From a3be9655a6155972d1b6673dfc80aeea5c0177c7 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 27 Jan 2024 02:51:11 -0500
Subject: [PATCH 01/74] feat(xlang-ir)!: Overhaul IR to a structured basic
 block form

---
 Cargo.lock                     |    2 +-
 c/src/lib.rs                   |    1 +
 codegen-clever/src/lib.rs      | 1164 +----------------
 codegen-x86/src/lib.rs         |    1 +
 lccc/src/main.rs               |   29 +-
 rust/src/irgen/xir_visitor.rs  | 2141 ++++++++------------------------
 rust/src/lib.rs                |    1 +
 rust/src/sema/mir.rs           |    1 +
 xir/src/lib.rs                 |   87 +-
 xlang/src/plugin.rs            |    2 +
 xlang/xlang_abi/src/alloc.rs   |    4 +-
 xlang/xlang_abi/src/vec.rs     |   48 +
 xlang/xlang_backend/src/lib.rs | 1108 +----------------
 xlang/xlang_backend/src/mc.rs  |  108 +-
 xlang/xlang_backend/src/ssa.rs |   30 +
 xlang/xlang_struct/Cargo.toml  |    2 +-
 xlang/xlang_struct/src/fmt.rs  |   69 +-
 xlang/xlang_struct/src/lib.rs  |  174 ++-
 18 files changed, 828 insertions(+), 4144 deletions(-)
 create mode 100644 xlang/xlang_backend/src/ssa.rs

diff --git a/Cargo.lock b/Cargo.lock
index 557b6564..1879da9e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -713,7 +713,7 @@ dependencies = [
 
 [[package]]
 name = "xlang_struct"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "bitflags",
  "fake-enum",
diff --git a/c/src/lib.rs b/c/src/lib.rs
index 2832dce2..2a9f2fef 100644
--- a/c/src/lib.rs
+++ b/c/src/lib.rs
@@ -57,6 +57,7 @@ impl XLangPlugin for CFrontend {
 xlang::host::rustcall! {
     #[allow(clippy::missing_const_for_fn)]
     #[no_mangle]
+    #[allow(improper_ctypes_definitions)]
     pub extern "rustcall" fn xlang_frontend_main() -> DynBox<dyn XLangFrontend> {
         DynBox::unsize_box(Box::new(CFrontend::new()))
     }
diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index 24318068..153443b4 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -1,1167 +1,11 @@
-use std::{
-    cell::RefCell, collections::HashSet, convert::TryFrom, ops::Deref, rc::Rc, str::FromStr,
-};
-
-use arch_ops::{
-    clever::{
-        CleverEncoder, CleverExtension, CleverImmediate, CleverIndex, CleverInstruction,
-        CleverOpcode, CleverOperand, CleverRegister,
-    },
-    traits::{Address, InsnWrite},
-};
-use binfmt::{
-    fmt::{FileType, Section, SectionType},
-    sym::{SymbolKind, SymbolType},
-};
-use target_tuples::{Architecture, Target};
-use xlang::{
-    abi::{
-        option::Option::{None as XLangNone, Some as XLangSome},
-        span::Span,
-        string::StringView,
-    },
-    plugin::{OutputMode, XLangCodegen, XLangPlugin},
-    prelude::v1::{DynBox, HashMap, Pair},
-    targets::properties::{MachineProperties, TargetProperties},
-};
-use xlang_backend::{
-    callconv::CallingConvention, expr::ValLocation, mangle::mangle_itanium, str::StringMap,
-    ty::TypeInformation, FunctionCodegen, FunctionRawCodegen,
-};
-use xlang_struct::{
-    AccessClass, AggregateDefinition, BinaryOp, FloatFormat, FnType, FunctionDeclaration,
-    PathComponent, ScalarType, ScalarTypeHeader, ScalarTypeKind, Type,
-};
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum CleverValLocation {
-    Register {
-        size: u16,
-        reg: CleverRegister,
-    },
-    Indirect {
-        size: u16,
-        reg: CleverRegister,
-        offset: i64,
-    },
-    Regs {
-        size: u64,
-        regs: Vec<CleverRegister>,
-    },
-    Null,
-    Unassigned(usize),
-}
-
-fn gcd(a: i64, b: i64) -> i64 {
-    if a == 0 {
-        b
-    } else if b == 0 {
-        a
-    } else {
-        gcd(b, a % b)
-    }
-}
-
-impl ValLocation for CleverValLocation {
-    fn addressible(&self) -> bool {
-        matches!(self, Self::Indirect { .. })
-    }
-
-    fn unassigned(n: usize) -> Self {
-        Self::Unassigned(n)
-    }
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum CleverInstructionOrLabel {
-    Insn(CleverInstruction),
-    Label(String),
-    FunctionEpilogue,
-}
-
-impl From<CleverInstruction> for CleverInstructionOrLabel {
-    fn from(insn: CleverInstruction) -> Self {
-        Self::Insn(insn)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TempSymbol(
-    String,
-    Option<&'static str>,
-    Option<usize>,
-    SymbolType,
-    SymbolKind,
-);
-
-#[allow(dead_code)]
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-enum RegisterStatus {
-    Free,
-    ToClobber,
-    MustSave,
-    InUse,
-    Saved {
-        loc: CleverValLocation,
-        next: Box<Self>,
-    },
-}
-
-pub struct CleverCallConv {
-    features: HashSet<CleverExtension>,
-    tys: Rc<TypeInformation>,
-}
-
-#[allow(dead_code)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum TypeClass {
-    Float,
-    Vec,
-    Integer,
-    Memory,
-    Zero,
-}
-
-#[allow(clippy::missing_panics_doc)] // TODO: remove todo!()
-#[must_use]
-pub fn classify_type(ty: &Type) -> Option<TypeClass> {
-    match ty {
-        Type::Scalar(ScalarType {
-            header:
-                ScalarTypeHeader {
-                    vectorsize: XLangSome(1..=65535),
-                    ..
-                },
-            ..
-        }) => Some(TypeClass::Vec),
-        Type::Scalar(ScalarType {
-            kind: ScalarTypeKind::Float { .. } | ScalarTypeKind::Posit,
-            ..
-        }) => Some(TypeClass::Float),
-        Type::Scalar(_) | Type::Pointer(_) => Some(TypeClass::Integer),
-        Type::Void | Type::FnType(_) | Type::Null => None,
-        Type::Array(ty) => classify_type(&ty.ty),
-        Type::TaggedType(_, ty) => classify_type(ty),
-        Type::Product(tys) => {
-            let mut infected = TypeClass::Zero;
-            for ty in tys {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Aligned(_, _) => todo!(),
-        Type::Aggregate(AggregateDefinition { fields, .. }) => {
-            let mut infected = TypeClass::Zero;
-            for ty in fields.iter().map(|field| &field.ty) {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Named(path) => todo!("named type {:?}", path),
-    }
-}
-
-impl CallingConvention for CleverCallConv {
-    type Loc = CleverValLocation;
-
-    fn pass_return_place(&self, ty: &xlang_struct::Type) -> Option<Self::Loc> {
-        match (classify_type(ty)?, self.tys.type_size(ty)?) {
-            (TypeClass::Memory, _) => todo!("memory"),
-            (_, 0..=8) => None,
-            _ => todo!("Oversized values"),
-        }
-    }
-
-    fn find_param(
-        &self,
-        fnty: &xlang_struct::FnType,
-        real: &xlang_struct::FnType,
-        param: u32,
-        infn: bool,
-    ) -> Self::Loc {
-        let mut int_regs = &[
-            CleverRegister::r2,
-            CleverRegister::r1,
-            CleverRegister::r3,
-            CleverRegister::r4,
-            CleverRegister::r5,
-            CleverRegister::r9,
-            CleverRegister::r10,
-            CleverRegister::r11,
-        ][..];
-        let mut float_regs = &[
-            CleverRegister::f0,
-            CleverRegister::f1,
-            CleverRegister::f2,
-            CleverRegister::f3,
-        ][..];
-
-        let mut last_loc = CleverValLocation::Unassigned(0);
-        if self.pass_return_place(&fnty.ret).is_some() {
-            int_regs = &int_regs[1..];
-        }
-        eprintln!("Finding param {} of {}", param, fnty);
-        for (i, ty) in fnty
-            .params
-            .iter()
-            .chain(core::iter::repeat(&Type::Void))
-            .take((param as usize) + 1)
-            .enumerate()
-        {
-            eprintln!("Classifying type {}", ty);
-            match (classify_type(ty).unwrap(), self.tys.type_size(ty).unwrap()) {
-                (TypeClass::Zero, _) => last_loc = CleverValLocation::Null,
-                (TypeClass::Memory, _) => panic!("Memory value"),
-                (TypeClass::Float, size @ (2 | 4 | 8)) => {
-                    let reg = float_regs[0];
-                    float_regs = &float_regs[1..];
-                    last_loc = CleverValLocation::Register {
-                        size: (size * 8) as u16,
-                        reg,
-                    };
-                }
-                (TypeClass::Integer, size @ 1..=8) | (TypeClass::Float, size @ 1) => {
-                    let reg = int_regs[0];
-                    int_regs = &int_regs[1..];
-                    let size = size.next_power_of_two() * 8;
-                    last_loc = CleverValLocation::Register {
-                        size: size as u16,
-                        reg,
-                    };
-                }
-                (TypeClass::Integer | TypeClass::Float, size @ 9..=16) => {
-                    let regs = int_regs[1..2].to_vec();
-                    int_regs = &int_regs[2..];
-                    last_loc = CleverValLocation::Regs { size, regs };
-                }
-
-                (_, _) => todo!("Memory value"),
-            }
-
-            if i == (param as usize) {
-                break;
-            }
-        }
-
-        last_loc
-    }
-
-    fn find_return_val(&self, fnty: &xlang_struct::FnType) -> Self::Loc {
-        match (
-            classify_type(&fnty.ret).unwrap(),
-            self.tys.type_size(&fnty.ret).unwrap(),
-        ) {
-            (TypeClass::Memory, _) => todo!("memory value"),
-            (_, 0) => CleverValLocation::Null,
-            (TypeClass::Integer, size @ 1..=8) => {
-                let size = size.next_power_of_two() * 8;
-                CleverValLocation::Register {
-                    size: size as u16,
-                    reg: CleverRegister::r0,
-                }
-            }
-            (TypeClass::Float, size @ (2 | 4 | 8)) => {
-                let size = size * 8;
-                CleverValLocation::Register {
-                    size: size as u16,
-                    reg: CleverRegister::f0,
-                }
-            }
-            _ => todo!("memory value"),
-        }
-    }
-}
-
-pub struct CleverFunctionCodegen {
-    insns: Vec<CleverInstructionOrLabel>,
-    symbols: Vec<TempSymbol>,
-    name: String,
-    strings: Rc<RefCell<StringMap>>,
-    frame_size: i32,
-    properties: &'static TargetProperties<'static>,
-    scratch_reg: Option<CleverRegister>,
-    callconv: CleverCallConv,
-    ptrreg: Option<CleverRegister>,
-    gpr_status: HashMap<CleverRegister, RegisterStatus>,
-    trap_unreachable: bool,
-    features: HashSet<CleverExtension>,
-    tys: Rc<TypeInformation>,
-}
-
-impl FunctionRawCodegen for CleverFunctionCodegen {
-    type Loc = CleverValLocation;
-
-    type CallConv = CleverCallConv;
-
-    fn write_trap(&mut self, trap: xlang_backend::expr::Trap) {
-        match trap {
-            xlang_backend::expr::Trap::Unreachable if !self.trap_unreachable => {}
-            xlang_backend::expr::Trap::Breakpoint => {
-                self.insns
-                    .push(CleverInstructionOrLabel::Insn(CleverInstruction::new(
-                        CleverOpcode::Int { i: 0 },
-                        vec![],
-                    )))
-            }
-            _ => self
-                .insns
-                .push(CleverInstructionOrLabel::Insn(CleverInstruction::new(
-                    CleverOpcode::Und0,
-                    vec![],
-                ))),
-        }
-    }
-
-    fn write_barrier(&mut self, acc: xlang_struct::AccessClass) {
-        match acc & AccessClass::ATOMIC_MASK {
-            AccessClass::AtomicRelaxed => {}
-            AccessClass::AtomicAcquire => {
-                let scratch = self.get_or_allocate_scratch_reg();
-                self.insns
-                    .push(CleverInstructionOrLabel::Insn(CleverInstruction::new(
-                        CleverOpcode::MovRS { r: scratch },
-                        vec![CleverOperand::Indirect {
-                            size: 8,
-                            base: CleverRegister::r7,
-                            scale: 1,
-                            index: CleverIndex::Abs(0),
-                        }],
-                    )));
-            }
-            AccessClass::AtomicRelease | AccessClass::AtomicAcqRel => {
-                let scratch = self.get_or_allocate_scratch_reg();
-                self.insns
-                    .push(CleverInstructionOrLabel::Insn(CleverInstruction::new(
-                        CleverOpcode::Or {
-                            lock: true,
-                            flags: false,
-                        },
-                        vec![
-                            CleverOperand::Indirect {
-                                size: 8,
-                                base: CleverRegister::r7,
-                                scale: 1,
-                                index: CleverIndex::Abs(0),
-                            },
-                            CleverOperand::Register {
-                                size: 8,
-                                reg: scratch,
-                            },
-                        ],
-                    )));
-            }
-            _ => self
-                .insns
-                .push(CleverInstruction::new(CleverOpcode::Fence, vec![]).into()),
-        }
-    }
-
-    fn write_int_binary_imm(
-        &mut self,
-        dest: Self::Loc,
-        a: Self::Loc,
-        b: u128,
-        ty: &xlang_struct::Type,
-        op: xlang_struct::BinaryOp,
-    ) {
-        todo!()
-    }
-
-    fn move_val(&mut self, src: Self::Loc, dest: Self::Loc) {
-        match (src, dest) {
-            (CleverValLocation::Unassigned(_), _) | (_, CleverValLocation::Unassigned(_)) => {
-                panic!("unassigned memory location")
-            }
-            (CleverValLocation::Regs { .. }, _) | (_, CleverValLocation::Regs { .. }) => {
-                todo!("regs")
-            }
-            (CleverValLocation::Null, _) | (_, CleverValLocation::Null) => {}
-            (
-                a,
-                CleverValLocation::Register {
-                    size: _,
-                    reg: r @ CleverRegister(0..=15),
-                },
-            ) => {
-                let ptrreg = self.get_or_allocate_pointer_reg();
-                let op1 = self.loc_to_operand(a, ptrreg).unwrap();
-
-                self.insns
-                    .push(CleverInstruction::new(CleverOpcode::MovRD { r }, vec![op1]).into());
-            }
-            (
-                CleverValLocation::Register {
-                    size: _,
-                    reg: r @ CleverRegister(0..=15),
-                },
-                a,
-            ) => {
-                let ptrreg = self.get_or_allocate_pointer_reg();
-                let op1 = self.loc_to_operand(a, ptrreg).unwrap();
-
-                self.insns
-                    .push(CleverInstruction::new(CleverOpcode::MovRS { r }, vec![op1]).into());
-            }
-            (a, b) => {
-                let ptrreg = self.get_or_allocate_pointer_reg();
-                let scratch = self.get_or_allocate_scratch_reg();
-
-                let op1 = self.loc_to_operand(a, ptrreg).unwrap();
-
-                self.insns.push(
-                    CleverInstruction::new(CleverOpcode::MovRD { r: scratch }, vec![op1]).into(),
-                );
-
-                let op2 = self.loc_to_operand(b, ptrreg).unwrap();
-
-                self.insns.push(
-                    CleverInstruction::new(CleverOpcode::MovRS { r: scratch }, vec![op2]).into(),
-                );
-            }
-        }
-    }
-
-    fn move_imm(&mut self, src: u128, dest: Self::Loc, ty: &xlang_struct::Type) {
-        match (dest, self.tys.type_size(ty).unwrap()) {
-            (CleverValLocation::Register { size, reg }, tysize @ 1..=8) => {
-                let imm_size = (128 - (src.leading_zeros())).min((tysize * 8) as u32);
-                let imm_val = if imm_size <= 12 {
-                    CleverImmediate::Short(src as u16)
-                } else {
-                    CleverImmediate::Long((((imm_size + 15) / 16) * 16) as u16, src as u64)
-                };
-
-                if reg.0 < 16 {
-                    self.insns.push(
-                        CleverInstruction::new(
-                            CleverOpcode::MovRD { r: reg },
-                            vec![CleverOperand::Immediate(imm_val)],
-                        )
-                        .into(),
-                    );
-                } else {
-                    self.insns.push(
-                        CleverInstruction::new(
-                            CleverOpcode::Mov,
-                            vec![
-                                CleverOperand::Register { size, reg },
-                                CleverOperand::Immediate(imm_val),
-                            ],
-                        )
-                        .into(),
-                    );
-                }
-            }
-            (loc, size) => todo!("move of size {} into {:?}", size, loc),
-        }
-    }
-
-    fn store_indirect_imm(&mut self, src: xlang_struct::Value, ptr: Self::Loc) {
-        todo!()
-    }
-
-    fn load_val(&mut self, lvalue: Self::Loc, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn store_indirect(&mut self, lvalue: Self::Loc, loc: Self::Loc, ty: &xlang_struct::Type) {
-        todo!()
-    }
-
-    fn get_callconv(&self) -> &Self::CallConv {
-        &self.callconv
-    }
-
-    fn native_int_size(&self) -> u16 {
-        64
-    }
-
-    fn native_float_size(&self) -> xlang::prelude::v1::Option<u16> {
-        if self.features.contains(&CleverExtension::Float) {
-            XLangSome(64)
-        } else {
-            XLangNone
-        }
-    }
-
-    fn native_vec_size(&self) -> xlang::prelude::v1::Option<u64> {
-        if self.features.contains(&CleverExtension::Vec) {
-            XLangSome(16)
-        } else {
-            XLangNone
-        }
-    }
-
-    fn preferred_vec_size(&self) -> xlang::abi::option::Option<u64> {
-        self.native_vec_size()
-    }
-
-    fn write_intrinsic(
-        &mut self,
-        name: xlang::abi::string::StringView,
-        params: xlang::vec::Vec<xlang_backend::expr::VStackValue<Self::Loc>>,
-    ) -> xlang_backend::expr::VStackValue<Self::Loc> {
-        todo!()
-    }
-
-    fn write_target(&mut self, target: u32) {
-        self.insns.push(CleverInstructionOrLabel::Label(format!(
-            "{}._T{}",
-            self.name, target
-        )))
-    }
-
-    fn call_direct(&mut self, path: &xlang_struct::Path, _realty: &FnType) {
-        let sym = match &*path.components {
-            [PathComponent::Text(n)] | [PathComponent::Root, PathComponent::Text(n)] => {
-                n.to_string()
-            }
-            [PathComponent::Root, rest @ ..] | [rest @ ..] => mangle_itanium(rest),
-        };
-
-        let addr = Address::PltSym { name: sym };
-
-        self.insns.push(
-            CleverInstruction::new(
-                CleverOpcode::CallR { ss: 2 },
-                vec![CleverOperand::Immediate(CleverImmediate::LongAddrRel(
-                    64, addr,
-                ))],
-            )
-            .into(),
-        );
-    }
-
-    fn call_indirect(&mut self, value: Self::Loc) {
-        todo!()
-    }
-
-    fn tailcall_direct(&mut self, path: &xlang_struct::Path, realty: &xlang_struct::FnType) {
-        todo!()
-    }
-
-    fn tailcall_indirect(&mut self, value: Self::Loc, realty: &xlang_struct::FnType) {
-        todo!()
-    }
-
-    fn leave_function(&mut self) {
-        self.insns.push(CleverInstructionOrLabel::FunctionEpilogue);
-    }
-
-    fn branch(&mut self, target: u32, condition: xlang_struct::BranchCondition, val: Self::Loc) {
-        todo!()
-    }
-
-    fn branch_compare(
-        &mut self,
-        target: u32,
-        condition: xlang_struct::BranchCondition,
-        v1: xlang_backend::expr::VStackValue<Self::Loc>,
-        v2: xlang_backend::expr::VStackValue<Self::Loc>,
-    ) {
-        todo!()
-    }
-
-    fn branch_unconditional(&mut self, target: u32) {
-        todo!()
-    }
-
-    fn branch_indirect(&mut self, target: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_global_address(&mut self, path: &xlang_struct::Path, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_label_address(&mut self, target: u32, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_parameter_address(&mut self, param: u32, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_local_address(&mut self, inloc: Self::Loc, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_string_address(
-        &mut self,
-        enc: xlang_backend::str::Encoding,
-        bytes: xlang::vec::Vec<u8>,
-        loc: Self::Loc,
-    ) {
-        let addr = self.strings.borrow_mut().get_string_symbol(bytes, enc);
-        let addr = Address::Symbol {
-            name: addr.to_string(),
-            disp: 0,
-        };
-        match loc {
-            CleverValLocation::Register { size, reg } => match (size, reg) {
-                (64, CleverRegister(0..=15)) => self.insns.push(
-                    CleverInstruction::new(
-                        CleverOpcode::LeaRD { r: reg },
-                        vec![CleverOperand::Immediate(CleverImmediate::LongMemRel(
-                            64, addr, 64,
-                        ))],
-                    )
-                    .into(),
-                ),
-                (size, reg) => self.insns.push(
-                    CleverInstruction::new(
-                        CleverOpcode::Lea,
-                        vec![
-                            CleverOperand::Register { size, reg },
-                            CleverOperand::Immediate(CleverImmediate::LongMemRel(64, addr, 64)),
-                        ],
-                    )
-                    .into(),
-                ),
-            },
-            CleverValLocation::Indirect { size, reg, offset } => todo!("indirect"),
-            CleverValLocation::Regs { size, regs } => todo!("registers"),
-            CleverValLocation::Null => {}
-            CleverValLocation::Unassigned(_) => panic!("Unassigned"),
-        }
-    }
-
-    fn free(&mut self, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn clobber(&mut self, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn allocate(&mut self, ty: &xlang_struct::Type, needs_addr: bool) -> Self::Loc {
-        todo!()
-    }
-
-    fn allocate_lvalue(&mut self, needs_addr: bool) -> Self::Loc {
-        todo!()
-    }
-
-    fn prepare_call_frame(&mut self, _: &xlang_struct::FnType, _: &xlang_struct::FnType) {
-        if self.frame_size & 15 != 0 {
-            self.frame_size = ((self.frame_size + 15) / 16) * 16;
-        }
-        /* TODO */
-    }
-
-    fn lockfree_use_libatomic(&mut self, _: u64) -> bool {
-        false
-    }
-
-    fn lockfree_cmpxchg_use_libatomic(&mut self, _: u64) -> bool {
-        false
-    }
-
-    fn has_wait_free_compound(&mut self, op: BinaryOp, size: u64) -> bool {
-        match op {
-            BinaryOp::Add
-            | BinaryOp::Sub
-            | BinaryOp::BitAnd
-            | BinaryOp::BitOr
-            | BinaryOp::BitXor
-            | BinaryOp::Lsh
-            | BinaryOp::Rsh => size < 128,
-            _ => false,
-        }
-    }
-
-    fn has_wait_free_compound_fetch(&mut self, op: BinaryOp, size: u64) -> bool {
-        false
-    }
-
-    fn compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: AccessClass,
-    ) {
-        todo!()
-    }
-
-    fn weak_compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: AccessClass,
-    ) {
-        todo!()
-    }
-
-    fn call_absolute(&mut self, addr: u128, _: &FnType) {
-        let addr = Address::Abs(addr);
-
-        self.insns.push(
-            CleverInstruction::new(
-                CleverOpcode::CallR { ss: 2 },
-                vec![CleverOperand::Immediate(CleverImmediate::LongAddrRel(
-                    64, addr,
-                ))],
-            )
-            .into(),
-        );
-    }
-
-    fn write_int_binary(
-        &mut self,
-        _dest: Self::Loc,
-        _a: Self::Loc,
-        _b: Self::Loc,
-        _ty: &Type,
-        _op: BinaryOp,
-    ) {
-        todo!()
-    }
-
-    fn write_unary(&mut self, _val: Self::Loc, _ty: &Type, _op: xlang_struct::UnaryOp) {
-        todo!()
-    }
-
-    fn write_asm(
-        &mut self,
-        asm: &xlang_struct::AsmExpr,
-        inputs: xlang::vec::Vec<xlang_backend::expr::VStackValue<Self::Loc>>,
-    ) -> xlang::vec::Vec<Self::Loc> {
-        todo!()
-    }
-
-    fn write_scalar_convert(
-        &mut self,
-        target_ty: ScalarType,
-        incoming_ty: ScalarType,
-        new_loc: Self::Loc,
-        old_loc: Self::Loc,
-    ) {
-        todo!()
-    }
-}
-
-impl CleverFunctionCodegen {
-    fn get_or_allocate_scratch_reg(&mut self) -> CleverRegister {
-        let Self {
-            scratch_reg,
-            gpr_status,
-            ..
-        } = self;
-        *scratch_reg.get_or_insert_with(|| {
-            for i in 0..16 {
-                match gpr_status.get_or_insert_mut(CleverRegister(i), RegisterStatus::Free) {
-                    RegisterStatus::Free | RegisterStatus::ToClobber => {
-                        gpr_status.insert(CleverRegister(i), RegisterStatus::InUse);
-                        return CleverRegister(i);
-                    }
-                    RegisterStatus::MustSave => {}
-                    RegisterStatus::InUse => {}
-                    RegisterStatus::Saved { .. } => {}
-                }
-            }
-
-            todo!("Save registers")
-        })
-    }
-
-    fn get_or_allocate_pointer_reg(&mut self) -> CleverRegister {
-        let Self {
-            ptrreg, gpr_status, ..
-        } = self;
-        *ptrreg.get_or_insert_with(|| {
-            for i in 0..16 {
-                match gpr_status.get_or_insert_mut(CleverRegister(i), RegisterStatus::Free) {
-                    RegisterStatus::Free | RegisterStatus::ToClobber => {
-                        gpr_status.insert(CleverRegister(i), RegisterStatus::InUse);
-                        return CleverRegister(i);
-                    }
-                    RegisterStatus::MustSave => {}
-                    RegisterStatus::InUse => {}
-                    RegisterStatus::Saved { .. } => {}
-                }
-            }
-
-            todo!("Save registers")
-        })
-    }
-
-    fn loc_to_operand(
-        &mut self,
-        loc: CleverValLocation,
-        sreg: CleverRegister,
-    ) -> Option<CleverOperand> {
-        match loc {
-            CleverValLocation::Register { size, reg } => {
-                Some(CleverOperand::Register { size, reg })
-            }
-            CleverValLocation::Indirect { size, reg, offset } => {
-                let scale = gcd(offset.abs(), 128);
-                let offset = offset / scale;
-                let idx = if (-8..8).contains(&offset) {
-                    CleverIndex::Abs(offset as i16)
-                } else {
-                    let size = ((((64 - (offset.leading_ones() + offset.leading_zeros())) + 15)
-                        / 16)
-                        * 16) as u16;
-
-                    self.insns.push(
-                        CleverInstruction::new(
-                            CleverOpcode::Movsx { flags: true },
-                            vec![
-                                CleverOperand::Register {
-                                    size: 64,
-                                    reg: sreg,
-                                },
-                                CleverOperand::Immediate(CleverImmediate::Long(
-                                    size,
-                                    offset as u64,
-                                )),
-                            ],
-                        )
-                        .into(),
-                    );
-                    CleverIndex::Register(sreg)
-                };
-                Some(CleverOperand::Indirect {
-                    size,
-                    base: reg,
-                    scale: scale as u8,
-                    index: idx,
-                })
-            }
-            CleverValLocation::Regs { .. } => None,
-            CleverValLocation::Null => None,
-            CleverValLocation::Unassigned(_) => panic!("unassigned location"),
-        }
-    }
-
-    #[allow(clippy::missing_errors_doc)]
-    #[allow(clippy::missing_panics_doc)]
-    pub fn write_output(
-        self,
-        text: &mut Section,
-        symbols: &mut Vec<TempSymbol>,
-    ) -> std::io::Result<()> {
-        let mut encoder = CleverEncoder::new(text);
-        if self.frame_size > 0 {
-            let size = 64 - self.frame_size.leading_zeros();
-            encoder.write_instruction(CleverInstruction::new(
-                CleverOpcode::PushR {
-                    r: CleverRegister::fbase,
-                },
-                vec![],
-            ))?;
-            encoder.write_instruction(CleverInstruction::new(
-                CleverOpcode::MovRD {
-                    r: CleverRegister::fbase,
-                },
-                vec![CleverOperand::Register {
-                    size: 64,
-                    reg: CleverRegister::sptr,
-                }],
-            ))?;
-            let val = if size <= 12 {
-                CleverImmediate::Short(self.frame_size as u16)
-            } else {
-                CleverImmediate::Long((((size + 15) / 16) * 16) as u16, self.frame_size as u64)
-            };
-            encoder.write_instruction(CleverInstruction::new(
-                CleverOpcode::SubRD {
-                    r: CleverRegister::sptr,
-                },
-                vec![CleverOperand::Immediate(val)],
-            ))?;
-        }
-        for item in self.insns {
-            match item {
-                CleverInstructionOrLabel::Label(num) => {
-                    symbols.push(TempSymbol(
-                        num.to_string(),
-                        Some(".text"),
-                        Some(encoder.offset()),
-                        SymbolType::Function,
-                        SymbolKind::Local,
-                    ));
-                }
-                CleverInstructionOrLabel::Insn(insn) => encoder.write_instruction(insn)?,
-                CleverInstructionOrLabel::FunctionEpilogue => {
-                    if self.frame_size > 0 {
-                        encoder.write_instruction(CleverInstruction::new(
-                            CleverOpcode::MovRD {
-                                r: CleverRegister::sptr,
-                            },
-                            vec![CleverOperand::Register {
-                                size: 64,
-                                reg: CleverRegister::fbase,
-                            }],
-                        ))?;
-                        encoder.write_instruction(CleverInstruction::new(
-                            CleverOpcode::PopR {
-                                r: CleverRegister::sptr,
-                            },
-                            Vec::new(),
-                        ))?;
-                    }
-                    encoder.write_instruction(CleverInstruction::new(CleverOpcode::Ret, vec![]))?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-pub struct CleverCodegenPlugin {
-    fns: Option<std::collections::HashMap<String, FunctionCodegen<CleverFunctionCodegen>>>,
-    strings: Rc<RefCell<StringMap>>,
-    properties: Option<&'static TargetProperties<'static>>,
-    features: HashSet<CleverExtension>,
-}
-
-impl CleverCodegenPlugin {
-    fn write_output_impl<W: std::io::Write>(&mut self, mut x: W) -> std::io::Result<()> {
-        let fmt = binfmt::format_by_name(&self.properties.unwrap().link.obj_binfmt).unwrap();
-        let mut file = fmt.create_file(FileType::Relocatable);
-        let mut text = Section {
-            name: String::from(".text"),
-            align: 1024,
-            ty: SectionType::ProgBits,
-            content: Vec::new(),
-            relocs: Vec::new(),
-            ..Section::default()
-        };
-
-        let mut rodata = Section {
-            name: String::from(".rodata"),
-            align: 1024,
-            ty: SectionType::ProgBits,
-            content: Vec::new(),
-            relocs: Vec::new(),
-            ..Section::default()
-        };
-
-        let mut syms = Vec::with_capacity(16);
-
-        syms.push(TempSymbol(
-            "_GLOBAL_OFFSET_TABLE_".into(),
-            None,
-            None,
-            SymbolType::Null,
-            SymbolKind::Global,
-        ));
-
-        for (enc, sym, str) in self.strings.borrow().symbols() {
-            let sym = TempSymbol(
-                sym.to_string(),
-                Some(".rodata"),
-                Some(rodata.content.len()),
-                SymbolType::Object,
-                SymbolKind::Local,
-            );
-            rodata.content.extend_from_slice(&enc.encode_utf8(str));
-            syms.push(sym);
-        }
-
-        for (name, mut output) in self.fns.take().unwrap() {
-            let sym = TempSymbol(
-                name.clone(),
-                Some(".text"),
-                Some(text.content.len()),
-                SymbolType::Function,
-                SymbolKind::Global,
-            ); // TODO: internal linkage is a thing
-            syms.push(sym);
-
-            syms.extend_from_slice(&output.raw_inner().symbols);
-            output.into_inner().write_output(&mut text, &mut syms)?;
-        }
-        file.add_section(text).unwrap();
-        file.add_section(rodata).unwrap();
-        for sym in syms {
-            let secno = sym
-                .1
-                .and_then(|v| file.sections().enumerate().find(|(_, s)| &*s.name == v))
-                .map(|(s, _)| u32::try_from(s).unwrap());
-            let fsym = file.get_or_create_symbol(&sym.0).unwrap();
-            *fsym.kind_mut() = sym.4;
-            if secno.is_some() {
-                *fsym.section_mut() = secno;
-                *fsym.value_mut() = sym.2.map(|v| v as u128);
-                *fsym.symbol_type_mut() = sym.3;
-            }
-        }
-
-        fmt.write_file(&mut x, &file)?;
-        Ok(())
-    }
-}
-
-impl XLangPlugin for CleverCodegenPlugin {
-    fn accept_ir(
-        &mut self,
-        ir: &mut xlang_struct::File,
-    ) -> xlang::abi::result::Result<(), xlang::plugin::Error> {
-        self.fns = Some(std::collections::HashMap::new());
-        let properties = self.properties.unwrap();
-
-        let mut tys = TypeInformation::from_properties(properties);
-
-        for Pair(path, member) in &ir.root.members {
-            match &member.member_decl {
-                xlang_struct::MemberDeclaration::AggregateDefinition(defn) => {
-                    tys.add_aggregate(path.clone(), defn.clone());
-                }
-                xlang_struct::MemberDeclaration::OpaqueAggregate(_) => {
-                    tys.add_opaque_aggregate(path.clone());
-                }
-                _ => {}
-            }
-        }
-
-        let tys = Rc::new(tys);
-
-        for Pair(path, member) in &ir.root.members {
-            let name = &*path.components;
-            let name = match name {
-                [xlang_struct::PathComponent::Root, xlang_struct::PathComponent::Text(t)]
-                | [xlang_struct::PathComponent::Text(t)] => t.to_string(),
-                [xlang_struct::PathComponent::Root, v @ ..] | [v @ ..] => {
-                    xlang_backend::mangle::mangle_itanium(v)
-                }
-            };
-
-            match &member.member_decl {
-                xlang_struct::MemberDeclaration::Function(FunctionDeclaration {
-                    ty,
-                    body: xlang::abi::option::Some(body),
-                    ..
-                }) => {
-                    let features = self.features.clone();
-                    let mut state = FunctionCodegen::new(
-                        CleverFunctionCodegen {
-                            insns: Vec::new(),
-                            symbols: Vec::new(),
-                            name: name.clone(),
-                            strings: self.strings.clone(),
-                            properties,
-                            gpr_status: HashMap::new(),
-                            frame_size: 0,
-                            scratch_reg: None,
-                            ptrreg: None,
-                            trap_unreachable: true,
-                            features: features.clone(),
-                            tys: tys.clone(),
-                            callconv: CleverCallConv {
-                                features,
-                                tys: tys.clone(),
-                            },
-                        },
-                        path.clone(),
-                        ty.clone(),
-                        properties,
-                        tys.clone(),
-                    );
-                    state.write_function_body(body);
-                    self.fns.as_mut().unwrap().insert(name.clone(), state);
-                }
-                xlang_struct::MemberDeclaration::Function(FunctionDeclaration {
-                    body: xlang::abi::option::None,
-                    ..
-                })
-                | xlang_struct::MemberDeclaration::Scope(_)
-                | xlang_struct::MemberDeclaration::Empty
-                | xlang_struct::MemberDeclaration::OpaqueAggregate(_)
-                | xlang_struct::MemberDeclaration::AggregateDefinition(_) => {}
-                xlang_struct::MemberDeclaration::Static(_) => todo!(),
-            }
-        }
-
-        xlang::abi::result::Ok(())
-    }
-
-    #[allow(clippy::needless_borrow)] // Incorrect lint
-    fn set_target(&mut self, targ: &'static TargetProperties<'static>) {
-        self.properties = Some(targ);
-        self.features = get_features_from_properties(targ, targ.arch.default_machine);
-    }
-}
-
-fn get_features_from_properties(
-    properties: &'static TargetProperties,
-    machine: &'static MachineProperties,
-) -> HashSet<CleverExtension> {
-    let mut names = HashSet::new();
-    for &f in machine.default_features {
-        names.insert(f);
-    }
-    for &Pair(name, val) in properties.enabled_features {
-        if val {
-            names.insert(name);
-        } else {
-            names.remove(&name);
-        }
-    }
-
-    names
-        .into_iter()
-        .map(xlang::abi::string::StringView::into_str)
-        .map(CleverExtension::from_str)
-        .collect::<Result<_, _>>()
-        .unwrap()
-}
-
-impl XLangCodegen for CleverCodegenPlugin {
-    fn target_matches(&self, x: StringView) -> bool {
-        let target: target_tuples::Target = x.parse().unwrap();
-
-        matches!(target.arch(), Architecture::Clever)
-    }
-
-    fn write_output(
-        &mut self,
-        x: xlang::prelude::v1::DynMut<dyn xlang::abi::io::Write>,
-        mode: OutputMode,
-    ) -> xlang::abi::io::Result<()> {
-        let wrapper = xlang::abi::io::WriteAdapter::new(x);
-        if mode != OutputMode::Obj {
-            todo!("asm output")
-        }
-        self.write_output_impl(wrapper).map_err(Into::into).into()
-    }
-
-    fn set_features(&mut self, features: Span<StringView>) {
-        self.features = features
-            .iter()
-            .map(Deref::deref)
-            .map(CleverExtension::from_str)
-            .collect::<Result<_, _>>()
-            .unwrap();
-    }
-}
+use xlang::plugin::XLangCodegen;
+use xlang::prelude::v1::*;
 
 xlang::host::rustcall! {
 #[no_mangle]
+#[allow(improper_ctypes_definitions)]
 pub extern "rustcall" fn xlang_backend_main() -> DynBox<dyn XLangCodegen> {
-    DynBox::unsize_box(xlang::prelude::v1::Box::new(CleverCodegenPlugin {
-        fns: Some(std::collections::HashMap::new()),
-        strings: Rc::new(RefCell::new(StringMap::new())),
-        properties: None,
-        features: HashSet::new()
-    }))
+    todo!()
 }}
 
 xlang::plugin_abi_version!("0.1");
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 24df1ad3..cc216189 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -9,6 +9,7 @@ use xlang::{
 
 xlang::host::rustcall! {
 #[no_mangle]
+#[allow(improper_ctypes_definitions)]
 pub extern "rustcall" fn xlang_backend_main() -> DynBox<dyn XLangCodegen> {
     DynBox::unsize_box(Box::new(xlang_backend::mc::MCBackend::new(mc::new_writer())))
 }}
diff --git a/lccc/src/main.rs b/lccc/src/main.rs
index 82aa3621..d6eb0e74 100644
--- a/lccc/src/main.rs
+++ b/lccc/src/main.rs
@@ -141,6 +141,13 @@ fn main() {
             TakesArg::Never,
             true
         ),
+        ArgSpec::new(
+            "printxir",
+            xlang::vec!["print-xir"],
+            Vec::new(),
+            TakesArg::Never,
+            true
+        ),
         ArgSpec::new(
             "shared",
             xlang::vec!["shared"],
@@ -216,6 +223,7 @@ fn main() {
             "output" => output = arg.value.clone(),
             "compile" => mode = Mode::CompileOnly,
             "typeck" => mode = Mode::TypeCheck,
+            "printxir" => mode = Mode::Xir,
             "pluginpath" => {
                 let arg = arg.value.as_ref().unwrap();
                 let (name, path) = arg.split_once('=').unwrap();
@@ -456,9 +464,14 @@ fn main() {
     );
 
     let mut codegen_handles = Vec::new();
-    for codegen_path in &codegen_paths {
-        codegen_handles.push(Handle::open(codegen_path).expect("couldn't load frontend library"));
+
+    if mode > Mode::Xir {
+        for codegen_path in &codegen_paths {
+            codegen_handles
+                .push(Handle::open(codegen_path).expect("couldn't load frontend library"));
+        }
     }
+
     let mut codegens = Vec::new();
     for codegen_handle in &codegen_handles {
         let initializer: lccc::CodegenInit =
@@ -478,12 +491,6 @@ fn main() {
         }
     }
 
-    let codegen = if let Some(cg) = codegen {
-        cg
-    } else {
-        panic!("couldn't find a backend for target {}", xtarget)
-    };
-
     for file in &files {
         let mut file_path = Path::new(file).canonicalize().unwrap();
         file_path.pop();
@@ -585,6 +592,11 @@ fn main() {
             }
 
             if mode >= Mode::Asm {
+                let codegen = if let Some(cg) = &mut codegen {
+                    cg
+                } else {
+                    panic!("couldn't find a backend for target {}", xtarget)
+                };
                 codegen.set_target(properties);
                 codegen.set_features(Span::new(&features));
                 codegen.accept_ir(&mut file).unwrap();
@@ -600,7 +612,6 @@ fn main() {
                     .unwrap();
                 // TODO: Handle `-S` and write assembly instead of an object
             } else if mode == Mode::Xir {
-                todo!()
             }
         } else {
             file_pairs.push((file.clone(), file.clone()));
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 7936b45c..3d5e3d28 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -7,7 +7,7 @@ use xlang::ir::{
 };
 use xlang::prelude::v1::{HashMap, Pair};
 use xlang::targets::properties::TargetProperties;
-use xlang::{abi::string::String as XLangString, abi::vec::Vec, vec};
+use xlang::{abi::boxed::Box as XLangBox, abi::string::String as XLangString, abi::vec::Vec, vec};
 use xlang::{
     abi::{
         self,
@@ -16,6 +16,7 @@ use xlang::{
     ir::PathComponent,
 };
 
+use crate::sema::mir;
 use crate::sema::{cx, hir::BinaryOp, mir::SsaVarId};
 use crate::sema::{generics, ty, UserTypeKind};
 use crate::sema::{mir::UnaryOp, ty::Mutability};
@@ -568,7 +569,6 @@ impl<'a> FunctionDefVisitor for XirFunctionDefVisitor<'a> {
             self.names,
             self.properties,
             self.deftys,
-            self.file,
             &mut self.fndef.ty,
             self.fndef.body.insert(ir::FunctionBody::default()),
         )))
@@ -951,64 +951,37 @@ pub struct XirFunctionBodyVisitor<'a> {
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    file: &'a mut ir::File,
     cur_fnty: &'a mut ir::FnType,
     fndecl: &'a mut ir::FunctionBody,
-    targs: HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: HashMap<SsaVarId, u32>,
     ssa_tys: HashMap<SsaVarId, ir::Type>,
-    stack_height: u32,
 }
 
 impl<'a> XirFunctionBodyVisitor<'a> {
-    fn new(
+    pub fn new(
         defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        file: &'a mut ir::File,
         cur_fnty: &'a mut ir::FnType,
         fndecl: &'a mut ir::FunctionBody,
     ) -> Self {
-        let mut result = Self {
-            stack_height: cur_fnty.params.len() as u32,
+        Self {
             defs,
             names,
             properties,
             deftys,
-            file,
-            fndecl,
             cur_fnty,
-            targs: HashMap::new(),
-            var_heights: HashMap::new(),
+            fndecl,
             ssa_tys: HashMap::new(),
-        };
-
-        for (idx, ty) in result.cur_fnty.params.iter().enumerate() {
-            let id = SsaVarId(idx as u32);
-            result.var_heights.insert(id, idx as u32);
-            result.ssa_tys.insert(id, ty.clone());
         }
-
-        result
     }
 }
 
-impl<'a> Drop for XirFunctionBodyVisitor<'a> {
-    fn drop(&mut self) {
-        for stat in self.fndecl.block.items.iter_mut() {
-            if let ir::BlockItem::Target { num, stack } = stat {
-                *stack = core::mem::take(
-                    self.targs
-                        .get_mut(num)
-                        .expect("must have visited the basic block first"),
-                );
-            }
-        }
+impl<'a> FunctionBodyVisitor for XirFunctionBodyVisitor<'a> {
+    fn visit_inner_value(&mut self) -> Option<Box<dyn ValueDefVisitor + '_>> {
+        todo!()
     }
-}
 
-impl<'a> FunctionBodyVisitor for XirFunctionBodyVisitor<'a> {
     fn visit_basic_block(&mut self) -> Option<Box<dyn BasicBlockVisitor + '_>> {
         Some(Box::new(XirBasicBlockVisitor::new(
             self.defs,
@@ -1016,21 +989,9 @@ impl<'a> FunctionBodyVisitor for XirFunctionBodyVisitor<'a> {
             self.properties,
             self.deftys,
             self.cur_fnty,
-            self.fndecl,
-            &mut self.targs,
-            &mut self.var_heights,
+            self.fndecl.blocks.push_mut(ir::Block::default()),
+            &mut self.fndecl.locals,
             &mut self.ssa_tys,
-            self.stack_height,
-        )))
-    }
-
-    fn visit_inner_value(&mut self) -> Option<Box<dyn ValueDefVisitor + '_>> {
-        Some(Box::new(XirValueDefVisitor::new(
-            self.defs,
-            self.names,
-            self.deftys,
-            self.file,
-            self.properties,
         )))
     }
 }
@@ -1041,27 +1002,24 @@ pub struct XirBasicBlockVisitor<'a> {
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
     cur_fnty: &'a mut ir::FnType,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    block: &'a mut ir::Block,
+    locals: &'a mut Vec<ir::Type>,
     ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: u32,
-    bb_id: BasicBlockId,
-    incoming_vars: Vec<SsaVarId>,
+    var_heights: HashMap<SsaVarId, u32>,
+    var_stack: Vec<SsaVarId>,
 }
 
 impl<'a> XirBasicBlockVisitor<'a> {
-    fn new(
+    pub fn new(
         defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
         cur_fnty: &'a mut ir::FnType,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        block: &'a mut ir::Block,
+        locals: &'a mut Vec<ir::Type>,
         ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-        stack_height: u32,
     ) -> Self {
         Self {
             defs,
@@ -1069,39 +1027,39 @@ impl<'a> XirBasicBlockVisitor<'a> {
             properties,
             deftys,
             cur_fnty,
-            body,
-            targs,
-            var_heights,
+            block,
+            locals,
             ssa_tys,
-            stack_height,
-            bb_id: BasicBlockId(u32::MAX),
-            incoming_vars: vec![],
+            stack_height: 0,
+            var_heights: HashMap::new(),
+            var_stack: Vec::new(),
         }
     }
 }
 
 impl<'a> BasicBlockVisitor for XirBasicBlockVisitor<'a> {
-    fn visit_id(&mut self, bb_id: BasicBlockId) {
-        self.targs.get_or_insert_mut(bb_id, Vec::new());
-        self.body.block.items.push(ir::BlockItem::Target {
-            num: bb_id.id(),
-            stack: vec![],
-        });
-        self.bb_id = bb_id;
+    fn visit_id(&mut self, id: mir::BasicBlockId) {
+        self.block.target = id.id();
     }
 
     fn visit_incoming_var(&mut self, incoming: SsaVarId) -> Option<Box<dyn TypeVisitor + '_>> {
-        self.stack_height += 1;
         let height = self.stack_height;
+        self.stack_height += 1;
         self.var_heights.insert(incoming, height);
 
-        let ty = self.ssa_tys.get_or_insert_mut(incoming, ir::Type::Null);
-        self.incoming_vars.push(incoming);
+        self.var_stack.push(incoming);
 
         Some(Box::new(XirTypeVisitor::new(
             self.defs,
             self.names,
-            ty,
+            &mut self
+                .block
+                .incoming_stack
+                .push_mut(ir::StackItem {
+                    ty: ir::Type::Null,
+                    kind: ir::StackValueKind::RValue,
+                })
+                .ty,
             self.properties,
         )))
     }
@@ -1113,11 +1071,12 @@ impl<'a> BasicBlockVisitor for XirBasicBlockVisitor<'a> {
             self.properties,
             self.deftys,
             self.cur_fnty,
-            self.body,
-            self.targs,
-            &mut self.var_heights,
-            &mut self.ssa_tys,
+            &mut self.block.expr,
+            self.locals,
+            self.ssa_tys,
             &mut self.stack_height,
+            &mut self.var_heights,
+            &mut self.var_stack,
         )))
     }
 
@@ -1128,39 +1087,28 @@ impl<'a> BasicBlockVisitor for XirBasicBlockVisitor<'a> {
             self.properties,
             self.deftys,
             self.cur_fnty,
-            self.body,
-            self.targs,
-            &mut self.var_heights,
-            &mut self.ssa_tys,
+            self.block,
+            self.locals,
+            self.ssa_tys,
             &mut self.stack_height,
+            &mut self.var_heights,
+            &mut self.var_stack,
         )))
     }
 }
 
-impl<'a> Drop for XirBasicBlockVisitor<'a> {
-    fn drop(&mut self) {
-        let targs = self.targs.get_mut(&self.bb_id).unwrap();
-        for incoming in &self.incoming_vars {
-            let ty = self.ssa_tys[incoming].clone();
-            targs.push(ir::StackItem {
-                ty,
-                kind: ir::StackValueKind::RValue,
-            });
-        }
-    }
-}
-
 pub struct XirTerminatorVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
     cur_fnty: &'a mut ir::FnType,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
+    block: &'a mut ir::Block,
+    locals: &'a mut Vec<ir::Type>,
     ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
     stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
 }
 
 impl<'a> XirTerminatorVisitor<'a> {
@@ -1170,11 +1118,12 @@ impl<'a> XirTerminatorVisitor<'a> {
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
         cur_fnty: &'a mut ir::FnType,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        block: &'a mut ir::Block,
+        locals: &'a mut Vec<ir::Type>,
         ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
@@ -1182,130 +1131,158 @@ impl<'a> XirTerminatorVisitor<'a> {
             properties,
             deftys,
             cur_fnty,
-            body,
-            targs,
+            block,
+            locals,
             ssa_tys,
-            var_heights,
             stack_height,
+            var_heights,
+            var_stack,
         }
     }
 }
 
 impl<'a> TerminatorVisitor for XirTerminatorVisitor<'a> {
+    fn visit_branch(&mut self) -> Option<Box<dyn BranchVisitor + '_>> {
+        todo!()
+    }
+
     fn visit_call(&mut self) -> Option<Box<dyn CallVisitor + '_>> {
         Some(Box::new(XirCallVisitor::new(
             self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.block,
+            self.locals,
             self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
     fn visit_jump(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
+        let targ = {
+            self.block.term = ir::Terminator::Jump(ir::JumpTarget {
+                target: !0,
+                flags: ir::JumpTargetFlags::empty(),
+            });
+
+            match &mut self.block.term {
+                ir::Terminator::Jump(targ) => targ,
+                _ => unsafe { core::hint::unreachable_unchecked() },
+            }
+        };
+
         Some(Box::new(XirJumpVisitor::new(
+            self.defs,
             self.names,
             self.properties,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.deftys,
+            self.cur_fnty,
+            &mut self.block.expr,
+            targ,
+            self.locals,
             self.ssa_tys,
             self.stack_height,
-            ir::BranchCondition::Always,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
     fn visit_return(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirReturnVisitor(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        ))))
-    }
-
-    fn visit_branch(&mut self) -> Option<Box<dyn BranchVisitor + '_>> {
-        Some(Box::new(XirBranchVisitor::new(
+        self.block.term = ir::Terminator::Exit(1);
+        Some(Box::new(XirExprVisitor::new(
             self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            &mut self.block.expr,
+            self.locals,
             self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 }
 
-pub struct XirReturnVisitor<'a>(XirExprVisitor<'a>);
-
-impl<'a> ExprVisitor for XirReturnVisitor<'a> {
-    fn visit_unreachable(&mut self) {
-        self.0.visit_unreachable()
-    }
-
-    fn visit_const_int(&mut self) -> Option<Box<dyn ConstIntVisitor + '_>> {
-        self.0.visit_const_int()
-    }
-
-    fn visit_const(&mut self, defid: DefId) {
-        self.0.visit_const(defid)
-    }
-
-    fn visit_cast(&mut self) -> Option<Box<dyn CastVisitor + '_>> {
-        self.0.visit_cast()
-    }
-
-    fn visit_const_string(&mut self) -> Option<Box<dyn ConstStringVisitor + '_>> {
-        self.0.visit_const_string()
-    }
-
-    fn visit_var(&mut self, var: SsaVarId) {
-        self.0.visit_var(var)
-    }
+pub struct XirJumpVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    targ: &'a mut ir::JumpTarget,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+}
 
-    fn visit_tuple(&mut self) -> Option<Box<dyn super::visitor::TupleExprVisitor + '_>> {
-        self.0.visit_tuple()
+impl<'a> XirJumpVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        targ: &'a mut ir::JumpTarget,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            targ,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+        }
     }
+}
 
-    fn visit_ctor(&mut self) -> Option<Box<dyn ConstructorVisitor + '_>> {
-        self.0.visit_ctor()
+impl<'a> JumpVisitor for XirJumpVisitor<'a> {
+    fn visit_target_bb(&mut self, targbb: mir::BasicBlockId) {
+        self.targ.target = targbb.id();
     }
 
-    fn visit_field_subobject(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        self.0.visit_field_subobject()
-    }
+    fn visit_remap(&mut self, src: mir::SsaVarId, _: mir::SsaVarId) {
+        let height = self.var_heights.remove(&src).unwrap().1;
+        let i = self
+            .var_stack
+            .iter()
+            .enumerate()
+            .skip_while(|(_, v)| *v != &src)
+            .map(|(off, _)| off)
+            .next()
+            .unwrap();
 
-    fn visit_field_project(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        self.0.visit_field_project()
-    }
+        self.var_stack.remove(i);
 
-    fn visit_binary_expr(&mut self) -> Option<Box<dyn BinaryExprVisitor + '_>> {
-        self.0.visit_binary_expr()
-    }
+        for var in &self.var_stack[i..] {
+            self.var_heights[var] -= 1;
+        }
 
-    fn visit_unary_expr(&mut self) -> Option<Box<dyn UnaryExprVisitor + '_>> {
-        self.0.visit_unary_expr()
-    }
-}
+        let depth = (*self.stack_height) - (height + 1);
 
-impl<'a> Drop for XirReturnVisitor<'a> {
-    fn drop(&mut self) {
-        self.0
-            .body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Exit { values: 1 }))
+        if depth != 0 {
+            self.exprs.push(ir::Expr::Pivot(depth, 1));
+        }
     }
 }
 
@@ -1314,14 +1291,16 @@ pub struct XirCallVisitor<'a> {
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    cur_fnty: &'a mut ir::FnType,
+    block: &'a mut ir::Block,
+    locals: &'a mut Vec<ir::Type>,
     ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
-    retplace: Option<SsaVarId>,
-    fnty: Option<ir::FnType>,
-    late_invoke_intrin: Option<(IntrinsicDef, generics::GenericArgs)>,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    late_bound_intrinsic: Option<IntrinsicDef>,
+    fnty: ir::FnType,
+    targ: Option<ir::JumpTarget>,
 }
 
 impl<'a> XirCallVisitor<'a> {
@@ -1330,33 +1309,35 @@ impl<'a> XirCallVisitor<'a> {
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        cur_fnty: &'a mut ir::FnType,
+        block: &'a mut ir::Block,
+        locals: &'a mut Vec<ir::Type>,
         ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
             names,
-            body,
+            properties,
             deftys,
-            targs,
-            var_heights,
+            cur_fnty,
+            block,
+            locals,
             ssa_tys,
             stack_height,
-            retplace: None,
-            fnty: None,
-            properties,
-            late_invoke_intrin: None,
+            var_heights,
+            var_stack,
+            late_bound_intrinsic: None,
+            fnty: ir::FnType::default(),
+            targ: None,
         }
     }
 }
 
 impl<'a> CallVisitor for XirCallVisitor<'a> {
-    fn visit_retplace(&mut self, retplace: SsaVarId) {
-        self.retplace = Some(retplace);
-    }
+    fn visit_retplace(&mut self, _: mir::SsaVarId) {}
 
     fn visit_target(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
         Some(Box::new(XirExprVisitor::new(
@@ -1364,10 +1345,13 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            &mut self.block.expr,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
@@ -1375,7 +1359,7 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
         Some(Box::new(XirFunctionTyVisitor::new(
             self.defs,
             self.names,
-            self.fnty.insert(ir::FnType::default()),
+            &mut self.fnty,
             self.properties,
         )))
     }
@@ -1386,603 +1370,203 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            &mut self.block.expr,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
-    fn visit_tailcall(&mut self) {
-        let fnty = self.fnty.take().expect("visit_fnty must have been called");
-
-        let is_never = fnty.ret == NEVER;
-
-        if let Some((intrin, generics)) = self.late_invoke_intrin.take() {
-            // Handle late bound intrinsics here
-            match intrin {
-                IntrinsicDef::__builtin_unreachable => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Invalid(
-                            fnty.ret,
-                        ))));
-                }
-                IntrinsicDef::impl_id => todo!("impl_id"),
-                IntrinsicDef::type_id => todo!("type_id"),
-                IntrinsicDef::type_name => todo!("type_name"),
-                IntrinsicDef::destroy_at => todo!("destroy_at"),
-                IntrinsicDef::discriminant => todo!("discriminant"),
-
-                IntrinsicDef::construct_in_place => todo!("construct_in_place"),
-                IntrinsicDef::__builtin_read => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_read_freeze => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Freeze,
-                        )));
-                }
-                IntrinsicDef::__builtin_read_volatile => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Volatile,
-                        )));
-                }
-                IntrinsicDef::__builtin_write => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Pivot(1, 1)));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Assign(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_write_volatile => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Pivot(1, 1)));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Assign(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_size_of => todo!(),
-                IntrinsicDef::__builtin_align_of => todo!(),
-                IntrinsicDef::__builtin_size_of_val => todo!(),
-                IntrinsicDef::__builtin_align_of_val => todo!(),
-
-                IntrinsicDef::__builtin_abort
-                | IntrinsicDef::__builtin_allocate
-                | IntrinsicDef::__builtin_deallocate
-                | IntrinsicDef::transmute
-                | IntrinsicDef::black_box
-                | IntrinsicDef::__builtin_likely
-                | IntrinsicDef::__builtin_unlikely => {
-                    unreachable!("These are handled like regular functions")
-                }
-            }
-            self.body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::Exit { values: 1 }));
-        } else {
-            // Either we're compatible or we're `!` and don't return
-            self.body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::Tailcall(fnty)));
-        }
-    }
-
     fn visit_next(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
-        let fnty = self.fnty.take().expect("visit_fnty must be called first");
-        let retty = fnty.ret.clone();
-        *self.stack_height -= fnty.params.len() as u32;
-
-        if let Some((intrin, generics)) = self.late_invoke_intrin.take() {
-            // Handle late bound intrinsics here
-            // Assume that params are correct - yes, this will bork irgen if the params are wrong
-            match intrin {
-                IntrinsicDef::__builtin_unreachable => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Invalid(
-                            retty.clone(),
-                        ))));
-                }
-                IntrinsicDef::impl_id => todo!("impl_id"),
-                IntrinsicDef::type_id => todo!("type_id"),
-                IntrinsicDef::type_name => todo!("type_name"),
-                IntrinsicDef::destroy_at => todo!("destroy_at"),
-                IntrinsicDef::discriminant => todo!("discriminant"),
-
-                IntrinsicDef::construct_in_place => todo!("construct_in_place"),
-                IntrinsicDef::__builtin_read => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_read_freeze => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Freeze,
-                        )));
-                }
-                IntrinsicDef::__builtin_read_volatile => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::AsRValue(
-                            ir::AccessClass::Volatile,
-                        )));
-                }
-                IntrinsicDef::__builtin_write => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Pivot(1, 1)));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Assign(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_write_volatile => {
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Pivot(1, 1)));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Indirect));
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Assign(
-                            ir::AccessClass::Normal,
-                        )));
-                }
-                IntrinsicDef::__builtin_size_of => {
-                    let ty = match generics.params.into_iter().next().unwrap() {
-                        generics::GenericArg::Type(ty) => ty,
-                        _ => unreachable!(),
-                    };
-
-                    let layout = self.defs.layout_of(&ty, DefId::ROOT, DefId::ROOT);
-
-                    let size = layout
-                        .size
-                        .expect("__builtin_size_of requires a Sized type");
-
-                    let intty = match &retty {
-                        ir::Type::Scalar(sty) => *sty,
-                        _ => unreachable!("__builtin_size_of returns `usize`"),
-                    };
-
-                    self.body
-                        .block
-                        .items
-                        .push(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Integer {
-                            ty: intty,
-                            val: size as u128,
-                        })));
-                }
-                IntrinsicDef::__builtin_align_of => todo!(),
-                IntrinsicDef::__builtin_size_of_val => todo!(),
-                IntrinsicDef::__builtin_align_of_val => todo!(),
-
-                IntrinsicDef::__builtin_abort
-                | IntrinsicDef::__builtin_allocate
-                | IntrinsicDef::__builtin_deallocate
-                | IntrinsicDef::transmute
-                | IntrinsicDef::black_box
-                | IntrinsicDef::__builtin_likely
-                | IntrinsicDef::__builtin_unlikely => unreachable!(),
-            }
-        } else {
-            self.body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::CallFunction(fnty)));
-        }
-
-        Some(Box::new(XirNextBlockVisitor {
-            inner: XirJumpVisitor::new(
-                self.names,
-                self.properties,
-                self.body,
-                self.targs,
-                self.var_heights,
-                self.ssa_tys,
-                self.stack_height,
-                ir::BranchCondition::Always,
-            ),
-            retty,
-            targ: None,
-        }))
+        Some(Box::new(XirJumpVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            &mut self.block.expr,
+            self.targ.insert(ir::JumpTarget {
+                flags: ir::JumpTargetFlags::empty(),
+                target: !0,
+            }),
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 
     fn visit_intrinsic(&mut self, intrin: IntrinsicDef, generics: &generics::GenericArgs) {
-        let (item, fnty) = match intrin {
-            // Rust sym calls
-            func @ (IntrinsicDef::__builtin_allocate | IntrinsicDef::__builtin_deallocate) => {
-                let layout_ty = self
-                    .defs
-                    .get_lang_item(LangItem::LayoutTy)
-                    .expect("lang item `layout` is required to use `__builtin_alloc`");
-                let u8_ptr = ty::Type::Pointer(
-                    span::synthetic(Mutability::Mut),
-                    Box::new(span::synthetic(ty::Type::Int(ty::IntType::u8))),
-                );
-                let (sym, sig) = match func {
-                    IntrinsicDef::__builtin_allocate => {
-                        let alloc_sym = self.defs.get_lang_item(LangItem::AllocSym).expect(
-                            "lang item `alloc_symbol` is required to use `__builtin_alloc`",
-                        );
-
-                        let fnty = ty::FnType {
-                            safety: span::synthetic(ty::Safety::Unsafe),
-                            constness: span::synthetic(ty::Mutability::Mut),
-                            asyncness: span::synthetic(ty::AsyncType::Normal),
-                            tag: span::synthetic(ty::AbiTag::LCRust(None)),
-                            retty: Box::new(span::synthetic(u8_ptr)),
-                            paramtys: std::vec![span::synthetic(ty::Type::UserType(
-                                layout_ty,
-                                Default::default()
-                            ))],
-                            iscvarargs: span::synthetic(false),
-                        };
-
-                        (alloc_sym, fnty)
-                    }
-                    IntrinsicDef::__builtin_deallocate => {
-                        let dealloc_sym = self.defs.get_lang_item(LangItem::DeallocSym).expect(
-                            "lang item `deaalloc_symbol` is required to use `__builtin_alloc`",
-                        );
-
-                        let fnty = ty::FnType {
-                            safety: span::synthetic(ty::Safety::Unsafe),
-                            constness: span::synthetic(ty::Mutability::Mut),
-                            asyncness: span::synthetic(ty::AsyncType::Normal),
-                            tag: span::synthetic(ty::AbiTag::LCRust(None)),
-                            retty: Box::new(span::synthetic(ty::Type::UNIT)),
-                            paramtys: std::vec![
-                                span::synthetic(ty::Type::UserType(layout_ty, Default::default())),
-                                span::synthetic(u8_ptr),
-                            ],
-                            iscvarargs: span::synthetic(false),
-                        };
-
-                        (dealloc_sym, fnty)
-                    }
-                    _ => unreachable!(),
-                };
-
-                let name = self.names[&sym];
-                let mut ir_fnty = ir::FnType::default();
-                let fnty_vis =
-                    XirFunctionTyVisitor::new(self.defs, self.names, &mut ir_fnty, self.properties);
-
-                super::visitor::visit_fnty(fnty_vis, &sig, &self.defs);
-
-                let path = ir::Path {
-                    components: vec![ir::PathComponent::Text((&name).into())],
-                };
-
-                (path, ir_fnty)
-            }
-
-            // xlang intrinsics
-            xlang_intrin @ (IntrinsicDef::__builtin_abort
-            | IntrinsicDef::transmute
-            | IntrinsicDef::black_box
-            | IntrinsicDef::__builtin_likely
-            | IntrinsicDef::__builtin_unlikely) => {
-                let path = match xlang_intrin {
-                    IntrinsicDef::__builtin_abort => {
-                        ir::simple_path!(__lccc::intrinsics::C::__builtin_trap)
-                    }
-                    IntrinsicDef::transmute => {
-                        ir::simple_path!(__lccc::intrinsics::Rust::__builtin_transmute)
-                    }
-                    IntrinsicDef::black_box => ir::simple_path!(__lccc::xlang::deoptimize),
-                    IntrinsicDef::__builtin_likely => ir::simple_path!(__lccc::xlang::likely),
-                    IntrinsicDef::__builtin_unlikely => ir::simple_path!(__lccc::xlang::unlikely),
-                    _ => unreachable!(),
-                };
-
-                (
-                    path,
-                    self.fnty
-                        .as_ref()
-                        .cloned()
-                        .expect("visit_fnty must have been called first"),
-                )
-            }
-
-            // late bound intrinsics (Few of these should survive to irgen?)
-            intrin => return self.late_invoke_intrin = Some((intrin, generics.clone())),
-        };
-
-        let ty = ir::Type::FnType((xlang::abi::boxed::Box::new(fnty)));
-
-        let value = ir::Value::GlobalAddress { ty, item };
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Const(value)));
+        todo!("{}{}", intrin.name(), generics)
     }
-}
-
-pub struct XirNextBlockVisitor<'a> {
-    inner: XirJumpVisitor<'a>,
-    retty: ir::Type,
-    targ: Option<BasicBlockId>,
-}
 
-impl<'a> JumpVisitor for XirNextBlockVisitor<'a> {
-    fn visit_target_bb(&mut self, targbb: BasicBlockId) {
-        self.targ = Some(targbb);
-        self.inner.visit_target_bb(targbb)
+    fn visit_tailcall(&mut self) {
+        self.block.term = ir::Terminator::Tailcall(
+            ir::CallFlags::empty(),
+            XLangBox::new(core::mem::take(&mut self.fnty)),
+        );
     }
+}
 
-    fn visit_remap(&mut self, src: SsaVarId, targ: SsaVarId) {
-        self.inner.visit_remap(src, targ)
+impl<'a> Drop for XirCallVisitor<'a> {
+    fn drop(&mut self) {
+        if let Some(targ) = self.targ.take() {
+            self.block.term = ir::Terminator::Call(
+                ir::CallFlags::empty(),
+                XLangBox::new(core::mem::take(&mut self.fnty)),
+                targ,
+            );
+        }
     }
 }
 
-pub struct XirJumpVisitor<'a> {
+pub struct XirStatementVisitor<'a> {
+    defs: &'a Definitions,
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
     ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
-    targ: Option<BasicBlockId>,
-    cond: ir::BranchCondition,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
 }
 
-impl<'a> XirJumpVisitor<'a> {
+impl<'a> XirStatementVisitor<'a> {
     pub fn new(
+        defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
         ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
-        cond: ir::BranchCondition,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
+            defs,
             names,
             properties,
-            body,
-            targs,
-            var_heights,
-            stack_height,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
             ssa_tys,
-            targ: None,
-            cond,
+            stack_height,
+            var_heights,
+            var_stack,
         }
     }
 }
 
-impl<'a> JumpVisitor for XirJumpVisitor<'a> {
-    fn visit_target_bb(&mut self, targbb: BasicBlockId) {
-        self.targ = Some(targbb);
-    }
-
-    fn visit_remap(&mut self, src: SsaVarId, dest: SsaVarId) {}
-}
-
-impl<'a> Drop for XirJumpVisitor<'a> {
-    fn drop(&mut self) {
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Branch {
-                cond: self.cond,
-                target: self.targ.unwrap().id(),
-            }));
-        if self.cond != ir::BranchCondition::Always && self.cond != ir::BranchCondition::Never {
-            *self.stack_height -= 1;
-        }
-    }
-}
-
-pub struct XirBranchVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-    stack_height: &'a mut u32,
-}
-
-impl<'a> XirBranchVisitor<'a> {
-    fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            ssa_tys,
-            stack_height,
-        }
-    }
-}
-
-impl<'a> BranchVisitor for XirBranchVisitor<'a> {
-    fn visit_branch_arm(&mut self) -> Option<Box<dyn BranchArmVisitor + '_>> {
-        Some(Box::new(XirBranchArmVisitor::new(
+impl<'a> StatementVisitor for XirStatementVisitor<'a> {
+    fn visit_let(&mut self) -> Option<Box<dyn LetStatementVisitor + '_>> {
+        Some(Box::new(XirLetStatementVisitor::new(
             self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
             self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
-    fn visit_else(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
-        Some(Box::new(XirJumpVisitor::new(
-            self.names,
-            self.properties,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.ssa_tys,
-            self.stack_height,
-            ir::BranchCondition::Always,
-        )))
+    fn visit_store_dead(&mut self, _: mir::SsaVarId) {}
+
+    fn visit_discard(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        None
     }
 }
 
-pub struct XirBranchArmVisitor<'a> {
+pub struct XirLetStatementVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
     ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    var: SsaVarId,
 }
 
-impl<'a> XirBranchArmVisitor<'a> {
-    fn new(
+impl<'a> XirLetStatementVisitor<'a> {
+    pub fn new(
         defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
         ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
             names,
             properties,
             deftys,
-            body,
-            targs,
-            var_heights,
+            cur_fnty,
+            exprs,
+            locals,
             ssa_tys,
             stack_height,
+            var_heights,
+            var_stack,
+            var: SsaVarId::INVALID,
         }
     }
 }
 
-impl<'a> BranchArmVisitor for XirBranchArmVisitor<'a> {
-    fn visit_cond(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
+impl<'a> LetStatementVisitor for XirLetStatementVisitor<'a> {
+    fn visit_var(&mut self, var: mir::SsaVarId) {
+        self.var = var;
+        self.var_heights.insert(var, *self.stack_height);
+        self.var_stack.push(var);
+    }
+
+    fn visit_var_ty(&mut self) -> Option<Box<dyn TypeVisitor + '_>> {
+        Some(Box::new(XirTypeVisitor::new(
             self.defs,
             self.names,
+            self.ssa_tys.get_or_insert_mut(self.var, ir::Type::Null),
             self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
         )))
     }
 
-    fn visit_jump(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
-        Some(Box::new(XirJumpVisitor::new(
+    fn visit_init(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
             self.names,
             self.properties,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
             self.ssa_tys,
             self.stack_height,
-            ir::BranchCondition::NotEqual,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 }
@@ -1992,16 +1576,13 @@ pub struct XirExprVisitor<'a> {
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
-}
-
-impl<'a> Drop for XirExprVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height += 1;
-    }
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
 }
 
 impl<'a> XirExprVisitor<'a> {
@@ -2010,75 +1591,61 @@ impl<'a> XirExprVisitor<'a> {
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
             names,
             properties,
             deftys,
-            body,
-            targs,
-            var_heights,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
             stack_height,
+            var_heights,
+            var_stack,
         }
     }
 }
 
 impl<'a> ExprVisitor for XirExprVisitor<'a> {
     fn visit_unreachable(&mut self) {
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Invalid(
-                NEVER,
-            ))));
+        todo!()
     }
 
     fn visit_const_int(&mut self) -> Option<Box<dyn ConstIntVisitor + '_>> {
-        match self
-            .body
-            .block
-            .items
-            .push_mut(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Integer {
-                ty: ir::ScalarType::default(),
-                val: 0,
-            }))) {
-            ir::BlockItem::Expr(ir::Expr::Const(ir::Value::Integer { ty, val })) => {
-                Some(Box::new(XirConstIntVisitor::new(
-                    self.names,
-                    self.properties,
-                    self.deftys,
-                    self.targs,
-                    self.var_heights,
-                    self.stack_height,
-                    ty,
-                    val,
-                )))
-            }
-            _ => unreachable!(),
-        }
+        let (intty, val) = match self.exprs.push_mut(ir::Expr::Const(ir::Value::Integer {
+            ty: ir::ScalarType::default(),
+            val: 0,
+        })) {
+            ir::Expr::Const(ir::Value::Integer { ty, val }) => (ty, val),
+            _ => unsafe { core::hint::unreachable_unchecked() },
+        };
+        Some(Box::new(XirConstIntVisitor::new(
+            self.properties,
+            val,
+            intty,
+        )))
     }
 
     fn visit_const(&mut self, defid: DefId) {
-        let sym = self.names[&defid];
+        let name = self.names[&defid];
 
         let path = ir::Path {
-            components: vec![ir::PathComponent::Text((&sym).into())],
+            components: vec![ir::PathComponent::Text((&name).into())],
         };
 
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Const(
-                ir::Value::GlobalAddress {
-                    ty: self.deftys[&defid].clone(),
-                    item: path,
-                },
-            )))
+        let ty = self.deftys[&defid].clone();
+
+        self.exprs
+            .push(ir::Expr::Const(ir::Value::GlobalAddress { ty, item: path }));
     }
 
     fn visit_cast(&mut self) -> Option<Box<dyn CastVisitor + '_>> {
@@ -2087,1012 +1654,328 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
     fn visit_const_string(&mut self) -> Option<Box<dyn ConstStringVisitor + '_>> {
-        match self
-            .body
-            .block
-            .items
-            .push_mut(ir::BlockItem::Expr(ir::Expr::Const(ir::Value::String {
-                encoding: ir::StringEncoding::Utf8,
-                utf8: XLangString::new(),
-                ty: ir::Type::Pointer(ir::PointerType {
-                    inner: xlang::abi::boxed::Box::new(ir::Type::Scalar(ir::ScalarType {
-                        header: ir::ScalarTypeHeader {
-                            bitsize: 8,
-                            vectorsize: XLangNone,
-                            validity: ScalarValidity::empty(),
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: XLangNone,
-                            max: XLangNone,
-                        },
-                    })),
-                    ..Default::default()
-                }),
-            }))) {
-            ir::BlockItem::Expr(ir::Expr::Const(ir::Value::String { utf8, .. })) => {
-                Some(Box::new(XirConstStringVisitor::new(
-                    self.names,
-                    self.properties,
-                    self.deftys,
-                    self.targs,
-                    self.var_heights,
-                    self.stack_height,
-                    utf8,
-                )))
-            }
-            _ => unreachable!(),
-        }
+        let (ty, val) = match self.exprs.push_mut(ir::Expr::Const(ir::Value::String {
+            encoding: ir::StringEncoding::Utf8,
+            ty: ir::Type::default(),
+            utf8: XLangString::new(),
+        })) {
+            ir::Expr::Const(ir::Value::String { ty, utf8, .. }) => (ty, utf8),
+            _ => unsafe { core::hint::unreachable_unchecked() },
+        };
+        Some(Box::new(XirConstStringVisitor::new(
+            self.properties,
+            val,
+            ty,
+        )))
     }
 
-    fn visit_var(&mut self, var: SsaVarId) {
-        let depth = *self.stack_height - self.var_heights[&var];
+    fn visit_var(&mut self, var: mir::SsaVarId) {
+        let height = self.var_heights[&var];
+
+        let depth = (*self.stack_height) - (height + 1);
 
         if depth != 0 {
-            self.body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::Pivot(1, depth)));
+            self.exprs.push(ir::Expr::Pivot(depth, 1));
         }
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Dup(1)));
+        self.exprs.push(ir::Expr::Dup(1));
         if depth != 0 {
-            self.body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::Pivot(depth + 1, 1)));
+            self.exprs.push(ir::Expr::Pivot(1, depth + 1));
         }
     }
 
     fn visit_tuple(&mut self) -> Option<Box<dyn TupleExprVisitor + '_>> {
-        Some(Box::new(XirTupleExprVisitor::new(
+        Some(Box::new(XirTupleVisitor::new(
+            self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
         )))
     }
 
     fn visit_ctor(&mut self) -> Option<Box<dyn ConstructorVisitor + '_>> {
-        Some(Box::new(XirConstructorExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
+        todo!()
     }
 
     fn visit_field_subobject(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        Some(Box::new(XirFieldAccessVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-            ir::Expr::Member,
-        )))
+        todo!()
     }
 
     fn visit_field_project(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        Some(Box::new(XirFieldAccessVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-            ir::Expr::MemberIndirect,
-        )))
+        todo!()
     }
 
     fn visit_binary_expr(&mut self) -> Option<Box<dyn BinaryExprVisitor + '_>> {
-        Some(Box::new(XirBinaryExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
+        todo!()
     }
 
     fn visit_unary_expr(&mut self) -> Option<Box<dyn UnaryExprVisitor + '_>> {
-        Some(Box::new(XirUnaryExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
+        todo!()
+    }
+}
+
+impl<'a> Drop for XirExprVisitor<'a> {
+    fn drop(&mut self) {
+        *self.stack_height += 1;
     }
 }
 
-pub struct XirConstructorExprVisitor<'a> {
+pub struct XirTupleVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
-    fields: Vec<XLangString>,
-    ctor_ty: DefId,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    tys: Vec<ir::Type>,
 }
 
-impl<'a> XirConstructorExprVisitor<'a> {
+impl<'a> XirTupleVisitor<'a> {
     pub fn new(
         defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
             names,
             properties,
             deftys,
-            body,
-            targs,
-            var_heights,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
             stack_height,
-            fields: Vec::new(),
-            ctor_ty: DefId::ROOT,
+            var_heights,
+            var_stack,
+            tys: vec![],
         }
     }
 }
 
-impl<'a> Drop for XirConstructorExprVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= self.fields.len() as u32;
-        let ty = ir::Type::Named(into_path(self.names[&self.ctor_ty]));
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Aggregate(
-                ir::AggregateCtor {
-                    ty,
-                    fields: core::mem::take(&mut self.fields),
-                },
-            )));
-    }
-}
-
-impl<'a> ConstructorVisitor for XirConstructorExprVisitor<'a> {
-    fn visit_ctor_def(&mut self, defid: DefId) {
-        self.ctor_ty = defid;
-        // TODO: Handle Enum constructors, which need to be nested.
-    }
-
-    fn visit_field(&mut self) -> Option<Box<dyn FieldInitVisitor + '_>> {
-        let field = self.fields.push_mut(XLangString::new());
-        Some(Box::new(XirConstructorFieldVisitor::new(
+impl<'a> TupleExprVisitor for XirTupleVisitor<'a> {
+    fn visit_elem(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
             self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
-            field,
+            self.var_heights,
+            self.var_stack,
         )))
     }
+}
 
-    fn visit_init(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        todo!()
+impl<'a> Drop for XirTupleVisitor<'a> {
+    fn drop(&mut self) {
+        let fields = self
+            .tys
+            .iter()
+            .zip(0..)
+            .map(|(_, x)| xlang::abi::format!("{}", x))
+            .collect::<Vec<_>>();
+
+        *self.stack_height -= fields.len() as u32;
+
+        self.exprs.push(ir::Expr::Aggregate(ir::AggregateCtor {
+            ty: ir::Type::Product(core::mem::take(&mut self.tys)),
+            fields,
+        }));
     }
 }
 
-pub struct XirConstructorFieldVisitor<'a> {
+pub struct XirCastVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
     deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
     stack_height: &'a mut u32,
-    field: &'a mut XLangString,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    ty: ir::Type,
 }
 
-impl<'a> XirConstructorFieldVisitor<'a> {
+impl<'a> XirCastVisitor<'a> {
     pub fn new(
         defs: &'a Definitions,
         names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
         deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
         stack_height: &'a mut u32,
-        field: &'a mut XLangString,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
     ) -> Self {
         Self {
             defs,
             names,
             properties,
             deftys,
-            body,
-            targs,
-            var_heights,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
             stack_height,
-            field,
+            var_heights,
+            var_stack,
+            ty: ir::Type::Null,
         }
     }
 }
 
-impl<'a> FieldInitVisitor for XirConstructorFieldVisitor<'a> {
-    fn visit_field(&mut self, field_name: &ty::FieldName) {
-        let _ = write!(self.field, "{}", field_name);
-    }
-
-    fn visit_value(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+impl<'a> CastVisitor for XirCastVisitor<'a> {
+    fn visit_inner(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
         Some(Box::new(XirExprVisitor::new(
             self.defs,
             self.names,
             self.properties,
             self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
             self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+
+    fn visit_cast_type(&mut self) -> Option<Box<dyn TypeVisitor + '_>> {
+        Some(Box::new(XirTypeVisitor::new(
+            self.defs,
+            self.names,
+            &mut self.ty,
+            self.properties,
         )))
     }
 }
 
-pub struct XirFieldAccessVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    ctor: fn(XLangString) -> ir::Expr,
-    field: XLangString,
+impl<'a> Drop for XirCastVisitor<'a> {
+    fn drop(&mut self) {
+        self.exprs.push(ir::Expr::Convert(
+            ir::ConversionStrength::Reinterpret,
+            core::mem::take(&mut self.ty),
+        ));
+        *self.stack_height -= 1;
+    }
 }
 
-impl<'a> XirFieldAccessVisitor<'a> {
-    pub fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-        ctor: fn(XLangString) -> ir::Expr,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            stack_height,
-            ctor,
-            field: XLangString::new(),
-        }
-    }
-}
-
-impl<'a> Drop for XirFieldAccessVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= 1;
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr((self.ctor)(core::mem::take(
-                &mut self.field,
-            ))))
-    }
-}
-
-impl<'a> FieldAccessVisitor for XirFieldAccessVisitor<'a> {
-    fn visit_base(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-    fn visit_field(&mut self, field_name: &ty::FieldName) {
-        // TODO: variant fields
-        let _ = write!(self.field, "{}", field_name);
-    }
-}
-
-pub struct XirBinaryExprVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    op: Option<BinaryOp>,
-}
-
-impl<'a> XirBinaryExprVisitor<'a> {
-    fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            stack_height,
-            op: None,
-        }
-    }
-}
-
-impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
-    fn visit_op(&mut self, op: BinaryOp) {
-        self.op = Some(op);
-    }
-
-    fn visit_lhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-
-    fn visit_rhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-}
-
-impl<'a> Drop for XirBinaryExprVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= 2; // `XirExprVisitor`s drop will increase stack height by 1
-        let op = match self.op.expect("visit_op must be called first") {
-            BinaryOp::Add => ir::BinaryOp::Add,
-            BinaryOp::Sub => ir::BinaryOp::Sub,
-            BinaryOp::Mul => ir::BinaryOp::Mul,
-            BinaryOp::Div => ir::BinaryOp::Div,
-            BinaryOp::Rem => ir::BinaryOp::Mod,
-            BinaryOp::BitAnd => ir::BinaryOp::BitAnd,
-            BinaryOp::BitOr => ir::BinaryOp::BitOr,
-            BinaryOp::BitXor => ir::BinaryOp::BitXor,
-
-            BinaryOp::Less => ir::BinaryOp::CmpLt,
-            BinaryOp::Greater => ir::BinaryOp::CmpGt,
-            BinaryOp::Equal => ir::BinaryOp::CmpEq,
-            BinaryOp::NotEqual => ir::BinaryOp::CmpNe,
-            BinaryOp::LessEqual => ir::BinaryOp::CmpLe,
-            BinaryOp::GreaterEqual => ir::BinaryOp::CmpGe,
-
-            BinaryOp::LeftShift => ir::BinaryOp::Lsh,
-            BinaryOp::RightShift => ir::BinaryOp::Rsh,
-
-            BinaryOp::BoolAnd
-            | BinaryOp::BoolOr
-            | BinaryOp::Range
-            | BinaryOp::RangeInclusive
-            | BinaryOp::Assign
-            | BinaryOp::AddAssign
-            | BinaryOp::SubAssign
-            | BinaryOp::MulAssign
-            | BinaryOp::DivAssign
-            | BinaryOp::RemAssign
-            | BinaryOp::BitAndAssign
-            | BinaryOp::BitOrAssign
-            | BinaryOp::BitXorAssign
-            | BinaryOp::BoolAndAssign
-            | BinaryOp::BoolOrAssign
-            | BinaryOp::LeftShiftAssign
-            | BinaryOp::RightShiftAssign => unreachable!("handled before MIR"),
-        };
-
-        let overflow_behaviour = ir::OverflowBehaviour::Wrap;
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::BinaryOp(
-                op,
-                overflow_behaviour,
-            )));
-    }
-}
-
-pub struct XirUnaryExprVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    op: Option<UnaryOp>,
-}
-
-impl<'a> XirUnaryExprVisitor<'a> {
-    fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            stack_height,
-            op: None,
-        }
-    }
-}
-
-impl<'a> UnaryExprVisitor for XirUnaryExprVisitor<'a> {
-    fn visit_op(&mut self, op: UnaryOp) {
-        self.op = Some(op);
-    }
-
-    fn visit_lhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-}
-
-impl<'a> Drop for XirUnaryExprVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= 1; // drop for XirExprVisitor will increase stack_height
-
-        let op = match self.op.expect("visit_op must be called first") {
-            UnaryOp::Neg => ir::UnaryOp::Minus,
-            UnaryOp::Not => todo!(),
-            UnaryOp::RangeFrom
-            | UnaryOp::RangeTo
-            | UnaryOp::RangeToInclusive
-            | UnaryOp::RawAddrOf(_)
-            | UnaryOp::AddrOf(_)
-            | UnaryOp::Deref => unreachable!("handled before of MIR"),
-        };
-
-        let overflow_behaviour = ir::OverflowBehaviour::Wrap;
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::UnaryOp(
-                op,
-                overflow_behaviour,
-            )));
-    }
-}
-
-pub struct XirTupleExprVisitor<'a> {
-    names: &'a NameMap,
+pub struct XirConstStringVisitor<'a> {
     properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    next_field: u32,
-    fields: Vec<XLangString>,
-    elem_tys: Vec<ir::Type>,
+    val: &'a mut XLangString,
+    ty: &'a mut ir::Type,
 }
 
-impl<'a> XirTupleExprVisitor<'a> {
+impl<'a> XirConstStringVisitor<'a> {
     pub fn new(
-        names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
+        val: &'a mut XLangString,
+        ty: &'a mut ir::Type,
     ) -> Self {
         Self {
-            names,
             properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            stack_height,
-            next_field: 0,
-            fields: Vec::new(),
-            elem_tys: Vec::new(),
+            val,
+            ty,
         }
     }
 }
 
-impl<'a> TupleExprVisitor for XirTupleExprVisitor<'a> {
-    fn visit_elem(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        todo!()
+impl<'a> ConstStringVisitor for XirConstStringVisitor<'a> {
+    fn visit_string_type(&mut self, st: StringType) {
+        match st {
+            StringType::Default | StringType::Raw(_) => todo!(),
+            StringType::Byte | StringType::RawByte(_) => {
+                let mut ptr = ir::PointerType::default();
+                *ptr.inner = ir::Type::Scalar(ir::ScalarType {
+                    header: ir::ScalarTypeHeader {
+                        bitsize: 0,
+                        vectorsize: XLangNone,
+                        validity: ir::ScalarValidity::empty(),
+                    },
+                    kind: ir::ScalarTypeKind::Integer {
+                        signed: false,
+                        min: XLangNone,
+                        max: XLangNone,
+                    },
+                });
+                *self.ty = ir::Type::Pointer(ptr);
+            }
+        }
     }
-}
 
-impl<'a> Drop for XirTupleExprVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= self.next_field;
-        let ty = ir::Type::Product(core::mem::take(&mut self.elem_tys));
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Aggregate(
-                ir::AggregateCtor {
-                    ty,
-                    fields: core::mem::take(&mut self.fields),
-                },
-            )))
+    fn visit_value(&mut self, val: Symbol) {
+        *self.val = (&val).into();
     }
 }
 
 pub struct XirConstIntVisitor<'a> {
-    names: &'a NameMap,
     properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    ty: &'a mut ir::ScalarType,
     val: &'a mut u128,
+    intty: &'a mut ir::ScalarType,
 }
 
 impl<'a> XirConstIntVisitor<'a> {
     pub fn new(
-        names: &'a NameMap,
         properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-        ty: &'a mut ir::ScalarType,
         val: &'a mut u128,
+        intty: &'a mut ir::ScalarType,
     ) -> Self {
         Self {
-            names,
             properties,
-            deftys,
-            targs,
-            var_heights,
-            stack_height,
-            ty,
             val,
+            intty,
         }
     }
 }
 
 impl<'a> ConstIntVisitor for XirConstIntVisitor<'a> {
     fn visit_intty(&mut self) -> Option<Box<dyn IntTyVisitor + '_>> {
-        Some(Box::new(XirIntTyVisitor::new(self.ty, self.properties)))
+        Some(Box::new(XirIntTyVisitor::new(self.intty, self.properties)))
     }
 
     fn visit_value(&mut self, val: u128) {
         *self.val = val;
     }
 }
-
-pub struct XirConstStringVisitor<'a> {
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    string: &'a mut XLangString,
-}
-
-impl<'a> XirConstStringVisitor<'a> {
-    pub fn new(
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-        string: &'a mut XLangString,
-    ) -> Self {
-        Self {
-            names,
-            properties,
-            deftys,
-            targs,
-            var_heights,
-            stack_height,
-            string,
-        }
-    }
-}
-
-impl<'a> ConstStringVisitor for XirConstStringVisitor<'a> {
-    fn visit_string_type(&mut self, st: StringType) {}
-
-    fn visit_value(&mut self, val: Symbol) {
-        *self.string = (&*val).into();
-    }
-}
-
-pub struct XirCastVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    stack_height: &'a mut u32,
-    as_ty: Option<ir::Type>,
-}
-
-impl<'a> XirCastVisitor<'a> {
-    pub fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            body,
-            targs,
-            var_heights,
-            stack_height,
-            as_ty: None,
-        }
-    }
-}
-
-impl<'a> CastVisitor for XirCastVisitor<'a> {
-    fn visit_inner(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-
-    fn visit_cast_type(&mut self) -> Option<Box<dyn TypeVisitor + '_>> {
-        Some(Box::new(XirTypeVisitor::new(
-            self.defs,
-            self.names,
-            self.as_ty.insert(ir::Type::Null),
-            self.properties,
-        )))
-    }
-}
-
-impl<'a> Drop for XirCastVisitor<'a> {
-    fn drop(&mut self) {
-        *self.stack_height -= 1;
-
-        self.body
-            .block
-            .items
-            .push(ir::BlockItem::Expr(ir::Expr::Convert(
-                ir::ConversionStrength::Reinterpret,
-                self.as_ty
-                    .take()
-                    .expect("visit_cast_type must have been called"),
-            )));
-    }
-}
-
-pub struct XirStatementVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    cur_fnty: &'a mut ir::FnType,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-    stack_height: &'a mut u32,
-}
-
-impl<'a> XirStatementVisitor<'a> {
-    pub fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        cur_fnty: &'a mut ir::FnType,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            cur_fnty,
-            body,
-            targs,
-            var_heights,
-            ssa_tys,
-            stack_height,
-        }
-    }
-}
-
-impl<'a> StatementVisitor for XirStatementVisitor<'a> {
-    fn visit_let(&mut self) -> Option<Box<dyn LetStatementVisitor + '_>> {
-        Some(Box::new(XirLetVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.cur_fnty,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.ssa_tys,
-            self.stack_height,
-        )))
-    }
-
-    fn visit_store_dead(&mut self, _: SsaVarId) {
-        // Be more intelligent in the future
-    }
-
-    fn visit_discard(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirDiscardVisitor(
-            XirExprVisitor::new(
-                self.defs,
-                self.names,
-                self.properties,
-                self.deftys,
-                self.body,
-                self.targs,
-                self.var_heights,
-                self.stack_height,
-            ),
-            true,
-        )))
-    }
-}
-
-pub struct XirDiscardVisitor<'a>(XirExprVisitor<'a>, bool);
-
-impl<'a> ExprVisitor for XirDiscardVisitor<'a> {
-    fn visit_unreachable(&mut self) {
-        self.0.visit_unreachable()
-    }
-
-    fn visit_const_int(&mut self) -> Option<Box<dyn ConstIntVisitor + '_>> {
-        self.0.visit_const_int()
-    }
-
-    fn visit_const(&mut self, defid: DefId) {
-        self.0.visit_const(defid)
-    }
-
-    fn visit_cast(&mut self) -> Option<Box<dyn CastVisitor + '_>> {
-        self.0.visit_cast()
-    }
-
-    fn visit_const_string(&mut self) -> Option<Box<dyn ConstStringVisitor + '_>> {
-        self.0.visit_const_string()
-    }
-
-    fn visit_var(&mut self, var: crate::sema::mir::SsaVarId) {
-        // We can honestly no-op, but destructor currently pops *something*
-        self.1 = false;
-    }
-
-    fn visit_tuple(&mut self) -> Option<Box<dyn super::visitor::TupleExprVisitor + '_>> {
-        self.0.visit_tuple()
-    }
-
-    fn visit_ctor(&mut self) -> Option<Box<dyn ConstructorVisitor + '_>> {
-        self.0.visit_ctor()
-    }
-
-    fn visit_field_subobject(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        self.0.visit_field_subobject()
-    }
-
-    fn visit_field_project(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        self.0.visit_field_project()
-    }
-
-    fn visit_binary_expr(&mut self) -> Option<Box<dyn BinaryExprVisitor + '_>> {
-        self.0.visit_binary_expr()
-    }
-
-    fn visit_unary_expr(&mut self) -> Option<Box<dyn UnaryExprVisitor + '_>> {
-        self.0.visit_unary_expr()
-    }
-}
-
-impl<'a> Drop for XirDiscardVisitor<'a> {
-    fn drop(&mut self) {
-        if self.1 {
-            *self.0.stack_height -= 1;
-            self.0
-                .body
-                .block
-                .items
-                .push(ir::BlockItem::Expr(ir::Expr::Pop(1)));
-        }
-    }
-}
-
-pub struct XirLetVisitor<'a> {
-    defs: &'a Definitions,
-    names: &'a NameMap,
-    properties: &'a TargetProperties<'a>,
-    deftys: &'a HashMap<DefId, ir::Type>,
-    cur_fnty: &'a mut ir::FnType,
-    body: &'a mut ir::FunctionBody,
-    targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-    var_heights: &'a mut HashMap<SsaVarId, u32>,
-    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-    stack_height: &'a mut u32,
-    varid: Option<SsaVarId>,
-}
-
-impl<'a> XirLetVisitor<'a> {
-    pub fn new(
-        defs: &'a Definitions,
-        names: &'a NameMap,
-        properties: &'a TargetProperties<'a>,
-        deftys: &'a HashMap<DefId, ir::Type>,
-        cur_fnty: &'a mut ir::FnType,
-        body: &'a mut ir::FunctionBody,
-        targs: &'a mut HashMap<BasicBlockId, Vec<ir::StackItem>>,
-        var_heights: &'a mut HashMap<SsaVarId, u32>,
-        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
-        stack_height: &'a mut u32,
-    ) -> Self {
-        Self {
-            defs,
-            names,
-            properties,
-            deftys,
-            cur_fnty,
-            body,
-            targs,
-            var_heights,
-            ssa_tys,
-            stack_height,
-            varid: None,
-        }
-    }
-}
-
-impl<'a> LetStatementVisitor for XirLetVisitor<'a> {
-    fn visit_var(&mut self, var: SsaVarId) {
-        self.varid = Some(var);
-    }
-
-    fn visit_var_ty(&mut self) -> Option<Box<dyn TypeVisitor + '_>> {
-        Some(Box::new(XirTypeVisitor::new(
-            self.defs,
-            self.names,
-            self.ssa_tys
-                .get_or_insert_mut(self.varid.unwrap(), ir::Type::default()),
-            self.properties,
-        )))
-    }
-
-    fn visit_init(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
-        Some(Box::new(XirExprVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.body,
-            self.targs,
-            self.var_heights,
-            self.stack_height,
-        )))
-    }
-}
-
-impl<'a> Drop for XirLetVisitor<'a> {
-    fn drop(&mut self) {
-        let varid = self.varid.take().expect("visit_var must have been called");
-        self.var_heights.insert(varid, *self.stack_height);
-    }
-}
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 62567964..e3c84bd0 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -116,6 +116,7 @@ impl XLangPlugin for RustFrontend {
 xlang::host::rustcall! {
     #[allow(clippy::missing_const_for_fn)]
     #[no_mangle]
+    #[allow(improper_ctypes_definitions)]
     pub extern "rustcall" fn xlang_frontend_main() -> DynBox<dyn XLangFrontend> {
         DynBox::unsize_box(Box::new(RustFrontend::new()))
     }
diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index 19b053e5..7741c539 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -60,6 +60,7 @@ impl core::borrow::Borrow<u32> for BasicBlockId {
 }
 
 impl SsaVarId {
+    pub const INVALID: SsaVarId = Self(!0);
     pub const fn id(self) -> u32 {
         self.0
     }
diff --git a/xir/src/lib.rs b/xir/src/lib.rs
index 8c2b9a12..251cb662 100644
--- a/xir/src/lib.rs
+++ b/xir/src/lib.rs
@@ -1,27 +1,16 @@
 #![deny(warnings, clippy::all, clippy::pedantic, clippy::nursery)]
-use ir::File;
-use xlang::abi::io::{self, IntoChars, Read};
+
+use xlang::abi::io::{self, Read};
 use xlang::abi::prelude::v1::*;
 use xlang::abi::result::Result;
-use xlang::abi::span::SpanMut;
 use xlang::abi::string::StringView;
 use xlang::ir;
 use xlang::plugin::{Error, XLangFrontend, XLangPlugin};
-
-mod binary_reader;
-mod lexer;
-mod parser;
-mod validate;
-
-use lexer::lex;
 use xlang::targets::properties::TargetProperties;
 
-use crate::parser::parse_file;
-
 struct XirFrontend {
     filename: Option<String>,
     target: Option<&'static TargetProperties<'static>>,
-    file: Option<File>,
 }
 
 impl XirFrontend {
@@ -30,7 +19,6 @@ impl XirFrontend {
         Self {
             filename: None,
             target: None,
-            file: None,
         }
     }
 }
@@ -45,77 +33,15 @@ impl XLangFrontend for XirFrontend {
     }
 
     #[allow(clippy::cast_lossless)]
-    fn read_source(&mut self, mut file: DynMut<dyn Read>) -> io::Result<()> {
-        let mut b = 0u8;
-
-        xlang::abi::try_!(file.read_exact(SpanMut::from_mut(&mut b)));
-
-        if b == 0xFF {
-            let mut mag = [0u8; 3];
-            xlang::abi::try_!(file.read_exact(SpanMut::new(&mut mag)));
-
-            if mag != *b"XIR" {
-                return xlang::abi::result::Err(io::Error::Message(
-                    "Invalid Binary XIR file".into(),
-                ));
-            }
-        } else {
-            let mut stream = file.into_chars();
-            let c = match b {
-                0x00..=0x7f => b as char,
-                0xC0..=0xDF => {
-                    let c2 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c2) {
-                        panic!("Invalid UTF-8");
-                    }
-                    char::from_u32(((b as u32) << 5) | (c2 as u32)).expect("Invalid UTF-8")
-                }
-                0xE0..=0xEF => {
-                    let c2 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c2) {
-                        panic!("Invalid UTF-8");
-                    }
-                    let c3 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c3) {
-                        panic!("Invalid UTF-8");
-                    }
-                    char::from_u32(((b as u32) << 10) | ((c2 as u32) << 5) | (c3 as u32))
-                        .expect("Invalid UTF-8")
-                }
-                0xF0..=0xF7 => {
-                    let c2 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c2) {
-                        panic!("Invalid UTF-8");
-                    }
-                    let c3 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c3) {
-                        panic!("Invalid UTF-8");
-                    }
-                    let c4 = stream.next_byte().expect("Invalid UTF-8");
-                    if !(0x80..=0xBF).contains(&c4) {
-                        panic!("Invalid UTF-8");
-                    }
-                    char::from_u32(
-                        ((b as u32) << 15) | ((c2 as u32) << 10) | ((c3 as u32) << 5) | (c4 as u32),
-                    )
-                    .expect("Invalid UTF-8")
-                }
-                _ => panic!("Invalid UTF-8"),
-            };
-            let lexed = lex(core::iter::once(c).chain(stream)).collect::<Vec<_>>();
-            self.file = Some(parse_file(lexed.into_iter()));
-        }
-
-        Result::Ok(())
+    fn read_source(&mut self, _: DynMut<dyn Read>) -> io::Result<()> {
+        todo!()
     }
 }
 
 impl XLangPlugin for XirFrontend {
     #[allow(clippy::too_many_lines)]
-    fn accept_ir(&mut self, file: &mut ir::File) -> Result<(), Error> {
-        *file = self.file.take().unwrap();
-        validate::tycheck(file, self.target.unwrap());
-        Result::Ok(())
+    fn accept_ir(&mut self, _: &mut ir::File) -> Result<(), Error> {
+        todo!()
     }
 
     fn set_target(&mut self, targ: &'static TargetProperties<'static>) {
@@ -125,6 +51,7 @@ impl XLangPlugin for XirFrontend {
 
 xlang::host::rustcall! {
     #[allow(clippy::missing_const_for_fn)]
+    #[allow(improper_ctypes_definitions)]
     #[no_mangle]
     pub extern "rustcall" fn xlang_frontend_main() -> DynBox<dyn XLangFrontend> {
         DynBox::unsize_box(Box::new(XirFrontend::new()))
diff --git a/xlang/src/plugin.rs b/xlang/src/plugin.rs
index 622c1c76..a71fca29 100644
--- a/xlang/src/plugin.rs
+++ b/xlang/src/plugin.rs
@@ -5,6 +5,8 @@
 //! xlang plugins should be installed to the xlang plugin directory
 //!
 
+#![allow(improper_ctypes_definitions)]
+
 pub mod v1 {
     use xlang_abi::{
         io::{self, Read, ReadSeek, Write},
diff --git a/xlang/xlang_abi/src/alloc.rs b/xlang/xlang_abi/src/alloc.rs
index 1cc4ac7a..b40546db 100644
--- a/xlang/xlang_abi/src/alloc.rs
+++ b/xlang/xlang_abi/src/alloc.rs
@@ -593,7 +593,7 @@ unsafe impl<A: ?Sized + Allocator> Allocator for &mut A {
 // TODO: Should this be changed? No. XLangAlloc is the correct name. This isn't the `Global` or `System` allocator, it's the xlang allocator
 #[derive(Copy, Clone)]
 #[repr(transparent)]
-pub struct XLangAlloc(core::mem::MaybeUninit<u8>);
+pub struct XLangAlloc(());
 
 impl XLangAlloc {
     ///
@@ -602,7 +602,7 @@ impl XLangAlloc {
     /// All values of type [`XLangAlloc`] are identical, and may be used interchangeably
     #[must_use]
     pub const fn new() -> Self {
-        Self(core::mem::MaybeUninit::uninit())
+        Self(())
     }
 }
 
diff --git a/xlang/xlang_abi/src/vec.rs b/xlang/xlang_abi/src/vec.rs
index b5e06b80..f2075c10 100644
--- a/xlang/xlang_abi/src/vec.rs
+++ b/xlang/xlang_abi/src/vec.rs
@@ -451,6 +451,54 @@ impl<T, A: Allocator> Vec<T, A> {
         self.len += 1;
     }
 
+    /// Removes and returns the `i`th element of the vector, shifting all subsequent elements down.
+    ///
+    /// The relative order of remaining elements is preserved by this function
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `i` is greater than or equal to `self.len()`
+    pub fn remove(&mut self, i: usize) -> T {
+        if i >= self.len {
+            panic!(
+                "Index {} is out of range for a Vec of length {}",
+                i, self.len
+            );
+        }
+        let rest = self.len - i;
+        let loc = unsafe { self.ptr.as_ptr().add(i) };
+        let val = unsafe { core::ptr::read(loc) };
+        unsafe {
+            core::ptr::copy(loc.offset(1), loc, rest);
+        }
+        self.len -= 1;
+        val
+    }
+
+    /// Removes and returns the `i`th element of the vector, replacing it with the last element of the vector.
+    ///
+    /// This operation does not preserve the relative order of the remaining elements
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `i` is greater than or equal to `self.len()`
+    pub fn swap_remove(&mut self, i: usize) -> T {
+        if i >= self.len {
+            panic!(
+                "Index {} is out of range for a Vec of length {}",
+                i, self.len
+            );
+        }
+        self.len -= 1;
+        let loc = unsafe { self.ptr.as_ptr().add(i) };
+        let end_loc = unsafe { self.ptr.as_ptr().add(self.len) };
+        if loc != end_loc {
+            unsafe { core::ptr::swap_nonoverlapping(loc, end_loc, 1) }
+        }
+
+        unsafe { core::ptr::read(end_loc) }
+    }
+
     /// Inserts `val` into the `Vec` at a position such that the list is sorted in ascending order and returns that position.
     ///
     /// If an element that compares equal to `val` is already present in the list, the position relative to any such element is unspecified
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index 8014199b..f39a0888 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -1,9 +1,10 @@
 #![deny(missing_docs, warnings)] // No clippy::nursery
+#![allow(dead_code)] // I'm not deleting a bunch of randomly placed shit
 //! A helper crate for implementing [`xlang::plugin::XLangCodegen`]s without duplicating code (also can be used to evaluate constant expressions)
 //! the `xlang_backend` crate provides a general interface for writing expressions to an output.
 use std::{
     collections::{HashSet, VecDeque},
-    convert::{TryFrom, TryInto},
+    convert::TryInto,
     fmt::Debug,
     io::Write,
     mem::MaybeUninit,
@@ -19,9 +20,8 @@ use xlang::{
     abi::string::StringView,
     ir::{
         AccessClass, AsmExpr, BinaryOp, Block, BranchCondition, CharFlags, Expr, FnType,
-        FunctionBody, HashSwitch, LinearSwitch, OverflowBehaviour, Path, PointerType, ScalarType,
-        ScalarTypeHeader, ScalarTypeKind, ScalarValidity, StackItem, StackValueKind, Switch, Type,
-        UnaryOp, Value,
+        OverflowBehaviour, Path, PointerType, ScalarType, ScalarTypeHeader, ScalarTypeKind,
+        ScalarValidity, Type, UnaryOp, Value,
     },
     prelude::v1::*,
     targets::properties::TargetProperties,
@@ -48,6 +48,10 @@ pub mod mangle;
 /// Module for generic Machine Code
 pub mod mc;
 
+/// Module for building SSA from XIR that can be readily lowered to machine code
+/// Does not use FunctionCodegen
+pub mod ssa;
+
 ///
 /// Basic Trait for creating the code generator
 pub trait FunctionRawCodegen {
@@ -1781,1101 +1785,17 @@ impl<F: FunctionRawCodegen> FunctionCodegen<F> {
     }
 
     /// Writes an expression in linear order into the codegen
-    pub fn write_expr(&mut self, expr: &Expr) {
-        if self.diverged {
-            return;
-        }
-        eprintln!("{:?}", expr);
-        self.print_vstack();
-        match expr {
-            Expr::Const(v) => self.push_value(VStackValue::Constant(v.clone())),
-            Expr::Exit { values } => self.write_exit(*values),
-            Expr::BinaryOp(op, v) => self.write_binary_op(*op, *v),
-            Expr::UnaryOp(op, v) => self.write_unary_op(*op, *v),
-            Expr::CallFunction(fnty) => {
-                let vals = self.pop_values(fnty.params.len()).unwrap();
-                let target = self.pop_value().unwrap();
-                match target {
-                    VStackValue::Constant(Value::GlobalAddress { ty, item }) => {
-                        let realty = match &ty {
-                            Type::FnType(ty) => &**ty,
-                            _ => fnty,
-                        };
-                        self.call_fn(fnty, realty, &item, vals, false);
-                    }
-                    VStackValue::Constant(Value::Invalid(_))
-                    | VStackValue::Constant(Value::Uninitialized(_))
-                    | VStackValue::Constant(Value::LabelAddress(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    VStackValue::Pointer(pty, lvalue) => {
-                        let ty = &*pty.inner;
-                        let realty = match &ty {
-                            Type::FnType(ty) => &**ty,
-                            _ => fnty,
-                        };
-                        match lvalue {
-                            LValue::OpaquePointer(loc) => {
-                                self.call_indirect(fnty, realty, loc, vals, false)
-                            }
-                            LValue::GlobalAddress(path) => {
-                                self.call_fn(fnty, realty, &path, vals, false)
-                            }
-                            LValue::TransparentAddr(_) => todo!("call abs"),
-                            _ => {
-                                self.inner.write_trap(Trap::Unreachable);
-                                self.push_value(VStackValue::Trapped);
-                            }
-                        }
-                    }
-                    val => panic!("Invalid value {}", val),
-                }
-            }
-            Expr::Branch { cond, target } => self.write_branch(*cond, *target),
-            Expr::BranchIndirect => {
-                let val = self.pop_value().unwrap();
-
-                match val {
-                    VStackValue::Constant(Value::LabelAddress(n)) => {
-                        self.branch_to(n);
-                    }
-                    VStackValue::Pointer(_, LValue::Label(n)) => self.branch_to(n),
-                    VStackValue::Pointer(_, LValue::OpaquePointer(loc)) => {
-                        self.inner.branch_indirect(loc);
-                    }
-                    VStackValue::Pointer(_, _) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.diverged = true;
-                    }
-                    VStackValue::Trapped => self.diverged = true,
-                    val => panic!("Invalid value {}", val),
-                }
-            }
-
-            Expr::Convert(_, Type::Pointer(pty)) => match self.pop_value().unwrap() {
-                VStackValue::Constant(Value::LabelAddress(n)) => {
-                    self.push_value(VStackValue::Pointer(pty.clone(), LValue::Label(n)))
-                }
-                VStackValue::Constant(Value::String { encoding, utf8, .. }) => {
-                    self.push_value(VStackValue::Pointer(
-                        pty.clone(),
-                        LValue::StringLiteral(Encoding::XLang(encoding), utf8.into_bytes()),
-                    ))
-                }
-                VStackValue::Constant(Value::ByteString { content }) => {
-                    self.push_value(VStackValue::Pointer(
-                        pty.clone(),
-                        LValue::StringLiteral(Encoding::Byte, content),
-                    ))
-                }
-                VStackValue::Constant(Value::GlobalAddress { item, .. }) => self.push_value(
-                    VStackValue::Pointer(pty.clone(), LValue::GlobalAddress(item)),
-                ),
-                VStackValue::Constant(Value::Uninitialized(Type::Pointer(_))) => self.push_value(
-                    VStackValue::Constant(Value::Uninitialized(Type::Pointer(pty.clone()))),
-                ),
-                VStackValue::Constant(Value::Invalid(Type::Pointer(_))) => {
-                    self.push_value(VStackValue::Trapped);
-                    self.inner.write_trap(Trap::Unreachable)
-                }
-                VStackValue::Pointer(_, lval) => {
-                    self.push_value(VStackValue::Pointer(pty.clone(), lval))
-                }
-                VStackValue::Trapped => {
-                    self.push_value(VStackValue::Trapped);
-                }
-                VStackValue::OpaqueScalar(sty, _) => todo!("{:?} as {:?}", sty, pty),
-                val => panic!("Invalid value for convert _ {:?}: {:?}", pty, val),
-            },
-            Expr::Convert(_, Type::Scalar(sty)) => match self.pop_value().unwrap() {
-                VStackValue::Constant(Value::Uninitialized(Type::Scalar(_))) => self.push_value(
-                    VStackValue::Constant(Value::Uninitialized(Type::Scalar(*sty))),
-                ),
-                VStackValue::Constant(Value::Invalid(Type::Scalar(_))) => {
-                    self.push_value(VStackValue::Trapped);
-                    self.inner.write_trap(Trap::Unreachable)
-                }
-                VStackValue::Constant(Value::Integer { ty, val }) => {
-                    let mut newval = val & (!0 >> (128 - sty.header.bitsize.min(128)));
-
-                    if matches!(
-                        sty,
-                        ScalarType {
-                            kind: ScalarTypeKind::Integer { signed: true, .. },
-                            ..
-                        }
-                    ) {
-                        let bits = match ty {
-                            ScalarType {
-                                kind: ScalarTypeKind::Integer { signed: true, .. },
-                                header: ScalarTypeHeader { bitsize, .. },
-                            } => bitsize,
-                            _ => sty.header.bitsize.min(128),
-                        };
-
-                        let bit = newval >> bits.saturating_sub(1);
-
-                        newval |= !(bit.wrapping_sub(1)) << bits.saturating_sub(1);
-                    }
-
-                    self.push_value(VStackValue::Constant(Value::Integer {
-                        ty: *sty,
-                        val: newval,
-                    }));
-                }
-                VStackValue::OpaqueScalar(psty, loc) => {
-                    let ty = Type::Scalar(*sty);
-
-                    let newloc = self.inner.allocate(&ty, false);
-
-                    self.inner
-                        .write_scalar_convert(*sty, psty, newloc.clone(), loc);
-
-                    self.push_value(VStackValue::OpaqueScalar(*sty, newloc));
-                }
-                val => panic!("Invalind input for convert {}: {:?}", sty, val),
-            },
-            Expr::Convert(str, ty) => todo!("convert {:?} {:?}", str, ty),
-            Expr::Derive(_, expr) => {
-                self.write_expr(expr);
-            }
-            Expr::Local(n) => {
-                let param_cnt = u32::try_from(self.fnty.params.len()).unwrap();
-                let ty = if *n < param_cnt {
-                    self.fnty.params[*n as usize].clone()
-                } else {
-                    self.locals[((*n) - param_cnt) as usize].1.clone()
-                };
-                self.push_value(VStackValue::LValue(ty, LValue::Local(*n)))
-            }
-            Expr::Pop(n) => {
-                for val in self.pop_values((*n).try_into().unwrap()).unwrap() {
-                    match val {
-                        VStackValue::Constant(Value::Invalid(_)) => {
-                            self.inner.write_trap(Trap::Unreachable);
-                            self.diverged = true;
-                            break;
-                        }
-                        VStackValue::Trapped => self.diverged = true,
-                        _ => {}
-                    }
-                }
-            }
-            Expr::Dup(n) => {
-                let values = self.pop_values((*n).try_into().unwrap()).unwrap();
-                self.push_values(values.clone());
-                self.push_values(values);
-            }
-            Expr::Pivot(n, m) => {
-                eprintln!("pivot {} {}", n, m);
-                let vals1 = self.pop_values((*m).try_into().unwrap()).unwrap();
-                let vals2 = self.pop_values((*n).try_into().unwrap()).unwrap();
-                self.push_values(vals1);
-                self.push_values(vals2);
-            }
-            Expr::Aggregate(ctor) => {
-                let vals = self.pop_values(ctor.fields.len()).unwrap();
-                self.push_value(VStackValue::AggregatePieced(
-                    ctor.ty.clone(),
-                    ctor.fields.iter().cloned().zip(vals).collect(),
-                ));
-            }
-            Expr::Member(m) => {
-                let val = self.pop_value().unwrap();
-
-                match val {
-                    VStackValue::LValue(ty, lval) => {
-                        let layout = self.tys.aggregate_layout(&ty).unwrap();
-                        let inner_ty = layout.fields.get(&m.to_string());
-
-                        match inner_ty {
-                            StdSome((_, inner_ty)) => self.push_value(VStackValue::LValue(
-                                inner_ty.clone(),
-                                LValue::Field(ty, Box::new(lval), m.clone()),
-                            )),
-                            _ => panic!("Cannot get member {} of {}", m, ty),
-                        }
-                    }
-                    VStackValue::OpaqueAggregate(ty, loc) => {
-                        let layout = self.tys.aggregate_layout(&ty).unwrap();
-                        let inner_ty = layout.fields.get(&m.to_string()).unwrap();
-
-                        if (inner_ty.0 == 0) && layout.fields.iter().count() == 1 {
-                            let val = self.opaque_value(&inner_ty.1, loc);
-                            self.push_value(val);
-                        } else {
-                            todo!("opaque aggregate")
-                        }
-                    }
-                    val => panic!("cannot get member {} of {}", m, val),
-                }
-            }
-            Expr::MemberIndirect(_) => todo!(),
-            Expr::Assign(cl) => {
-                let lval = self.vstack.pop_back().unwrap();
-                let value = self.vstack.pop_back().unwrap();
-
-                let (_, lval) = match lval {
-                    VStackValue::LValue(ty, lval) => (ty, lval),
-                    val => panic!("Cannot assign to rvalue stack value {:?}", val),
-                };
-
-                match (lval, value) {
-                    (LValue::Null, _)
-                    | (LValue::Label(_), _)
-                    | (LValue::StringLiteral(_, _), _)
-                    | (_, VStackValue::Constant(Value::Invalid(_))) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    (_, VStackValue::Trapped) => {
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    (LValue::Local(n), val) => {
-                        let loc = self.locals[n as usize].0.clone();
-
-                        match loc {
-                            VStackValue::Trapped => {
-                                self.push_value(VStackValue::Trapped);
-                            }
-                            VStackValue::OpaqueScalar(_, loc)
-                            | VStackValue::OpaqueAggregate(_, loc)
-                            | VStackValue::Pointer(_, LValue::OpaquePointer(loc)) => {
-                                self.move_val(val, loc);
-                            }
-                            _ => {
-                                self.locals[n as usize].0 = val;
-                            }
-                        }
-                    }
-                    (LValue::OpaquePointer(loc), val) => self.store_val(loc, val, *cl),
-                    (a, b) => todo!("store {:?} <- {:?}", a, b),
-                }
-            }
-            Expr::AsRValue(_) => {
-                let lvalue = self.pop_value().unwrap();
-                let (ty, lvalue) = match lvalue {
-                    VStackValue::LValue(ty, lvalue) => (ty, lvalue),
-                    val => panic!("Invalid value for as_rvalue {:?}", val),
-                };
-
-                let (_, base, path) = self.get_field_paths(lvalue, &ty);
-
-                let mut val = match base {
-                    LValue::Null => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        VStackValue::Trapped
-                    }
-                    LValue::Temporary(val) => Box::into_inner(val),
-                    LValue::OpaquePointer(loc) => {
-                        let dst = self.inner.allocate(&ty, false);
-                        self.inner.load_val(loc, dst.clone());
-
-                        self.opaque_value(&ty, dst)
-                    }
-
-                    LValue::Local(n) => {
-                        let local = self.locals[n as usize].0.clone();
-                        if let Some(loc) = local.opaque_location() {
-                            let dst = self.inner.allocate(&ty, false);
-                            self.inner.move_val(loc.clone(), dst.clone());
-                            self.opaque_value(&ty, dst)
-                        } else {
-                            local
-                        }
-                    }
-                    LValue::GlobalAddress(_) => todo!("as_rvalue global_address"),
-                    LValue::Label(_) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        VStackValue::Trapped
-                    }
-                    LValue::Field(_, _, _) => todo!("as_rvalue field"),
-                    LValue::StringLiteral(_, _) => todo!("as_rvalue string_literal"),
-                    LValue::Offset(_, _) => todo!("as_rvalue offset"),
-                    LValue::TransparentAddr(_) => todo!("absolute addr"),
-                };
-
-                for f in &path {
-                    val = match val {
-                        VStackValue::Constant(_) => todo!(),
-                        VStackValue::LValue(_, _) => todo!(),
-                        VStackValue::Pointer(_, _) => todo!(),
-                        VStackValue::OpaqueScalar(_, _) => todo!(),
-                        VStackValue::AggregatePieced(base, mut fields) => {
-                            let inner = fields.remove(f);
-
-                            if let StdSome(Pair(_, inner)) = inner {
-                                inner
-                            } else {
-                                let fty = self.tys.get_field_type(&base, f).unwrap();
-                                self.tys.zero_init(&fty).unwrap().into_transparent_for()
-                            }
-                        }
-                        VStackValue::OpaqueAggregate(_, _) => todo!(),
-                        VStackValue::CompareResult(_, _) => todo!(),
-                        VStackValue::Trapped => VStackValue::Trapped,
-                        VStackValue::ArrayRepeat(_, _) => todo!(),
-                    }
-                }
-                self.push_value(val);
-            }
-            Expr::CompoundAssign(op, v, acc) => {
-                let [rhs, lval] = self.pop_values_static().unwrap();
-
-                let (ty, lval) = match lval {
-                    VStackValue::Trapped => {
-                        self.push_value(VStackValue::Trapped);
-                        return;
-                    }
-                    VStackValue::LValue(ty, lval) => (ty, lval),
-                    val => panic!("Invalid value {}", val),
-                };
-
-                let (_, base, fields) = self.get_field_paths(lval, &ty);
-
-                match base {
-                    LValue::OpaquePointer(_) => todo!(),
-                    LValue::Local(n) => {
-                        let mut val = &mut self.locals[n as usize].0;
-
-                        let tys = &self.tys;
-
-                        let mut it = fields.into_iter();
-
-                        for field in &mut it {
-                            match val {
-                                VStackValue::Constant(Value::Invalid(_)) => {
-                                    self.inner.write_trap(Trap::Unreachable);
-                                    self.push_value(VStackValue::Trapped);
-                                    return;
-                                }
-                                VStackValue::Constant(Value::Uninitialized(ty)) => {
-                                    let mut aggregate = HashMap::<String, _>::new();
-
-                                    for Pair(name, (_, ty)) in
-                                        tys.aggregate_layout(ty).unwrap().fields
-                                    {
-                                        let _ = aggregate.insert(
-                                            name.into(),
-                                            VStackValue::Constant(Value::Uninitialized(ty)),
-                                        );
-                                    }
-
-                                    *val = VStackValue::AggregatePieced(
-                                        core::mem::replace(ty, Type::Null),
-                                        aggregate,
-                                    );
-
-                                    match val {
-                                        VStackValue::AggregatePieced(_, vals) => {
-                                            val = vals.get_mut(&field).unwrap()
-                                        }
-                                        _ => unsafe { core::hint::unreachable_unchecked() },
-                                    }
-                                }
-                                VStackValue::AggregatePieced(ty, vals) => {
-                                    val = vals.get_or_insert_with_mut(field, |field| {
-                                        let field_ty = tys.get_field_type(ty, field).unwrap();
-                                        tys.zero_init(&field_ty).unwrap().into_transparent_for()
-                                    });
-                                }
-                                VStackValue::OpaqueAggregate(_, _) => todo!("opaque aggregate"),
-                                VStackValue::Trapped => break,
-                                val => panic!("Invalid value {}", val),
-                            }
-                        }
-
-                        if *acc == AccessClass::Normal {
-                            let underlying = core::mem::replace(val, VStackValue::Trapped);
-
-                            match (underlying, rhs) {
-                                (VStackValue::Constant(Value::Invalid(_)), _)
-                                | (_, VStackValue::Constant(Value::Invalid(_))) => {
-                                    self.inner.write_trap(Trap::Unreachable);
-                                }
-                                (VStackValue::Trapped, _) | (_, VStackValue::Trapped) => {}
-                                (
-                                    underlying @ VStackValue::Constant(Value::Uninitialized(_)),
-                                    _,
-                                )
-                                | (
-                                    underlying @ VStackValue::OpaqueScalar(_, _),
-                                    VStackValue::Constant(Value::Uninitialized(_)),
-                                ) => {
-                                    *val = underlying;
-                                    match *v {
-                                        OverflowBehaviour::Trap => {
-                                            self.inner.write_trap(Trap::Unreachable);
-                                            self.diverged = true;
-                                        }
-                                        OverflowBehaviour::Checked => {
-                                            let bool_sty = ScalarType {
-                                                header: ScalarTypeHeader {
-                                                    bitsize: 1,
-                                                    ..Default::default()
-                                                },
-                                                kind: ScalarTypeKind::Integer {
-                                                    signed: false,
-                                                    min: None,
-                                                    max: None,
-                                                },
-                                            };
-                                            self.push_value(VStackValue::Constant(
-                                                Value::Uninitialized(Type::Scalar(bool_sty)),
-                                            ))
-                                        }
-                                        _ => {}
-                                    }
-                                }
-                                (_, res @ VStackValue::Constant(Value::Uninitialized(_))) => {
-                                    *val = res;
-                                    match *v {
-                                        OverflowBehaviour::Trap => {
-                                            self.inner.write_trap(Trap::Unreachable);
-                                            self.diverged = true;
-                                        }
-                                        OverflowBehaviour::Checked => {
-                                            let bool_sty = ScalarType {
-                                                header: ScalarTypeHeader {
-                                                    bitsize: 1,
-                                                    ..Default::default()
-                                                },
-                                                kind: ScalarTypeKind::Integer {
-                                                    signed: false,
-                                                    min: None,
-                                                    max: None,
-                                                },
-                                            };
-                                            self.push_value(VStackValue::Constant(
-                                                Value::Uninitialized(Type::Scalar(bool_sty)),
-                                            ))
-                                        }
-                                        _ => {}
-                                    }
-                                }
-                                (
-                                    VStackValue::Constant(Value::Integer {
-                                        ty: sty1,
-                                        val: val1,
-                                    }),
-                                    VStackValue::Constant(Value::Integer {
-                                        ty: sty2,
-                                        val: val2,
-                                    }),
-                                ) => match (sty1, sty2) {
-                                    (
-                                        ScalarType {
-                                            header:
-                                                ScalarTypeHeader {
-                                                    bitsize: bit1,
-                                                    vectorsize: None,
-                                                    ..
-                                                },
-                                            kind: ScalarTypeKind::Integer { signed: false, .. },
-                                        },
-                                        ScalarType {
-                                            header:
-                                                ScalarTypeHeader {
-                                                    vectorsize: None, ..
-                                                },
-                                            kind: ScalarTypeKind::Integer { signed: false, .. },
-                                        },
-                                    ) => {
-                                        let (res, overflow) = match *op{
-                                                    BinaryOp::Add => val1.overflowing_add(val2),
-                                                    BinaryOp::Sub => val1.overflowing_sub(val2),
-                                                    BinaryOp::Mul => val1.overflowing_mul(val2),
-                                                    BinaryOp::Div => {
-                                                        if val2==0{
-                                                            (0,true)
-                                                        }else{
-                                                            val1.overflowing_div(val2)
-                                                        }
-                                                    }
-                                                    BinaryOp::Mod => {
-                                                        if val2==0{
-                                                            (0,true)
-                                                        }else{
-                                                            val1.overflowing_rem(val2)
-                                                        }
-                                                    }
-                                                    BinaryOp::BitAnd => (val1&val2,false),
-                                                    BinaryOp::BitOr => (val1|val2,false),
-                                                    BinaryOp::BitXor => (val1|val2,false),
-                                                    BinaryOp::Lsh => (val1.wrapping_shl(val2 as u32),u16::try_from(val2).map(|val|val>bit1).unwrap_or(true)),
-                                                    BinaryOp::Rsh => (val1.wrapping_shr(val2 as u32),u16::try_from(val2).map(|val|val>bit1).unwrap_or(true)),
-                                                    op => panic!("Cannot perform binary operation {} as compound_assign",op)
-                                                };
-
-                                        let mask = (!0u128).wrapping_shr(128 - (bit1 as u32));
-
-                                        let mres = res & mask;
-
-                                        let overflow = overflow || (mres != res);
-
-                                        let res = match *v {
-                                            OverflowBehaviour::Saturate => {
-                                                let mres = if overflow {
-                                                    if *op == BinaryOp::Rsh || *op == BinaryOp::Sub
-                                                    {
-                                                        0
-                                                    } else {
-                                                        mask
-                                                    }
-                                                } else {
-                                                    res
-                                                };
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Wrap => {
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Checked => {
-                                                let bool_sty = ScalarType {
-                                                    header: ScalarTypeHeader {
-                                                        bitsize: 1,
-                                                        ..Default::default()
-                                                    },
-                                                    kind: ScalarTypeKind::Integer {
-                                                        signed: false,
-                                                        min: None,
-                                                        max: None,
-                                                    },
-                                                };
-
-                                                self.vstack.push_back(VStackValue::Constant(
-                                                    Value::Integer {
-                                                        ty: bool_sty,
-                                                        val: overflow as u128,
-                                                    },
-                                                ));
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Trap => {
-                                                if overflow {
-                                                    self.inner.write_trap(Trap::Abort);
-                                                    self.diverged = true;
-                                                    return;
-                                                } else {
-                                                    VStackValue::Constant(Value::Integer {
-                                                        ty: sty1,
-                                                        val: mres,
-                                                    })
-                                                }
-                                            }
-                                            OverflowBehaviour::Unchecked => {
-                                                if overflow {
-                                                    VStackValue::Constant(Value::Uninitialized(
-                                                        Type::Scalar(sty1),
-                                                    ))
-                                                } else {
-                                                    VStackValue::Constant(Value::Integer {
-                                                        ty: sty1,
-                                                        val: mres,
-                                                    })
-                                                }
-                                            }
-                                            _ => panic!("Invalid overflow behaviour {}", v),
-                                        };
-
-                                        *val = res;
-                                    }
-                                    (
-                                        ScalarType {
-                                            header:
-                                                ScalarTypeHeader {
-                                                    bitsize: bit1,
-                                                    vectorsize: None,
-                                                    ..
-                                                },
-                                            kind: ScalarTypeKind::Integer { signed: true, .. },
-                                        },
-                                        ScalarType {
-                                            header:
-                                                ScalarTypeHeader {
-                                                    vectorsize: None, ..
-                                                },
-                                            kind: ScalarTypeKind::Integer { signed: true, .. },
-                                        },
-                                    ) => {
-                                        let val1 = val1 as i128;
-                                        let val2 = val2 as i128;
-                                        let (res, overflow) = match *op{
-                                            BinaryOp::Add => val1.overflowing_add(val2),
-                                            BinaryOp::Sub => val1.overflowing_sub(val2),
-                                            BinaryOp::Mul => val1.overflowing_mul(val2),
-                                            BinaryOp::Div => {
-                                                if val2==0{
-                                                    (0,true)
-                                                }else{
-                                                    val1.overflowing_div(val2)
-                                                }
-                                            }
-                                            BinaryOp::Mod => {
-                                                if val2==0{
-                                                    (0,true)
-                                                }else{
-                                                    val1.overflowing_rem(val2)
-                                                }
-                                            }
-                                            BinaryOp::BitAnd => (val1&val2,false),
-                                            BinaryOp::BitOr => (val1|val2,false),
-                                            BinaryOp::BitXor => (val1|val2,false),
-                                            BinaryOp::Lsh => (val1.wrapping_shl(val2 as u32),u16::try_from(val2).map(|val|val>bit1).unwrap_or(true)),
-                                            BinaryOp::Rsh => (val1.wrapping_shr(val2 as u32),u16::try_from(val2).map(|val|val>bit1).unwrap_or(true)),
-                                            op => panic!("Cannot perform binary operation {} as compound_assign",op)
-                                        };
-
-                                        let mask =
-                                            (!0u128).wrapping_shr(128 - (bit1 as u32)) as i128;
-
-                                        let mres = res & mask;
-
-                                        let overflow = overflow
-                                            || ((128 - res.leading_ones() - res.leading_zeros())
-                                                < 128 - (bit1 as u32));
-
-                                        let mres = ((0i128
-                                            .wrapping_sub(mres.wrapping_shr(bit1.into()) & 1))
-                                        .wrapping_shl(bit1.into()))
-                                            as u128;
-
-                                        let res = match *v {
-                                            OverflowBehaviour::Saturate => {
-                                                let mres = if overflow {
-                                                    if *op == BinaryOp::Rsh || *op == BinaryOp::Sub
-                                                    {
-                                                        0
-                                                    } else {
-                                                        mask as u128
-                                                    }
-                                                } else {
-                                                    mres
-                                                };
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Wrap => {
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Checked => {
-                                                let bool_sty = ScalarType {
-                                                    header: ScalarTypeHeader {
-                                                        bitsize: 1,
-                                                        ..Default::default()
-                                                    },
-                                                    kind: ScalarTypeKind::Integer {
-                                                        signed: false,
-                                                        min: None,
-                                                        max: None,
-                                                    },
-                                                };
-
-                                                self.vstack.push_back(VStackValue::Constant(
-                                                    Value::Integer {
-                                                        ty: bool_sty,
-                                                        val: overflow as u128,
-                                                    },
-                                                ));
-                                                VStackValue::Constant(Value::Integer {
-                                                    ty: sty1,
-                                                    val: mres,
-                                                })
-                                            }
-                                            OverflowBehaviour::Trap => {
-                                                if overflow {
-                                                    self.inner.write_trap(Trap::Abort);
-                                                    self.diverged = true;
-                                                    return;
-                                                } else {
-                                                    VStackValue::Constant(Value::Integer {
-                                                        ty: sty1,
-                                                        val: mres,
-                                                    })
-                                                }
-                                            }
-                                            OverflowBehaviour::Unchecked => {
-                                                if overflow {
-                                                    VStackValue::Constant(Value::Uninitialized(
-                                                        Type::Scalar(sty1),
-                                                    ))
-                                                } else {
-                                                    VStackValue::Constant(Value::Integer {
-                                                        ty: sty1,
-                                                        val: mres,
-                                                    })
-                                                }
-                                            }
-                                            _ => panic!("Invalid overflow behaviour {}", v),
-                                        };
-
-                                        *val = res;
-                                    }
-                                    (sty1, sty2) => todo!("({},{})", sty1, sty2),
-                                },
-                                (val1, val2) => panic!("Invalid values {}, {}", val1, val2),
-                            }
-                        } else {
-                            todo!("compound_assign {}", acc)
-                        }
-                    }
-                    LValue::Temporary(_) => todo!(),
-                    LValue::GlobalAddress(_) => todo!(),
-                    LValue::TransparentAddr(_) => todo!(),
-                    _ => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                }
-            }
-            Expr::FetchAssign(_, _, _) => todo!(),
-            Expr::LValueOp(_, _) => todo!(),
-            Expr::UnaryLValue(_, _, _) => todo!(),
-            Expr::Indirect => {
-                let val = self.pop_value().unwrap();
-                match val {
-                    VStackValue::Pointer(pty, lval) => {
-                        self.push_value(VStackValue::LValue(Box::into_inner(pty.inner), lval))
-                    }
-                    val => panic!("Invalid value for instruction {:?}", val),
-                }
-            }
-            Expr::AddrOf => {
-                let val = self.pop_value().unwrap();
-                match val {
-                    VStackValue::LValue(ty, lval) => self.push_value(VStackValue::Pointer(
-                        PointerType {
-                            inner: Box::new(ty),
-                            ..Default::default()
-                        },
-                        lval,
-                    )),
-                    val => panic!("Invalid value for instruction {:?}", val),
-                }
-            }
-            Expr::Sequence(_) => {}
-            Expr::Fence(barrier) => self.inner.write_barrier(*barrier),
-            Expr::Switch(Switch::Linear(s)) => {
-                let ctrl = self.pop_value().unwrap();
-                match ctrl {
-                    VStackValue::Constant(Value::Uninitialized(_) | Value::Invalid(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                    }
-                    VStackValue::Constant(Value::Integer { val, .. }) => {
-                        let val = val.wrapping_sub(s.min);
-                        let (idx, rem) = ((val / (s.scale as u128)), val % (s.scale as u128));
-                        let target = if rem != 0 || idx >= (s.cases.len() as u128) {
-                            s.default
-                        } else {
-                            s.cases[usize::try_from(idx).unwrap()]
-                        };
-
-                        self.branch_to(target);
-                    }
-                    VStackValue::OpaqueScalar(ty, loc) => {
-                        todo!("switch OpaqueScalar({:?},{:?})", ty, loc)
-                    }
-                    VStackValue::CompareResult(a, b) => {
-                        todo!("switch CompareResult({:?},{:?})", a, b)
-                    }
-                    VStackValue::Trapped => {}
-                    v => panic!("Invalid value for switch {:?}", v),
-                }
-            }
-            Expr::Switch(Switch::Hash(s)) => {
-                let ctrl = self.pop_value().unwrap();
-                match ctrl {
-                    VStackValue::Constant(Value::Uninitialized(_) | Value::Invalid(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                    }
-                    VStackValue::Constant(v @ Value::Integer { .. }) => {
-                        let mut found = None;
-                        for Pair(case, target) in &s.cases {
-                            if &v == case {
-                                found = Some(*target);
-                                break;
-                            }
-                        }
-                        let target = found.unwrap_or(s.default);
-
-                        self.branch_to(target);
-                    }
-                    VStackValue::OpaqueScalar(ty, loc) => {
-                        todo!("switch OpaqueScalar({:?},{:?})", ty, loc)
-                    }
-                    VStackValue::CompareResult(a, b) => {
-                        todo!("switch CompareResult({:?},{:?})", a, b)
-                    }
-                    VStackValue::Trapped => {}
-                    v => panic!("Invalid value for switch {:?}", v),
-                }
-            }
-            Expr::Tailcall(fnty) => {
-                let vals = self.pop_values(fnty.params.len()).unwrap();
-                let target = self.pop_value().unwrap();
-                match target {
-                    VStackValue::Constant(Value::GlobalAddress { ty, item }) => {
-                        let realty = match &ty {
-                            Type::FnType(ty) => &**ty,
-                            _ => fnty,
-                        };
-                        self.call_fn(fnty, realty, &item, vals, true);
-                    }
-                    VStackValue::Constant(Value::Invalid(_))
-                    | VStackValue::Constant(Value::Uninitialized(_))
-                    | VStackValue::Constant(Value::LabelAddress(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                    }
-                    VStackValue::Pointer(pty, lvalue) => {
-                        let ty = &*pty.inner;
-                        let realty = match &ty {
-                            Type::FnType(ty) => &**ty,
-                            _ => fnty,
-                        };
-                        match lvalue {
-                            LValue::OpaquePointer(loc) => {
-                                self.call_indirect(fnty, realty, loc, vals, true)
-                            }
-                            LValue::GlobalAddress(path) => {
-                                self.call_fn(fnty, realty, &path, vals, true)
-                            }
-                            LValue::TransparentAddr(_) => todo!("call abs"),
-                            _ => {
-                                self.inner.write_trap(Trap::Unreachable);
-                            }
-                        }
-                    }
-                    val => panic!("Invalid value {}", val),
-                }
-            }
-            Expr::Asm(asm) => self.write_asm(asm),
-            Expr::BeginStorage(n) => {
-                let local = &mut self.locals[(*n) as usize];
-                local.0 = VStackValue::Constant(Value::Uninitialized(local.1.clone()));
-            }
-            Expr::EndStorage(n) => {
-                let local = &mut self.locals[(*n) as usize];
-                local.0 = VStackValue::Constant(Value::Invalid(local.1.clone()));
-            }
-            Expr::Select(n) => {
-                let sel = self.pop_value().unwrap();
-                let possible_vals = self.pop_values(*n as usize).unwrap();
-                let tyof = possible_vals[0].value_type();
-                match sel {
-                    VStackValue::Trapped => {
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    VStackValue::Constant(Value::Invalid(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    VStackValue::Constant(Value::Uninitialized(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    VStackValue::Constant(Value::Integer {
-                        ty:
-                            ScalarType {
-                                kind: ScalarTypeKind::Integer { .. },
-                                ..
-                            },
-                        val,
-                    }) => {
-                        if val > (*n as u128) {
-                            self.push_value(VStackValue::Constant(Value::Invalid(tyof)))
-                        } else {
-                            self.push_value(possible_vals.into_iter().nth(val as usize).unwrap())
-                        }
-                    }
-                    val => todo!("{:?}", val),
-                }
-            }
-        }
+    pub fn write_expr(&mut self, _: &Expr) {
+        unimplemented!()
     }
 
     /// Writes an asm-expr
-    pub fn write_asm(&mut self, asm: &AsmExpr) {
-        let nexprs = asm.inputs.len();
-
-        let inputs = self.pop_values(nexprs).unwrap();
-
-        let vals = self.inner.write_asm(asm, inputs);
-
-        let vals = vals
-            .into_iter()
-            .zip(&asm.outputs)
-            .map(|(loc, ty)| self.opaque_value(&ty.ty, loc))
-            .collect::<Vec<_>>();
-
-        self.push_values(vals);
-    }
-
-    /// Writes the body of a function to the codegen
-    pub fn write_function_body(&mut self, body: &FunctionBody) {
-        let fnty: FnType = self.fnty.clone();
-        self.vstack.reserve(fnty.params.len());
-
-        for (i, ty) in fnty.params.iter().enumerate() {
-            let loc =
-                self.inner
-                    .get_callconv()
-                    .find_param(&fnty, &fnty, u32::try_from(i).unwrap(), true);
-            let val = self.opaque_value(ty, loc);
-            self.push_value(val);
-        }
-
-        self.locals.reserve(body.locals.len());
-        for ty in &body.locals {
-            self.locals.push((
-                VStackValue::Constant(Value::Uninitialized(ty.clone())),
-                ty.clone(),
-            ))
-        }
-        self.write_block(&body.block, 0);
-        if !self.diverged {
-            self.inner.leave_function();
-        }
+    pub fn write_asm(&mut self, _: &AsmExpr) {
+        unimplemented!()
     }
 
     /// Writes the elements of a block to the codegen, usually the top level block of a function
-    pub fn write_block(&mut self, block: &Block, _: u32) {
-        for item in &block.items {
-            match item {
-                xlang::ir::BlockItem::Target { num, stack } => {
-                    self.cfg
-                        .get_or_insert_with_mut(*num, |_| BranchToInfo::default())
-                        .fallthrough_from = self.ctarg;
-
-                    self.ctarg = *num;
-
-                    let values = stack
-                        .iter()
-                        .map(|item| match item {
-                            StackItem {
-                                kind: StackValueKind::LValue,
-                                ty,
-                            } => VStackValue::LValue(
-                                ty.clone(),
-                                LValue::OpaquePointer(self.inner.allocate_lvalue(false)),
-                            ),
-                            StackItem {
-                                kind: StackValueKind::RValue,
-                                ty,
-                            } => {
-                                let loc = self.inner.allocate(ty, false);
-                                self.opaque_value(ty, loc)
-                            }
-                        })
-                        .collect();
-                    self.targets.insert(*num, values);
-                }
-                xlang::ir::BlockItem::Expr(expr) => match expr {
-                    Expr::Branch {
-                        cond: BranchCondition::Never,
-                        ..
-                    } => {}
-                    Expr::Const(Value::LabelAddress(targ)) => {
-                        self.cfg
-                            .get_or_insert_with_mut(*targ, |_| BranchToInfo::default())
-                            .branch_from
-                            .insert(self.ctarg);
-                    }
-                    Expr::Branch { target, .. } => {
-                        self.cfg
-                            .get_or_insert_with_mut(*target, |_| BranchToInfo::default())
-                            .branch_from
-                            .insert(self.ctarg);
-                    }
-                    Expr::Switch(s) => match s {
-                        Switch::Linear(LinearSwitch { default, cases, .. }) => {
-                            self.cfg
-                                .get_or_insert_with_mut(*default, |_| BranchToInfo::default())
-                                .branch_from
-                                .insert(self.ctarg);
-
-                            for targ in cases {
-                                self.cfg
-                                    .get_or_insert_with_mut(*targ, |_| BranchToInfo::default())
-                                    .branch_from
-                                    .insert(self.ctarg);
-                            }
-                        }
-                        Switch::Hash(HashSwitch { default, cases, .. }) => {
-                            self.cfg
-                                .get_or_insert_with_mut(*default, |_| BranchToInfo::default())
-                                .branch_from
-                                .insert(self.ctarg);
-
-                            for Pair(_, targ) in cases {
-                                self.cfg
-                                    .get_or_insert_with_mut(*targ, |_| BranchToInfo::default())
-                                    .branch_from
-                                    .insert(self.ctarg);
-                            }
-                        }
-                    },
-                    _ => {}
-                },
-            }
-        }
-        self.ctarg = !0; // reset block position
-        for item in &block.items {
-            match item {
-                xlang::ir::BlockItem::Expr(expr) => self.write_expr(expr),
-                xlang::ir::BlockItem::Target { num, .. } => {
-                    self.ctarg = *num;
-                    if !self.locals_opaque {
-                        let mut locals = std::mem::take(&mut self.locals);
-
-                        for (local, _) in &mut locals {
-                            let val = core::mem::replace(local, VStackValue::Trapped);
-
-                            *local = self.make_opaque(val);
-                        }
-
-                        self.locals = locals;
-                        self.locals_opaque = true;
-                    }
-                    if !self.diverged {
-                        let locs = self.targets[num].clone();
-                        let vals = self.pop_values(locs.len()).unwrap();
-                        for (val, stack_val) in vals.into_iter().zip(locs) {
-                            self.move_val(val, stack_val.opaque_location().unwrap().clone());
-                        }
-                        self.clear_stack();
-                        for val in self.targets[num].clone() {
-                            self.push_value(val.clone());
-                        }
-                    } else if let StdSome(br) = self.cfg.get(num) {
-                        if !br.branch_from.is_empty() {
-                            self.clear_stack();
-                            for val in self.targets[num].clone() {
-                                self.push_value(val.clone());
-                            }
-                            self.diverged = false;
-                        } else {
-                            self.clear_stack();
-                        }
-                    }
-
-                    self.inner.write_target(*num);
-                }
-            }
-        }
+    pub fn write_block(&mut self, _: &Block, _: u32) {
+        unimplemented!()
     }
 }
diff --git a/xlang/xlang_backend/src/mc.rs b/xlang/xlang_backend/src/mc.rs
index d9bc31f0..067e1bda 100644
--- a/xlang/xlang_backend/src/mc.rs
+++ b/xlang/xlang_backend/src/mc.rs
@@ -8,9 +8,8 @@ use binfmt::{
 };
 use xlang::{
     abi::{
-        collection::HashMap, io::WriteAdapter, option::None as XLangNone,
-        option::Some as XLangSome, pair::Pair, result::Result::Ok as XLangOk, span::Span,
-        string::StringView, try_,
+        collection::HashMap, io::WriteAdapter, option::None as XLangNone, pair::Pair,
+        result::Result::Ok as XLangOk, span::Span, string::StringView, try_,
     },
     ir::{
         AccessClass, BinaryOp, FnType, Linkage, PathComponent, PointerKind, ScalarType,
@@ -782,108 +781,9 @@ impl<W: MCWriter> MCBackend<W> {
 impl<W: MCWriter> XLangPlugin for MCBackend<W> {
     fn accept_ir(
         &mut self,
-        ir: &mut xlang::ir::File,
+        _: &mut xlang::ir::File,
     ) -> xlang::abi::result::Result<(), xlang::plugin::Error> {
-        let mut tys = TypeInformation::from_properties(self.properties.unwrap());
-        for Pair(path, mem) in &ir.root.members {
-            match &mem.member_decl {
-                xlang::ir::MemberDeclaration::OpaqueAggregate(_) => {
-                    tys.add_opaque_aggregate(path.clone())
-                }
-                xlang::ir::MemberDeclaration::AggregateDefinition(defn) => {
-                    tys.add_aggregate(path.clone(), defn.clone())
-                }
-                _ => {}
-            }
-        }
-        let tys = Rc::new(tys);
-        for Pair(path, mem) in &ir.root.members {
-            match &mem.member_decl {
-                xlang::ir::MemberDeclaration::Function(f) => {
-                    let features = self
-                        .writer
-                        .get_features(self.properties.unwrap(), self.feature);
-                    let mangled_name = match &*path.components {
-                        [PathComponent::Root, PathComponent::Text(n)]
-                        | [PathComponent::Text(n)] => n.to_string(),
-                        [PathComponent::Root, rest @ ..] | [rest @ ..] => features.mangle(rest),
-                    };
-
-                    let linkage = f.linkage;
-                    let body = if let XLangSome(body) = &f.body {
-                        let section_spec = SectionSpec::GlobalSection;
-
-                        let innercg = MCFunctionCodegen {
-                            fn_name: mangled_name.clone(),
-                            inner: features,
-                            next_loc_id: 0,
-                            tys: tys.clone(),
-                            mc_insns: Vec::new(),
-                            strings: self.strings.clone(),
-                            callconv: CallConvAdaptor(self.writer.get_call_conv(
-                                &f.ty,
-                                self.properties.unwrap(),
-                                self.feature,
-                                Rc::clone(&tys),
-                            )),
-                            fnty: f.ty.clone(),
-                        };
-                        let mut fncg = FunctionCodegen::new(
-                            innercg,
-                            path.clone(),
-                            f.ty.clone(),
-                            self.properties.unwrap(),
-                            tys.clone(),
-                        );
-
-                        fncg.write_function_body(body);
-
-                        Some((section_spec, fncg))
-                    } else {
-                        None
-                    };
-
-                    self.functions
-                        .insert(mangled_name, MCFunctionDecl { linkage, body });
-                }
-                xlang::ir::MemberDeclaration::Static(st) => {
-                    let features = self
-                        .writer
-                        .get_features(self.properties.unwrap(), self.feature);
-                    let mangled_name = match &*path.components {
-                        [PathComponent::Root, PathComponent::Text(n)]
-                        | [PathComponent::Text(n)] => n.to_string(),
-                        [PathComponent::Root, rest @ ..] | [rest @ ..] => features.mangle(rest),
-                    };
-
-                    let linkage = st.linkage;
-
-                    let init = match &st.init {
-                        xlang::ir::Value::Empty => None,
-                        val => {
-                            let section_spec = SectionSpec::GlobalSection;
-                            let space = tys.type_size(&st.ty).unwrap();
-                            let align = tys.type_align(&st.ty).unwrap();
-                            let init: xlang::ir::Value = val.clone();
-                            let specifier = st.specifiers;
-                            Some(MCStaticDef {
-                                section: section_spec,
-                                init,
-                                space,
-                                align,
-                                specifier,
-                            })
-                        }
-                    };
-
-                    self.statics
-                        .insert(mangled_name, MCStaticDecl { linkage, init });
-                }
-                _ => {}
-            }
-        }
-        self.tys = Some(tys);
-        XLangOk(())
+        unimplemented!()
     }
 
     fn set_target(&mut self, targ: &'static TargetProperties<'static>) {
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
new file mode 100644
index 00000000..9c8296fa
--- /dev/null
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -0,0 +1,30 @@
+#![allow(missing_docs)]
+use std::rc::Rc;
+
+use xlang::ir::*;
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum SsaTerminator {
+    Fallthrough(u32, Vec<OpaqueLocation>),
+    Jump(u32, Vec<OpaqueLocation>),
+    Exit(u16),
+    Tailcall(CallTarget, Vec<OpaqueLocation>),
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct CallTarget {
+    pub ptr: OpaquePtr,
+    pub real_ty: FnType,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum OpaquePtr {
+    Symbol(String),
+    Pointer(OpaqueLocation),
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct OpaqueLocation {
+    pub ty: Rc<Type>,
+    pub num: u32,
+}
diff --git a/xlang/xlang_struct/Cargo.toml b/xlang/xlang_struct/Cargo.toml
index 9328a522..252a6599 100644
--- a/xlang/xlang_struct/Cargo.toml
+++ b/xlang/xlang_struct/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "xlang_struct"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
 edition = "2018"
 license = "BSD-2-Clause-Patent"
diff --git a/xlang/xlang_struct/src/fmt.rs b/xlang/xlang_struct/src/fmt.rs
index ec33a782..36420111 100644
--- a/xlang/xlang_struct/src/fmt.rs
+++ b/xlang/xlang_struct/src/fmt.rs
@@ -52,6 +52,51 @@ impl<'b, 'a> IrFormatter<'b, 'a> {
         Self(f)
     }
 
+    pub fn fmt_terminator(&mut self, term: &Terminator, tabs: Tabs) -> core::fmt::Result {
+        tabs.fmt(self)?;
+        match term {
+            Terminator::Jump(jump) => self.write_fmt(format_args!("jump {}", jump)),
+            Terminator::Branch(cond, then_targ, else_targ) => self.write_fmt(format_args!(
+                "branch {} {} else {}",
+                cond, then_targ, else_targ
+            )),
+            Terminator::BranchIndirect => self.write_str("branch indirect"),
+            Terminator::Call(flags, fnty, next) => {
+                self.write_fmt(format_args!("call {}function{} next {}", flags, fnty, next))
+            }
+            Terminator::Tailcall(flags, fnty) => {
+                self.write_fmt(format_args!("tailcall {}function{}", flags, fnty))
+            }
+            Terminator::Exit(vals) => self.write_fmt(format_args!("exit {}", vals)),
+            Terminator::Asm(asm) => asm.fmt(self),
+            Terminator::Switch(switch) => {
+                self.write_str("switch ")?;
+                let nested = tabs.nest();
+                match switch {
+                    Switch::Hash(switch) => {
+                        self.write_str("hash\n")?;
+                        for case in &switch.cases {
+                            self.write_fmt(format_args!("{}{}: {}\n", nested, case.0, case.1))?;
+                        }
+                        self.write_fmt(format_args!("{}default {}\n", nested, switch.default))?;
+                    }
+                    Switch::Linear(switch) => {
+                        self.write_fmt(format_args!(
+                            "linear {} min {} scale {}\n",
+                            switch.ty, switch.min, switch.scale
+                        ))?;
+                        for case in &switch.cases {
+                            self.write_fmt(format_args!("{}{}", nested, case))?;
+                        }
+                        self.write_fmt(format_args!("{}default {}\n", nested, switch.default))?;
+                    }
+                }
+                self.write_fmt(format_args!("{}end switch", tabs))
+            }
+            Terminator::Unreachable => self.write_str("unreachable"),
+        }
+    }
+
     /// Formats a scope member `mem` at the given `path` at the current nesting level given by `tabs`
     pub fn fmt_scope_member(
         &mut self,
@@ -93,10 +138,30 @@ impl<'b, 'a> IrFormatter<'b, 'a> {
                         self.write_fmt(format_args!("declare _{}: {};\n", local, ty))?;
                     }
 
-                    for item in &body.block.items {
+                    for block in &body.blocks {
                         nested.fmt(self)?;
-                        item.fmt(self)?;
+                        self.write_str("target @")?;
+                        block.target.fmt(self)?;
+                        self.write_str(" [")?;
+                        let mut sep = "";
+                        for item in &block.incoming_stack {
+                            self.write_str(sep)?;
+                            sep = ", ";
+                            item.fmt(self)?;
+                        }
+                        self.write_str("]{\n")?;
+                        let inner_nest = nested.nest();
+
+                        for expr in &block.expr {
+                            inner_nest.fmt(self)?;
+                            expr.fmt(self)?;
+                            self.write_str("\n")?;
+                        }
+
+                        self.fmt_terminator(&block.term, inner_nest)?;
                         self.write_str("\n")?;
+                        nested.fmt(self)?;
+                        self.write_str("}\n")?;
                     }
 
                     tabs.fmt(self)?;
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 8bd27f4e..c57c127b 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1784,26 +1784,9 @@ pub enum Expr {
     /// Operands: [..]=>[..,Value]
     Const(Value),
 
-    /// Exits the function
-    ///
-    /// # Stack
-    ///
-    /// Type Checking: [..,T1,T2,...,Tn]=>diverged
-    ///
-    /// Operands: [..,v1,v2,...,vn]=>diverged
-    Exit {
-        values: u16,
-    },
-
     /// Computes
     BinaryOp(BinaryOp, OverflowBehaviour),
     UnaryOp(UnaryOp, OverflowBehaviour),
-    CallFunction(FnType),
-    Branch {
-        cond: BranchCondition,
-        target: u32,
-    },
-    BranchIndirect,
     Convert(ConversionStrength, Type),
     Derive(PointerType, Box<Self>),
     Local(u32),
@@ -1823,9 +1806,6 @@ pub enum Expr {
     AddrOf,
 
     Fence(AccessClass),
-    Switch(Switch),
-    Tailcall(FnType),
-    Asm(AsmExpr),
     BeginStorage(u32),
     EndStorage(u32),
 
@@ -1851,14 +1831,8 @@ impl core::fmt::Display for Expr {
                 f.write_str("const ")?;
                 val.fmt(f)
             }
-            Self::Exit { values } => f.write_fmt(format_args!("exit {}", values)),
             Self::BinaryOp(op, v) => f.write_fmt(format_args!("{} {}", op, v)),
             Self::UnaryOp(op, v) => f.write_fmt(format_args!("{} {}", op, v)),
-            Self::CallFunction(fun) => f.write_fmt(format_args!("call {}", fun)),
-            Self::Branch { cond, target } => {
-                f.write_fmt(format_args!("branch {} @{}", cond, target))
-            }
-            Self::BranchIndirect => f.write_str("branch indirect"),
             Self::Convert(strength, ty) => f.write_fmt(format_args!("convert {} {}", strength, ty)),
             Self::Derive(pty, inner) => f.write_fmt(format_args!("derive {} {}", pty, inner)),
             Self::Local(n) => f.write_fmt(format_args!("local _{}", n)),
@@ -1895,9 +1869,6 @@ impl core::fmt::Display for Expr {
             Self::Sequence(AccessClass::Normal) => f.write_str("nop"),
             Self::Sequence(acc) => f.write_fmt(format_args!("sequence {}", acc)),
             Self::Fence(acc) => f.write_fmt(format_args!("fence {}", acc)),
-            Self::Switch(_) => todo!(),
-            Self::Tailcall(fun) => f.write_fmt(format_args!("tailcall {}", fun)),
-            Self::Asm(asm) => asm.fmt(f),
             Self::BeginStorage(n) => f.write_fmt(format_args!("begin storage _{}", n)),
             Self::EndStorage(n) => f.write_fmt(format_args!("end storage _{}", n)),
             Self::Select(n) => f.write_fmt(format_args!("select {}", n)),
@@ -1905,6 +1876,107 @@ impl core::fmt::Display for Expr {
     }
 }
 
+bitflags::bitflags! {
+    /// The flags for a jump target
+    ///
+    /// Matches the syntax:
+    /// ```abnf
+    /// jump-target-flag := "fallthrough" / "cold" / "continue"
+    /// ```
+    #[repr(transparent)]
+    pub struct JumpTargetFlags : u32{
+        /// The "fallthrough" flag.
+        /// Indicates that the jump does not perform a branch but instead continues on to the next basic block
+        ///
+        /// The behaviour is undefined if the `target` field of the [`JumpTarget`] is not the immediately adjacent basic block
+        const FALLTHROUGH = 1;
+        /// The "cold" flag.
+        /// Indicates that the branch is unlikely to be taken.
+        ///
+        /// The optimizer may pessimize the case where the branch is taken, to optimize the case where a different branch is taken
+        const COLD = 2;
+    }
+}
+
+impl core::fmt::Display for JumpTargetFlags {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.contains(Self::FALLTHROUGH) {
+            f.write_str("fallthrough ")?;
+        }
+        if self.contains(Self::COLD) {
+            f.write_str("cold ")?;
+        }
+        Ok(())
+    }
+}
+
+/// The target of a jump, such as a branch,
+/// Matches the syntax
+/// ```abnf
+/// jump-target := [*(<jump-target-flags>)] @<int-literal>
+/// ```
+#[repr(C)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct JumpTarget {
+    /// The flags for the jump
+    pub flags: JumpTargetFlags,
+    /// The target basic block
+    pub target: u32,
+}
+
+impl core::fmt::Display for JumpTarget {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        self.flags.fmt(f)?;
+        f.write_str("@")?;
+        self.target.fmt(f)
+    }
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct CallFlags: u32{
+        const WILLRETURN = 1;
+    }
+}
+
+impl core::fmt::Display for CallFlags {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.contains(Self::WILLRETURN) {
+            f.write_str("willreturn ")?;
+        }
+        Ok(())
+    }
+}
+
+/// A terminator of a [`Block`]
+///
+/// Matchs the `terminator` production
+#[repr(u32)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum Terminator {
+    /// Jump to another basic block, uncondtionally
+    /// Matches the syntax
+    /// ```abnf
+    /// terminator := "jump" <jump-target>
+    /// ```
+    Jump(JumpTarget),
+    /// Branch to one of two basic blocks, depending on the evaluation of a condition,
+    Branch(BranchCondition, JumpTarget, JumpTarget),
+    BranchIndirect,
+    Call(CallFlags, Box<FnType>, JumpTarget),
+    Tailcall(CallFlags, Box<FnType>),
+    Exit(u16),
+    Asm(AsmExpr),
+    Switch(Switch),
+    Unreachable,
+}
+
+impl Default for Terminator {
+    fn default() -> Self {
+        Self::Unreachable
+    }
+}
+
 #[repr(u16)]
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum AsmConstraint {
@@ -1991,9 +2063,10 @@ pub struct AsmExpr {
     pub access_class: AccessClass,
     pub string: String,
     pub clobbers: Vec<AsmConstraint>,
-    pub targets: Vec<u32>,
+    pub targets: Vec<JumpTarget>,
     pub inputs: Vec<AsmConstraint>,
     pub outputs: Vec<AsmOutput>,
+    pub next: Option<JumpTarget>,
 }
 
 impl core::fmt::Display for AsmExpr {
@@ -2143,8 +2216,8 @@ pub enum Switch {
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct HashSwitch {
-    pub cases: Vec<Pair<Value, u32>>,
-    pub default: u32,
+    pub cases: Vec<Pair<Value, JumpTarget>>,
+    pub default: JumpTarget,
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -2152,8 +2225,8 @@ pub struct LinearSwitch {
     pub ty: Type,
     pub min: u128,
     pub scale: u32,
-    pub default: u32,
-    pub cases: Vec<u32>,
+    pub default: JumpTarget,
+    pub cases: Vec<JumpTarget>,
 }
 
 #[repr(u8)]
@@ -2180,43 +2253,20 @@ impl core::fmt::Display for StackItem {
     }
 }
 
-#[repr(u8)]
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum BlockItem {
-    Expr(Expr),
-    Target { num: u32, stack: Vec<StackItem> },
-}
-
-impl core::fmt::Display for BlockItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Expr(expr) => expr.fmt(f),
-            Self::Target { num, stack } => {
-                f.write_fmt(format_args!("target @{} [", num))?;
-                let mut sep = "";
-
-                for item in stack {
-                    f.write_str(sep)?;
-                    sep = ", ";
-                    item.fmt(f)?;
-                }
-                f.write_str("]")
-            }
-        }
-    }
-}
-
 #[repr(C)]
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Default)]
 pub struct Block {
-    pub items: Vec<BlockItem>,
+    pub target: u32,
+    pub incoming_stack: Vec<StackItem>,
+    pub expr: Vec<Expr>,
+    pub term: Terminator,
 }
 
 #[repr(C)]
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Default)]
 pub struct FunctionBody {
     pub locals: Vec<Type>,
-    pub block: Block,
+    pub blocks: Vec<Block>,
 }
 
 #[repr(C)]

From fb347a142ddb5dce01f0d2b2a9ec3c4721c363a5 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 27 Jan 2024 22:11:50 -0500
Subject: [PATCH 02/74] fix(xlang): Reintroduce dependency on xlang-interface
 cdylib

---
 Cargo.lock          | 20 +++++++++++++++++++-
 lccc/src/exports.rs |  1 +
 xlang/Cargo.toml    |  1 +
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1879da9e..9713e6ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,7 +19,7 @@ version = "0.1.0"
 dependencies = [
  "install-dirs 0.3.2",
  "itertools",
- "lccc-siphash",
+ "lccc-siphash 0.1.0 (git+https://github.com/lccc-project/lccc-siphash)",
  "libc",
  "serde",
  "serde_derive",
@@ -293,6 +293,12 @@ dependencies = [
  "xlang_host",
 ]
 
+[[package]]
+name = "lccc-siphash"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15d185e10c787c464fc66c65e04e5ece989e1b654ab177bdad844248e9df71fc"
+
 [[package]]
 name = "lccc-siphash"
 version = "0.1.0"
@@ -660,6 +666,7 @@ dependencies = [
  "target-tuples",
  "xlang_abi",
  "xlang_host",
+ "xlang_interface",
  "xlang_struct",
  "xlang_targets",
 ]
@@ -704,6 +711,17 @@ dependencies = [
  "cfg-match",
 ]
 
+[[package]]
+name = "xlang_interface"
+version = "0.1.0"
+dependencies = [
+ "lazy_static",
+ "lccc-siphash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "xlang_abi",
+ "xlang_host",
+ "xlang_targets",
+]
+
 [[package]]
 name = "xlang_opt"
 version = "0.1.0"
diff --git a/lccc/src/exports.rs b/lccc/src/exports.rs
index 395577cf..65544dee 100644
--- a/lccc/src/exports.rs
+++ b/lccc/src/exports.rs
@@ -1,4 +1,5 @@
 xlang_host::rustcall! {
+    #[link(name = "xlang_interface", kind = "dylib")]
     extern "rustcall"{
         pub fn __xlang_driver_init_rng(key: u64);
     }
diff --git a/xlang/Cargo.toml b/xlang/Cargo.toml
index efd8d547..e3c05071 100644
--- a/xlang/Cargo.toml
+++ b/xlang/Cargo.toml
@@ -13,4 +13,5 @@ xlang_abi = {path="xlang_abi"}
 xlang_struct = {path="xlang_struct"}
 xlang_targets = {path="xlang_targets"}
 xlang_host = {path="xlang_host"}
+xlang_interface = {path="xlang_interface"}
 fake-enum ="0.1"

From 3144a1b02b46ac9d86fc547f4e461abaa336426e Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sat, 27 Jan 2024 21:47:53 -0600
Subject: [PATCH 03/74] feat(rust-irgen): start support for binary expr

---
 rust/src/irgen/xir_visitor.rs | 112 +++++++++++++++++++++++++++++++++-
 1 file changed, 111 insertions(+), 1 deletion(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 3d5e3d28..77d09e9b 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1723,7 +1723,19 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
     }
 
     fn visit_binary_expr(&mut self) -> Option<Box<dyn BinaryExprVisitor + '_>> {
-        todo!()
+        Some(Box::new(XirBinaryExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 
     fn visit_unary_expr(&mut self) -> Option<Box<dyn UnaryExprVisitor + '_>> {
@@ -1819,6 +1831,104 @@ impl<'a> Drop for XirTupleVisitor<'a> {
     }
 }
 
+pub struct XirBinaryExprVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    op: Option<ir::BinaryOp>,
+}
+
+impl<'a> XirBinaryExprVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+            op: None,
+        }
+    }
+}
+
+impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
+    fn visit_op(&mut self, op: BinaryOp) {
+        self.op = Some(match op {
+            BinaryOp::Sub => ir::BinaryOp::Sub,
+            x => todo!("{:?}", x),
+        });
+    }
+
+    fn visit_lhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+
+    fn visit_rhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+}
+
+impl<'a> Drop for XirBinaryExprVisitor<'a> {
+    fn drop(&mut self) {
+        *self.stack_height -= 1;
+        self.exprs.push(ir::Expr::BinaryOp(
+            self.op
+                .expect("BinaryExprVisitor::visit_op was never called"),
+            ir::OverflowBehaviour::Wrap,
+        ));
+    }
+}
+
 pub struct XirCastVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,

From 4b9e8aaec27dfb0765498665e7e0048a73f1d574 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sat, 27 Jan 2024 21:52:25 -0600
Subject: [PATCH 04/74] fix(rust-irgen): two problems: off by one errors.

---
 rust/src/irgen/xir_visitor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 77d09e9b..2fd66614 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1920,7 +1920,7 @@ impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
 
 impl<'a> Drop for XirBinaryExprVisitor<'a> {
     fn drop(&mut self) {
-        *self.stack_height -= 1;
+        *self.stack_height -= 2;
         self.exprs.push(ir::Expr::BinaryOp(
             self.op
                 .expect("BinaryExprVisitor::visit_op was never called"),

From 2c7cf3958e1c59a512fb2d4096b49c857bcb3d74 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sat, 27 Jan 2024 22:52:07 -0600
Subject: [PATCH 05/74] feat(rust-irgen): initial support for unary exprs

---
 rust/src/irgen/xir_visitor.rs | 96 ++++++++++++++++++++++++++++++++++-
 1 file changed, 95 insertions(+), 1 deletion(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 2fd66614..482d8249 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1739,7 +1739,19 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
     }
 
     fn visit_unary_expr(&mut self) -> Option<Box<dyn UnaryExprVisitor + '_>> {
-        todo!()
+        Some(Box::new(XirUnaryExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 }
 
@@ -1929,6 +1941,88 @@ impl<'a> Drop for XirBinaryExprVisitor<'a> {
     }
 }
 
+pub struct XirUnaryExprVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    op: Option<ir::UnaryOp>,
+}
+
+impl<'a> XirUnaryExprVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+            op: None,
+        }
+    }
+}
+
+impl<'a> UnaryExprVisitor for XirUnaryExprVisitor<'a> {
+    fn visit_op(&mut self, op: UnaryOp) {
+        self.op = Some(match op {
+            UnaryOp::Neg => ir::UnaryOp::Minus,
+            x => todo!("{:?}", x),
+        });
+    }
+
+    fn visit_lhs(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+}
+
+impl<'a> Drop for XirUnaryExprVisitor<'a> {
+    fn drop(&mut self) {
+        *self.stack_height -= 1;
+        self.exprs.push(ir::Expr::UnaryOp(
+            self.op
+                .expect("UnaryExprVisitor::visit_op was never called"),
+            ir::OverflowBehaviour::Wrap,
+        ));
+    }
+}
+
 pub struct XirCastVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,

From 7c3dccdd4b6d72f0cc00a073cec140929f02bc09 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 28 Jan 2024 00:45:28 -0600
Subject: [PATCH 06/74] feat(rust-xir): struct support

---
 rust/src/irgen/xir_visitor.rs | 264 +++++++++++++++++++++++++++++++++-
 1 file changed, 262 insertions(+), 2 deletions(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 482d8249..2ce664d4 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1711,11 +1711,35 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
     }
 
     fn visit_ctor(&mut self) -> Option<Box<dyn ConstructorVisitor + '_>> {
-        todo!()
+        Some(Box::new(XirConstructorVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 
     fn visit_field_subobject(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
-        todo!()
+        Some(Box::new(XirFieldSubobjectVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 
     fn visit_field_project(&mut self) -> Option<Box<dyn FieldAccessVisitor + '_>> {
@@ -1761,6 +1785,76 @@ impl<'a> Drop for XirExprVisitor<'a> {
     }
 }
 
+pub struct XirFieldSubobjectVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+}
+
+impl<'a> XirFieldSubobjectVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+        }
+    }
+}
+
+impl<'a> FieldAccessVisitor for XirFieldSubobjectVisitor<'a> {
+    fn visit_base(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+
+    fn visit_field(&mut self, field_name: &ty::FieldName) {
+        *self.stack_height -= 1;
+        self.exprs.push(ir::Expr::Member(match field_name {
+            ty::FieldName::Field(x) => x.to_string().into(),
+            x => todo!("{:?}", x),
+        }))
+    }
+}
+
 pub struct XirTupleVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
@@ -1843,6 +1937,172 @@ impl<'a> Drop for XirTupleVisitor<'a> {
     }
 }
 
+pub struct XirConstructorVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    ty: Option<ir::Type>,
+    fields: Vec<String>,
+}
+
+impl<'a> XirConstructorVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+            ty: None,
+            fields: vec![],
+        }
+    }
+}
+
+impl<'a> ConstructorVisitor for XirConstructorVisitor<'a> {
+    fn visit_ctor_def(&mut self, defid: DefId) {
+        self.ty = Some(ir::Type::Named(ir::Path {
+            components: vec![ir::PathComponent::Text(
+                self.names[&defid].to_string().into(),
+            )],
+        }));
+    }
+
+    fn visit_field(&mut self) -> Option<Box<dyn FieldInitVisitor + '_>> {
+        Some(Box::new(XirFieldInitVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+            &mut self.fields,
+        )))
+    }
+
+    fn visit_init(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        todo!("..default() and similar aren't currently handled by irgen")
+    }
+}
+
+impl<'a> Drop for XirConstructorVisitor<'a> {
+    fn drop(&mut self) {
+        let fields = std::mem::replace(&mut self.fields, vec![]);
+        *self.stack_height -= self.fields.len() as u32;
+
+        self.exprs.push(ir::Expr::Aggregate(ir::AggregateCtor {
+            ty: self
+                .ty
+                .take()
+                .expect("ConstructorVisitor::visit_ty was never called"),
+            fields: fields.into_iter().map(String::into).collect(),
+        }));
+    }
+}
+
+pub struct XirFieldInitVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+    fields: &'a mut Vec<String>,
+}
+
+impl<'a> XirFieldInitVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+        fields: &'a mut Vec<String>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+            fields,
+        }
+    }
+}
+
+impl<'a> FieldInitVisitor for XirFieldInitVisitor<'a> {
+    fn visit_field(&mut self, field_name: &ty::FieldName) {
+        self.fields.push(match field_name {
+            ty::FieldName::Field(x) => x.to_string(),
+            x => todo!("{:?}", x),
+        });
+    }
+
+    fn visit_value(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+}
+
 pub struct XirBinaryExprVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,

From 49b8fb201992ded1694cbe2c83190a7e7f9e7e6f Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Mon, 29 Jan 2024 14:29:24 -0600
Subject: [PATCH 07/74] feat(rust-parse): support char literals

---
 rust/src/lex.rs   |  1 -
 rust/src/parse.rs | 69 +++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 64 insertions(+), 6 deletions(-)

diff --git a/rust/src/lex.rs b/rust/src/lex.rs
index b4b0c02c..420eee99 100644
--- a/rust/src/lex.rs
+++ b/rust/src/lex.rs
@@ -512,7 +512,6 @@ impl LexemeClass {
                 AstFrag::Vis(_) => Self::AstFrag(Some(AstFragClass::Vis)),
                 AstFrag::Meta(_) => Self::AstFrag(Some(AstFragClass::Meta)),
             },
-            _ => todo!(),
         }
     }
 
diff --git a/rust/src/parse.rs b/rust/src/parse.rs
index 0092fbfe..9dedea18 100644
--- a/rust/src/parse.rs
+++ b/rust/src/parse.rs
@@ -16,8 +16,7 @@ use crate::{
     },
     interning::Symbol,
     lex::{
-        AstFrag, AstFragClass, Group, GroupType, IsEof, Keyword, Lexeme, LexemeBody, LexemeClass,
-        Punctuation, StringType, Token, TokenType,
+        AstFrag, AstFragClass, CharType, Group, GroupType, IsEof, Keyword, Lexeme, LexemeBody, LexemeClass, Punctuation, StringType, Token, TokenType
     },
     sema::ty::Mutability,
     span::{Pos, Span},
@@ -800,6 +799,7 @@ pub fn do_user_type_enum(
 
         let (startspan, var_id) = do_lexeme_token(&mut inner_tree, LexemeClass::Identifier)?;
 
+        // FIXME: What is this used for?
         let var_name = Spanned {
             body: var_id.body,
             span: startspan,
@@ -1169,7 +1169,7 @@ pub fn do_statement(
 pub fn do_literal(
     tree: &mut PeekMoreIterator<impl Iterator<Item = Lexeme>>,
 ) -> Result<Spanned<Literal>> {
-    // Only handling int and string lits for now
+    // Only handling int, string, and char lits for now
     match do_lexeme_class(tree, LexemeClass::Number) {
         Ok(x) => {
             let span = x.span;
@@ -1195,7 +1195,19 @@ pub fn do_literal(
                     span,
                 })
             }
-            Err(b) => Err(a | b)?, // TODO: Literally every other kind of useful literal
+            Err(b) => match do_char(tree) {
+                Ok((ch, ty)) => {
+                    let span = ch.span;
+                    Ok(Spanned {
+                        body: Literal {
+                            val: ch,
+                            lit_kind: LiteralKind::Char(ty),
+                        },
+                        span,
+                    })
+                }
+                Err(c) => Err(a | b | c)?, // TODO: Literally every other kind of useful literal
+            },
         },
     }
 }
@@ -2639,7 +2651,7 @@ pub fn do_pattern_binding(
     };
 
     let binding = match do_lexeme_classes(&mut tree, &[punct!(@), punct!(::)]) {
-        Ok((lex, punct!(@))) => Some(Box::new(do_pattern_param(&mut tree)?)),
+        Ok((_, punct!(@))) => Some(Box::new(do_pattern_param(&mut tree)?)),
         Ok((lex, punct!(::))) => {
             return Err(Error {
                 expected: vec![punct!(@)],
@@ -3217,6 +3229,53 @@ pub fn do_string(
     ))
 }
 
+pub fn do_char(
+    tree: &mut PeekMoreIterator<impl Iterator<Item = Lexeme>>,
+) -> Result<(Spanned<Symbol>, StringType)> {
+    let full_str = do_lexeme_class(tree, LexemeClass::Character)?;
+    let chr_ty = *if let Lexeme {
+        body:
+            LexemeBody::Token(Token {
+                ty: TokenType::Character(chr_ty),
+                ..
+            }),
+        ..
+    } = &full_str
+    {
+        chr_ty
+    } else {
+        unreachable!()
+    };
+    let str = full_str.text().unwrap();
+    let str = match chr_ty {
+        CharType::Default => &str[1..str.len() - 1], // Skip    " and "
+        CharType::Byte => &str[2..str.len() - 1],    // Skip   b" and "
+    };
+    let mut parsed = String::new();
+    let mut str_iter = str.chars();
+    while let Some(c) = str_iter.next() {
+        match c {
+            '\\' => match str_iter.next() {
+                Some('0') => parsed.push('\0'),
+                Some('n') => parsed.push('\n'),
+                None => todo!("throw an error"),
+                Some(x) => todo!("\\{}", x),
+            },
+            x => parsed.push(x),
+        }
+    }
+    Ok((
+        Spanned {
+            body: parsed.into(),
+            span: full_str.span,
+        },
+        match chr_ty {
+            CharType::Default => StringType::Default,
+            CharType::Byte => StringType::Byte,
+        },
+    ))
+}
+
 pub fn do_item_extern_block(
     tree: &mut PeekMoreIterator<impl Iterator<Item = Lexeme>>,
 ) -> Result<Spanned<ItemBody>> {

From 72a31934e8170874897e2fcab4670019347ff6ba Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Mon, 29 Jan 2024 14:45:56 -0600
Subject: [PATCH 08/74] feat(rust-hir): support char literals

---
 rust/src/ast.rs       |  4 ++--
 rust/src/parse.rs     |  7 ++-----
 rust/src/sema/hir.rs  | 16 +++++++++++++---
 rust/src/sema/tyck.rs |  3 +++
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/rust/src/ast.rs b/rust/src/ast.rs
index 2d860c1a..00504dcb 100644
--- a/rust/src/ast.rs
+++ b/rust/src/ast.rs
@@ -3,7 +3,7 @@ use core::fmt;
 use crate::lex::Group;
 use crate::{interning::Symbol, lex::Lexeme};
 
-pub use crate::lex::StringType;
+pub use crate::lex::{CharType, StringType};
 
 pub use crate::span::Spanned;
 
@@ -433,7 +433,7 @@ impl core::fmt::Display for Literal {
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum LiteralKind {
     String(StringType),
-    Char(StringType),
+    Char(CharType),
     Int(Option<Spanned<Symbol>>),
     Float(Option<Spanned<Symbol>>),
     Bool,
diff --git a/rust/src/parse.rs b/rust/src/parse.rs
index 9dedea18..7acf0a14 100644
--- a/rust/src/parse.rs
+++ b/rust/src/parse.rs
@@ -3231,7 +3231,7 @@ pub fn do_string(
 
 pub fn do_char(
     tree: &mut PeekMoreIterator<impl Iterator<Item = Lexeme>>,
-) -> Result<(Spanned<Symbol>, StringType)> {
+) -> Result<(Spanned<Symbol>, CharType)> {
     let full_str = do_lexeme_class(tree, LexemeClass::Character)?;
     let chr_ty = *if let Lexeme {
         body:
@@ -3269,10 +3269,7 @@ pub fn do_char(
             body: parsed.into(),
             span: full_str.span,
         },
-        match chr_ty {
-            CharType::Default => StringType::Default,
-            CharType::Byte => StringType::Byte,
-        },
+        chr_ty,
     ))
 }
 
diff --git a/rust/src/sema/hir.rs b/rust/src/sema/hir.rs
index 9e899172..116460f6 100644
--- a/rust/src/sema/hir.rs
+++ b/rust/src/sema/hir.rs
@@ -1,6 +1,6 @@
 use xlang::abi::collection::HashMap;
 
-use crate::ast::{self, Literal, LiteralKind, Mutability, Safety, StringType};
+use crate::ast::{self, CharType, Literal, LiteralKind, Mutability, Safety, StringType};
 use crate::helpers::{FetchIncrement, TabPrinter};
 use crate::interning::Symbol;
 use crate::span::{synthetic, Span};
@@ -85,6 +85,7 @@ pub enum HirExpr {
     Var(HirVarId),
     ConstInt(Option<Spanned<IntType>>, u128),
     ConstString(StringType, Spanned<Symbol>),
+    ConstChar(CharType, Spanned<Symbol>),
     Const(DefId, GenericArgs),
     #[allow(dead_code)]
     Unreachable,
@@ -127,6 +128,11 @@ impl core::fmt::Display for HirExpr {
                 s.escape_default().fmt(f)?;
                 f.write_str("\"")
             }
+            HirExpr::ConstChar(_, s) => {
+                f.write_str("'")?;
+                s.escape_default().fmt(f)?;
+                f.write_str("'")
+            }
             HirExpr::Tuple(v) => {
                 f.write_str("(")?;
                 let mut sep = "";
@@ -710,9 +716,13 @@ impl<'a> HirLowerer<'a> {
                     Ok(expr.copy_span(|_| HirExpr::ConstInt(ty, val)))
                 }
                 Literal {
-                    lit_kind: LiteralKind::String(skind),
+                    lit_kind: LiteralKind::String(sty),
+                    val: sym,
+                } => Ok(expr.copy_span(|_| HirExpr::ConstString(sty, sym))),
+                Literal {
+                    lit_kind: LiteralKind::Char(cty),
                     val: sym,
-                } => Ok(expr.copy_span(|_| HirExpr::ConstString(skind, sym))),
+                } => Ok(expr.copy_span(|_| HirExpr::ConstChar(cty, sym))),
                 _ => todo!("literal"),
             },
             ast::Expr::Break(_, _) => todo!("break"),
diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
index 273863c9..9d71c40a 100644
--- a/rust/src/sema/tyck.rs
+++ b/rust/src/sema/tyck.rs
@@ -692,6 +692,9 @@ impl<'a> ThirConverter<'a> {
                     cat: ValueCategory::Rvalue,
                 })
             }
+            &hir::HirExpr::ConstChar(cty, val) => {
+                todo!("const char");
+            }
             hir::HirExpr::Const(defid, generics) => {
                 let def = self.defs.definition(*defid);
 

From 25937b5029bb9a5ca28d461de858e93887daba75 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Tue, 30 Jan 2024 23:25:08 -0500
Subject: [PATCH 09/74] feat(xlang-backend): Start rewrite for new format

---
 codegen-clever/src/lib.rs              |   62 +-
 codegen-w65/src/lib.rs                 |  409 +----
 codegen-x86/src/lib.rs                 |   86 +-
 lc-binutils                            |    2 +-
 lccc/src/main.rs                       |    1 +
 lccc/src/session.rs                    |    9 +-
 xlang/xlang_abi/src/vec.rs             |   77 +
 xlang/xlang_backend/src/expr.rs        |  150 +-
 xlang/xlang_backend/src/intrinsic.rs   |  182 ---
 xlang/xlang_backend/src/lib.rs         | 1932 +++---------------------
 xlang/xlang_backend/src/mach.rs        |   42 +
 xlang/xlang_backend/src/mc.rs          | 1036 -------------
 xlang/xlang_backend/src/mc/callconv.rs |   31 -
 xlang/xlang_backend/src/mc/regalloc.rs |   22 -
 xlang/xlang_backend/src/ssa.rs         |  493 +++++-
 xlang/xlang_backend/src/ty.rs          |    2 +-
 xlang/xlang_host/build.rs              |    1 +
 17 files changed, 1074 insertions(+), 3463 deletions(-)
 create mode 100644 xlang/xlang_backend/src/mach.rs
 delete mode 100644 xlang/xlang_backend/src/mc.rs
 delete mode 100644 xlang/xlang_backend/src/mc/callconv.rs
 delete mode 100644 xlang/xlang_backend/src/mc/regalloc.rs

diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index 153443b4..9b351b27 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -1,11 +1,67 @@
-use xlang::plugin::XLangCodegen;
-use xlang::prelude::v1::*;
+use target_tuples::{Architecture, Target};
+use xlang::{
+    abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
+    targets::properties::TargetProperties,
+};
+use xlang_backend::{mach::Machine, SsaCodegenPlugin};
+
+pub struct CleverAssignments {}
+
+pub struct CleverClobbers {}
+
+pub struct CleverMachine {}
+
+impl Machine for CleverMachine {
+    fn matches_target(&self, targ: StringView) -> bool {
+        Target::parse(&targ).arch() == Architecture::Clever
+    }
+
+    fn init_from_target(&mut self, _: &TargetProperties) {}
+
+    type Assignments = CleverAssignments;
+
+    type BlockClobbers = CleverClobbers;
+
+    fn new_assignments(&self) -> Self::Assignments {
+        todo!()
+    }
+
+    fn assign_locations(
+        &self,
+        assignments: &mut Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        incoming: &[xlang_backend::ssa::OpaqueLocation],
+        which: u32,
+    ) -> Self::BlockClobbers {
+        todo!()
+    }
+
+    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
+        &self,
+        assignments: &Self::Assignments,
+        out: &mut W,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+
+    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
+        &self,
+        assignments: &Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        block_clobbers: Self::BlockClobbers,
+        out: &mut W,
+        label_sym: F,
+        which: u32,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+}
 
 xlang::host::rustcall! {
 #[no_mangle]
 #[allow(improper_ctypes_definitions)]
 pub extern "rustcall" fn xlang_backend_main() -> DynBox<dyn XLangCodegen> {
-    todo!()
+    DynBox::unsize_box(xlang::abi::boxed::Box::new(SsaCodegenPlugin::new(CleverMachine{})))
 }}
 
 xlang::plugin_abi_version!("0.1");
diff --git a/codegen-w65/src/lib.rs b/codegen-w65/src/lib.rs
index e1191477..1883dbd5 100644
--- a/codegen-w65/src/lib.rs
+++ b/codegen-w65/src/lib.rs
@@ -1,410 +1,67 @@
-use std::{
-    cell::RefCell, collections::HashSet, convert::TryFrom, ops::Deref, rc::Rc, str::FromStr,
-};
-
-use arch_ops::{
-    traits::{Address, InsnWrite},
-    w65::{W65Address, W65Encoder, W65Instruction, W65Mode, W65Opcode, W65Operand, W65Register},
-};
-use binfmt::{
-    fmt::{FileType, Section, SectionType},
-    sym::{SymbolKind, SymbolType},
-};
 use target_tuples::{Architecture, Target};
 use xlang::{
-    abi::{
-        option::Option::{None as XLangNone, Some as XLangSome},
-        span::Span,
-        string::StringView,
-    },
-    plugin::{OutputMode, XLangCodegen, XLangPlugin},
-    prelude::v1::{DynBox, HashMap, Pair},
-    targets::properties::{MachineProperties, TargetProperties},
-};
-use xlang_backend::{
-    callconv::CallingConvention,
-    expr::ValLocation,
-    mangle::mangle_itanium,
-    mc::{MCBackend, MCWriter, MachineFeatures},
-    str::StringMap,
-    ty::TypeInformation,
-    FunctionCodegen, FunctionRawCodegen,
-};
-use xlang_struct::{
-    AccessClass, AggregateDefinition, BinaryOp, FnType, FunctionDeclaration, PathComponent,
-    ScalarType, ScalarTypeHeader, ScalarTypeKind, Type,
+    abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
+    targets::properties::TargetProperties,
 };
+use xlang_backend::{mach::Machine, SsaCodegenPlugin};
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum W65ValLocation {
-    Register {
-        size: u16,
-        reg: W65Register,
-    },
-    Indirect {
-        size: u16,
-        reg: W65Register,
-        offset: i64,
-    },
-    Regs {
-        size: u64,
-        regs: Vec<W65Register>,
-    },
-    SyntheticRegister {
-        size: u64,
-        base: u32,
-    },
-    Null,
-    Unassigned(usize),
-}
-
-fn gcd(a: i64, b: i64) -> i64 {
-    if a == 0 {
-        b
-    } else if b == 0 {
-        a
-    } else {
-        gcd(b, a % b)
-    }
-}
-
-impl ValLocation for W65ValLocation {
-    fn addressible(&self) -> bool {
-        matches!(self, Self::Indirect { .. })
-    }
-
-    fn unassigned(n: usize) -> Self {
-        Self::Unassigned(n)
-    }
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum W65InstructionOrLabel {
-    Insn(W65Instruction),
-    Label(String),
-    FunctionEpilogue,
-    ClobberMode,
-    ClearModeFlags(W65Mode),
-    SetModeFlags(W65Mode),
-    ResetMode(W65Mode),
-    AssumeMode(W65Mode),
-}
-
-impl From<W65Instruction> for W65InstructionOrLabel {
-    fn from(insn: W65Instruction) -> Self {
-        Self::Insn(insn)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TempSymbol(
-    String,
-    Option<&'static str>,
-    Option<usize>,
-    SymbolType,
-    SymbolKind,
-);
-
-#[allow(dead_code)]
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-enum RegisterStatus {
-    Free,
-    ToClobber,
-    MustSave,
-    InUse,
-    Saved {
-        loc: W65ValLocation,
-        next: Box<Self>,
-    },
-}
-
-pub struct W65CallConv {
-    tys: Rc<TypeInformation>,
-}
-
-#[allow(dead_code)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum TypeClass {
-    Integer,
-    Memory,
-    Zero,
-}
-
-#[allow(clippy::missing_panics_doc)] // TODO: remove todo!()
-#[must_use]
-pub fn classify_type(ty: &Type) -> Option<TypeClass> {
-    match ty {
-        Type::Scalar(ScalarType {
-            header:
-                ScalarTypeHeader {
-                    vectorsize: XLangSome(1..=65535),
-                    ..
-                },
-            ..
-        }) => Some(TypeClass::Memory),
-        Type::Scalar(ScalarType {
-            kind: ScalarTypeKind::Float { .. },
-            ..
-        }) => Some(TypeClass::Integer),
-        Type::Scalar(_) | Type::Pointer(_) => Some(TypeClass::Integer),
-        Type::Void | Type::FnType(_) | Type::Null => None,
-        Type::Array(ty) => classify_type(&ty.ty),
-        Type::TaggedType(_, ty) => classify_type(ty),
-        Type::Product(tys) => {
-            let mut infected = TypeClass::Zero;
-            for ty in tys {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Aligned(_, _) => todo!(),
-        Type::Aggregate(AggregateDefinition { fields, .. }) => {
-            let mut infected = TypeClass::Zero;
-            for ty in fields.iter().map(|field| &field.ty) {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Named(path) => todo!("named type {:?}", path),
-    }
-}
-
-impl CallingConvention for W65CallConv {
-    type Loc = W65ValLocation;
-
-    fn pass_return_place(&self, ty: &xlang_struct::Type) -> Option<Self::Loc> {
-        match (classify_type(ty)?, self.tys.type_size(ty)?) {
-            (TypeClass::Memory, _) => todo!("memory"),
-            (_, 0..=8) => None,
-            _ => todo!("Oversized values"),
-        }
-    }
-
-    fn find_param(
-        &self,
-        fnty: &xlang_struct::FnType,
-        real: &xlang_struct::FnType,
-        param: u32,
-        infn: bool,
-    ) -> Self::Loc {
-        let mut ismallregs: &[W65Register] = &[W65Register::X, W65Register::Y];
-        let mut iregs: &[u32] = &[1, 2, 3, 4, 5, 6];
-
-        let mut last_loc = W65ValLocation::Unassigned(0);
-
-        let param = param as usize;
-
-        if param > real.params.len() && real.variadic {
-            todo!("varargs are passed on the stack")
-        }
-
-        for (i, ty) in fnty.params.iter().enumerate() {
-            match (classify_type(ty).unwrap(), self.tys.type_size(ty).unwrap()) {
-                (TypeClass::Memory, _) => todo!("memory"),
-                (TypeClass::Zero, _) => last_loc = W65ValLocation::Null,
-                (TypeClass::Integer, size @ (1 | 2)) => {
-                    if ismallregs.is_empty() {
-                        if let Some((first, rest)) = iregs.split_first() {
-                            iregs = rest;
-                            last_loc = W65ValLocation::SyntheticRegister { size, base: *first }
-                        } else {
-                            todo!("stack")
-                        }
-                    } else {
-                        let reg = ismallregs[0];
-                        ismallregs = &ismallregs[1..];
-                        last_loc = W65ValLocation::Register {
-                            size: size as u16,
-                            reg,
-                        }
-                    }
-                }
-                (TypeClass::Integer, size @ 3..=4) => {
-                    if let Some((first, rest)) = iregs.split_first() {
-                        iregs = rest;
-                        last_loc = W65ValLocation::SyntheticRegister { size, base: *first }
-                    } else {
-                        todo!("stack")
-                    }
-                }
-                (TypeClass::Integer, size @ 5..=16) => {
-                    let nregs = ((size as usize) & !3) >> 2;
-
-                    if iregs.len() < nregs {
-                        todo!("stack")
-                    }
-
-                    let (l, r) = iregs.split_at(nregs);
-
-                    iregs = r;
+pub struct W65Assignments {}
 
-                    last_loc = W65ValLocation::SyntheticRegister { size, base: l[0] }
-                }
-                _ => todo!("oversized values"),
-            }
-        }
+pub struct W65Clobbers {}
 
-        last_loc
-    }
-
-    fn find_return_val(&self, fnty: &xlang_struct::FnType) -> Self::Loc {
-        match (
-            classify_type(&fnty.ret).unwrap(),
-            self.tys.type_size(&fnty.ret),
-        ) {
-            (TypeClass::Memory, _) => todo!("memory"),
-            (TypeClass::Zero, _) => W65ValLocation::Null,
-            (TypeClass::Integer, Some(size @ (1 | 2))) => W65ValLocation::Register {
-                size: size as u16,
-                reg: W65Register::A,
-            },
-            (TypeClass::Integer, Some(size @ (3..=8))) => {
-                W65ValLocation::SyntheticRegister { size, base: 0 }
-            }
-            _ => todo!("oversized values"),
-        }
-    }
-}
-
-impl W65CallConv {
-    pub fn return_mode(&self, fnty: &xlang_struct::FnType) -> W65Mode {
-        let mut mode = W65Mode::NONE;
-
-        match (classify_type(&fnty.ret), self.tys.type_size(&fnty.ret)) {
-            (Some(TypeClass::Integer), Some(1)) => mode |= W65Mode::M,
-            _ => {}
-        }
-
-        mode
-    }
-
-    pub fn call_mode(&self, fnty: &xlang_struct::FnType) -> W65Mode {
-        let mut mode = W65Mode::M;
-        let mut hassize2 = false;
-        let mut nsize12vals = 0;
-
-        for param in &fnty.params {
-            match (classify_type(param), self.tys.type_size(param)) {
-                (Some(TypeClass::Integer), Some(1)) if nsize12vals != 2 => {
-                    nsize12vals += 1;
-                }
-                (Some(TypeClass::Integer), Some(1)) if nsize12vals != 2 => {
-                    nsize12vals += 1;
-                }
-                _ if nsize12vals == 2 => break,
-                _ => continue,
-            }
-        }
-
-        if !hassize2 && nsize12vals != 0 {
-            mode | W65Mode::X;
-        }
-
-        mode
-    }
-}
-
-pub struct W65MachineFeatures {
-    properties: &'static TargetProperties<'static>,
-}
-
-impl MachineFeatures for W65MachineFeatures {
-    type Loc = W65ValLocation;
-
-    type CallConv = W65CallConv;
-
-    fn native_int_size(&self) -> u16 {
-        todo!()
-    }
+pub struct W65Machine {}
 
-    fn native_float_size(&self) -> Option<u16> {
-        todo!()
+impl Machine for W65Machine {
+    fn matches_target(&self, targ: StringView) -> bool {
+        Target::parse(&targ).arch() == Architecture::Wc65c816
     }
 
-    fn lockfree_use_libatomic(&self, size: u64) -> bool {
-        todo!()
-    }
+    fn init_from_target(&mut self, _: &TargetProperties) {}
 
-    fn lockfree_cmpxchg_use_libatomic(&self, size: u64) -> bool {
-        todo!()
-    }
+    type Assignments = W65Assignments;
 
-    fn has_wait_free_compound(&self, op: BinaryOp, size: u64) -> bool {
-        todo!()
-    }
+    type BlockClobbers = W65Clobbers;
 
-    fn has_wait_free_compound_fetch(&self, op: BinaryOp, size: u64) -> bool {
-        todo!()
+    fn new_assignments(&self) -> Self::Assignments {
+        W65Assignments {}
     }
 
-    fn mangle(&self, path: &[PathComponent]) -> String {
-        todo!()
-    }
-}
-
-pub struct W65MCWriter {}
-
-impl MCWriter for W65MCWriter {
-    fn get_features(
-        &self,
-        properties: &'static TargetProperties<'static>,
-        features: Span<StringView>,
-    ) -> Self::Features {
-        W65MachineFeatures { properties }
-    }
-
-    type Features = W65MachineFeatures;
-
-    type Clobbers = ();
-
-    fn resolve_locations(
+    fn assign_locations(
         &self,
-        insns: &mut [xlang_backend::mc::MCInsn<<Self::Features as MachineFeatures>::Loc>],
-        callconv: &<Self::Features as MachineFeatures>::CallConv,
-    ) -> Self::Clobbers {
+        assignments: &mut Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        incoming: &[xlang_backend::ssa::OpaqueLocation],
+        which: u32,
+    ) -> Self::BlockClobbers {
         todo!()
     }
 
-    fn write_machine_code<I: InsnWrite, F: FnMut(String, u64)>(
+    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
         &self,
-        insns: &[xlang_backend::mc::MCInsn<<Self::Features as MachineFeatures>::Loc>],
-        clobbers: Self::Clobbers,
-        tys: Rc<TypeInformation>,
-        out: &mut I,
-        sym_accepter: F,
+        assignments: &Self::Assignments,
+        out: &mut W,
     ) -> std::io::Result<()> {
         todo!()
     }
 
-    fn get_call_conv(
+    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
         &self,
-        realty: &FnType,
-        targ: &'static TargetProperties<'static>,
-        features: Span<StringView>,
-        ty_info: Rc<TypeInformation>,
-    ) -> <Self::Features as MachineFeatures>::CallConv {
+        assignments: &Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        block_clobbers: Self::BlockClobbers,
+        out: &mut W,
+        label_sym: F,
+        which: u32,
+    ) -> std::io::Result<()> {
         todo!()
     }
-
-    fn target_matches(&self, name: &str) -> bool {
-        Target::parse(name).arch() == Architecture::Wc65c816
-    }
 }
 
 xlang::host::rustcall! {
 #[no_mangle]
+#[allow(improper_ctypes_definitions)]
 pub extern "rustcall" fn xlang_backend_main() -> DynBox<dyn XLangCodegen> {
-    DynBox::unsize_box(xlang::abi::boxed::Box::new(MCBackend::new(W65MCWriter{})))
+    DynBox::unsize_box(xlang::abi::boxed::Box::new(SsaCodegenPlugin::new(W65Machine{})))
 }}
 
 xlang::plugin_abi_version!("0.1");
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index cc216189..a9bd4269 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -1,15 +1,87 @@
-#![deny(warnings, clippy::all, clippy::pedantic, clippy::nursery)]
-
-pub mod mc;
-
+use arch_ops::x86::{X86Mode, X86Register};
+use target_tuples::{Architecture, Target};
 use xlang::{
-    plugin::XLangCodegen,
-    prelude::v1::{Box, DynBox},
+    abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
+    targets::properties::TargetProperties,
 };
+use xlang_backend::{mach::Machine, SsaCodegenPlugin};
+
+pub struct LocationAssignment {}
+
+pub struct X86Machine {
+    mode: Option<X86Mode>,
+}
+
+pub struct X86Assignments {
+    mode: X86Mode,
+    sp: X86Register,
+    available_int_registers: Vec<X86Register>,
+    stack_width: u32,
+    assigns: HashMap<u32, LocationAssignment>,
+}
+
+pub struct X86Clobbers {}
+
+impl Machine for X86Machine {
+    fn matches_target(&self, targ: StringView) -> bool {
+        let arch = Target::parse(&targ).arch();
+        arch.is_x86() || arch == Architecture::X86_64
+    }
+
+    fn init_from_target(&mut self, properties: &TargetProperties) {
+        let mode = match properties.arch.width {
+            16 => X86Mode::Real,
+            32 => X86Mode::Protected,
+            64 => X86Mode::Long,
+            _ => panic!("Not an x86 target"),
+        };
+        self.mode = Some(mode);
+    }
+
+    type Assignments = X86Assignments;
+
+    type BlockClobbers = X86Clobbers;
+
+    fn new_assignments(&self) -> Self::Assignments {
+        todo!()
+    }
+
+    fn assign_locations(
+        &self,
+        assignments: &mut Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        incoming: &[xlang_backend::ssa::OpaqueLocation],
+        which: u32,
+    ) -> Self::BlockClobbers {
+        todo!()
+    }
+
+    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
+        &self,
+        assignments: &Self::Assignments,
+        insns: &[xlang_backend::ssa::SsaInstruction],
+        block_clobbers: Self::BlockClobbers,
+        out: &mut W,
+        label_sym: F,
+        which: u32,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+
+    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
+        &self,
+        assignments: &Self::Assignments,
+        out: &mut W,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+}
 
 xlang::host::rustcall! {
 #[no_mangle]
 #[allow(improper_ctypes_definitions)]
 pub extern "rustcall" fn xlang_backend_main() -> DynBox<dyn XLangCodegen> {
-    DynBox::unsize_box(Box::new(xlang_backend::mc::MCBackend::new(mc::new_writer())))
+    DynBox::unsize_box(xlang::abi::boxed::Box::new(SsaCodegenPlugin::new(X86Machine{mode: None})))
 }}
+
+xlang::plugin_abi_version!("0.1");
diff --git a/lc-binutils b/lc-binutils
index 23371857..d97de389 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 23371857b11f909a19af38a1a4873290b546a9d8
+Subproject commit d97de389bd9a941c222320229bbe41f41294230b
diff --git a/lccc/src/main.rs b/lccc/src/main.rs
index d6eb0e74..1dea9441 100644
--- a/lccc/src/main.rs
+++ b/lccc/src/main.rs
@@ -467,6 +467,7 @@ fn main() {
 
     if mode > Mode::Xir {
         for codegen_path in &codegen_paths {
+            println!("Opening codegen plugin: {}", codegen_path.display());
             codegen_handles
                 .push(Handle::open(codegen_path).expect("couldn't load frontend library"));
         }
diff --git a/lccc/src/session.rs b/lccc/src/session.rs
index 972eeb75..86a647c1 100644
--- a/lccc/src/session.rs
+++ b/lccc/src/session.rs
@@ -1,13 +1,15 @@
 use core::cell::RefCell;
 use std::path::PathBuf;
 
-use xlang::abi::io::Read;
+use xlang::abi::io::{Read, Write};
 use xlang::abi::prelude::v1::*;
 use xlang::abi::string::StringView;
 use xlang::plugin::{XLangCodegen, XLangFrontend, XLangPlugin};
 use xlang::targets::properties::{MachineProperties, TargetProperties};
 use xlang_host::dso::Handle;
 
+use crate::Mode;
+
 use super::{DebugLevel, OptimizeLevel};
 
 pub struct MsvcSysroot {
@@ -63,6 +65,9 @@ pub struct CompileSession<'a> {
     driver: &'a DriverSession<'a>,
     frontend: DynBox<dyn XLangFrontend>,
     backend: Option<DynBox<dyn XLangCodegen>>,
+    middle_plugins: Vec<DynBox<dyn XLangPlugin>>,
     file: PathBuf,
-    output_file: Box<dyn Read>,
+    output_file: Box<dyn Write + 'a>,
 }
+
+impl<'a> CompileSession<'a> {}
diff --git a/xlang/xlang_abi/src/vec.rs b/xlang/xlang_abi/src/vec.rs
index f2075c10..6ba70f29 100644
--- a/xlang/xlang_abi/src/vec.rs
+++ b/xlang/xlang_abi/src/vec.rs
@@ -6,6 +6,7 @@ use std::{
     marker::PhantomData,
     mem::{size_of, ManuallyDrop},
     ops::{Deref, DerefMut},
+    ptr::NonNull,
 };
 
 use crate::{
@@ -394,6 +395,32 @@ impl<T, A: Allocator> Vec<T, A> {
         new
     }
 
+    /// Returns an iterator that moves out of the back `n` elements of `self`.
+    ///
+    /// The iterator takes ownership of the values immediately - if dropped, the unconsumed values are dropped, and if forgetten the unconsumed values will also be forgotten.
+    /// `self` remains borrowed for the lifetime of the iterator to avoid an extra allocation.
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `n` is greater than `len()`
+    ///
+    pub fn drain_back(&mut self, n: usize) -> DrainBack<T> {
+        if n > self.len {
+            panic!(
+                "Index {} is out of range for a vector of length {}",
+                n, self.len
+            )
+        }
+        self.len -= n;
+        let base = unsafe { self.ptr.as_ptr().add(self.len) };
+
+        DrainBack {
+            ptr: unsafe { NonNull::new_unchecked(base) },
+            remaining: n,
+            _phantom: PhantomData,
+        }
+    }
+
     ///
     /// Resizes the vector, shrinking it to `nlen`, dropping any excees elements
     ///
@@ -744,6 +771,56 @@ impl<T, A: Allocator + Default> From<std::vec::Vec<T>> for Vec<T, A> {
     }
 }
 
+/// An iterator that takes ownership of elements at the end of a [`Vec`]
+pub struct DrainBack<'a, T> {
+    ptr: core::ptr::NonNull<T>,
+    remaining: usize,
+    _phantom: PhantomData<&'a mut [T]>,
+}
+
+impl<'a, T> Iterator for DrainBack<'a, T> {
+    type Item = T;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.remaining == 0 {
+            None
+        } else {
+            let val = unsafe { core::ptr::read(self.ptr.as_ptr()) };
+            self.remaining -= 1;
+            self.ptr = unsafe { NonNull::new_unchecked(self.ptr.as_ptr().add(1)) };
+
+            Some(val)
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
+    }
+}
+
+impl<'a, T> Drop for DrainBack<'a, T> {
+    fn drop(&mut self) {
+        if core::mem::needs_drop::<T>() {
+            for i in 0..self.remaining {
+                unsafe { core::ptr::drop_in_place(self.ptr.as_ptr().add(i)) }
+            }
+        }
+    }
+}
+
+impl<'a, T> ExactSizeIterator for DrainBack<'a, T> {}
+impl<'a, T> FusedIterator for DrainBack<'a, T> {}
+impl<'a, T> DoubleEndedIterator for DrainBack<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.remaining == 0 {
+            None
+        } else {
+            self.remaining -= 1;
+            let val = unsafe { core::ptr::read(self.ptr.as_ptr().add(self.remaining)) };
+            Some(val)
+        }
+    }
+}
+
 /// An iterator over the values of a [`Vec`]
 pub struct IntoIter<T, A: Allocator> {
     ptr: Unique<T>,
diff --git a/xlang/xlang_backend/src/expr.rs b/xlang/xlang_backend/src/expr.rs
index dacf46a0..9a832d8a 100644
--- a/xlang/xlang_backend/src/expr.rs
+++ b/xlang/xlang_backend/src/expr.rs
@@ -1,6 +1,6 @@
 use xlang::{
+    abi::{collection::HashMap, option::None as XLangNone, pair::Pair},
     ir::{ArrayType, Path, PointerType, ScalarType, ScalarTypeHeader, ScalarTypeKind, Type, Value},
-    prelude::v1::*,
 };
 
 use core::{fmt::Debug, hash::Hash};
@@ -12,9 +12,6 @@ use crate::str::Encoding;
 pub trait ValLocation: Eq + Debug + Clone {
     /// Checks if this location is addressable (is not a register)
     fn addressible(&self) -> bool;
-
-    /// Gets an unassigned location, used by [`super::FunctionCodegen`] to keep track of values before asking the raw codegen to assign locations.
-    fn unassigned(n: usize) -> Self;
 }
 
 /// The pointee of a pointer
@@ -22,8 +19,6 @@ pub trait ValLocation: Eq + Debug + Clone {
 pub enum LValue<Loc: ValLocation> {
     /// An LValue from an Opaque pointer stored in `Loc`
     OpaquePointer(Loc),
-    /// A pointer to a temporary value (`as_temporary`)
-    Temporary(Box<VStackValue<Loc>>),
     /// A pointer to a local variable
     Local(u32),
     /// A pointer to a global static/function
@@ -32,11 +27,9 @@ pub enum LValue<Loc: ValLocation> {
     Label(u32),
     /// Aggregate Element Field
     Field(Type, Box<LValue<Loc>>, String),
-    /// A pointer to a string literal
-    StringLiteral(Encoding, Vec<u8>),
 
     /// Offset (in bytes) to some other lvalue
-    Offset(Box<LValue<Loc>>, u64),
+    Offset(Box<LValue<Loc>>, i64),
 
     /// A Null pointer
     Null,
@@ -49,51 +42,12 @@ impl<Loc: ValLocation> core::fmt::Display for LValue<Loc> {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             LValue::OpaquePointer(loc) => f.write_fmt(format_args!("opaque({:?})", loc)),
-            LValue::Temporary(val) => f.write_fmt(format_args!("temporary({})", val)),
             LValue::Local(n) => f.write_fmt(format_args!("_{}", n)),
             LValue::GlobalAddress(path) => f.write_fmt(format_args!("global_addr({})", path)),
             LValue::Label(n) => f.write_fmt(format_args!("&&@{}", n)),
             LValue::Field(ty, lval, name) => {
                 f.write_fmt(format_args!("{}.({})::{}", lval, ty, name))
             }
-            LValue::StringLiteral(enc, bytes) => {
-                core::fmt::Display::fmt(enc, f)?;
-                f.write_str(" ")?;
-                match core::str::from_utf8(bytes) {
-                    Ok(s) => f.write_fmt(format_args!(" \"{}\"", s.escape_default())),
-                    Err(mut e) => {
-                        let mut bytes = &bytes[..];
-                        f.write_str(" \"")?;
-                        while !bytes.is_empty() {
-                            let (l, r) = bytes.split_at(e.valid_up_to());
-                            core::fmt::Display::fmt(
-                                &core::str::from_utf8(l).unwrap().escape_default(),
-                                f,
-                            )?;
-                            if let core::option::Option::Some(len) = e.error_len() {
-                                let (ebytes, rest) = r.split_at(len);
-                                bytes = rest;
-                                for b in ebytes {
-                                    f.write_fmt(format_args!("\\x{:02x}", b))?;
-                                }
-                            } else {
-                                let ebytes = core::mem::take(&mut bytes);
-                                for b in ebytes {
-                                    f.write_fmt(format_args!("\\x{:02x}", b))?;
-                                }
-                            }
-                            match core::str::from_utf8(bytes) {
-                                Ok(s) => {
-                                    core::fmt::Display::fmt(&s.escape_default(), f)?;
-                                    break;
-                                }
-                                Err(next_err) => e = next_err,
-                            }
-                        }
-                        f.write_str("\"")
-                    }
-                }
-            }
             LValue::Offset(loc, off) => f.write_fmt(format_args!("{}+{}", loc, off)),
             LValue::Null => f.write_str("null"),
             LValue::TransparentAddr(addr) => f.write_fmt(format_args!("{:#x}", addr)),
@@ -180,10 +134,47 @@ impl<Loc: ValLocation> VStackValue<Loc> {
         }
     }
 
+    /// Creates an opaque value corresponding to the specified [`Type`]
+    pub fn opaque_value(ty: Type, loc: Loc) -> Self {
+        match ty {
+            Type::Void | Type::FnType(_) | Type::Null => {
+                panic!("opaque_value requires a complete value type")
+            }
+            Type::Scalar(sty) => Self::OpaqueScalar(sty, loc),
+            Type::Aligned(_, ty) | Type::TaggedType(_, ty) => {
+                Self::opaque_value(xlang::abi::boxed::Box::into_inner(ty), loc)
+            }
+            Type::Pointer(pty) => Self::Pointer(pty, LValue::OpaquePointer(loc)),
+            ty => VStackValue::OpaqueAggregate(ty, loc),
+        }
+    }
+
+    /// Creates an opaque [`VStackValue::LValue`] of the specified [`Type`]
+    pub fn opaque_lvalue(ty: Type, loc: Loc) -> Self {
+        Self::LValue(ty, LValue::OpaquePointer(loc))
+    }
+
     /// Obtains the type of the value
     pub fn value_type(&self) -> Type {
         match self {
-            VStackValue::Constant(_) => todo!(),
+            VStackValue::Constant(val) => match val {
+                Value::Invalid(ty) | Value::Uninitialized(ty) => ty.clone(),
+                Value::GenericParameter(_) => panic!("Cannot handle generic params this late"),
+                Value::Integer { ty, val } => Type::Scalar(*ty),
+                Value::GlobalAddress { ty, item } => {
+                    let mut pty = PointerType::default();
+                    *pty.inner = ty.clone();
+                    Type::Pointer(pty)
+                }
+                Value::ByteString { .. } => todo!("what type is byte string constant again?"),
+                Value::String { ty, .. } => ty.clone(),
+                Value::LabelAddress(_) => {
+                    let mut pty = PointerType::default();
+                    *pty.inner = Type::Void;
+                    Type::Pointer(pty)
+                }
+                Value::Empty => Type::Null,
+            },
             VStackValue::LValue(ty, _) => ty.clone(),
             VStackValue::Pointer(ptrty, _) => Type::Pointer(ptrty.clone()),
             VStackValue::OpaqueScalar(scalar, _) => Type::Scalar(*scalar),
@@ -196,15 +187,17 @@ impl<Loc: ValLocation> VStackValue<Loc> {
                 },
                 kind: ScalarTypeKind::Integer {
                     signed: false,
-                    min: None,
-                    max: None,
+                    min: XLangNone,
+                    max: XLangNone,
                 },
             }),
-            VStackValue::Trapped => Type::Void,
-            VStackValue::ArrayRepeat(val, len) => Type::Array(Box::new(ArrayType {
-                ty: val.value_type(),
-                len: len.clone(),
-            })),
+            VStackValue::Trapped => Type::Null,
+            VStackValue::ArrayRepeat(val, len) => {
+                Type::Array(xlang::abi::boxed::Box::new(ArrayType {
+                    ty: val.value_type(),
+                    len: len.clone(),
+                }))
+            }
         }
     }
 }
@@ -222,6 +215,17 @@ pub enum Trap {
     Overflow,
 }
 
+impl core::fmt::Display for Trap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Trap::Unreachable => f.write_str("unreachable"),
+            Trap::Breakpoint => f.write_str("breakpoint"),
+            Trap::Abort => f.write_str("abort"),
+            Trap::Overflow => f.write_str("overflow"),
+        }
+    }
+}
+
 /// A ValLocation that cannot be instantiated - that is, no opaque values can be produced within this location
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum NoOpaque {}
@@ -230,10 +234,6 @@ impl ValLocation for NoOpaque {
     fn addressible(&self) -> bool {
         match *self {}
     }
-
-    fn unassigned(_: usize) -> Self {
-        panic!("Unassigned location")
-    }
 }
 
 impl VStackValue<NoOpaque> {
@@ -254,14 +254,13 @@ impl VStackValue<NoOpaque> {
             ),
             VStackValue::OpaqueAggregate(_, loc) => match loc {},
             VStackValue::CompareResult(left, right) => VStackValue::CompareResult(
-                Box::new(Box::into_inner(left).into_transparent_for()),
-                Box::new(Box::into_inner(right).into_transparent_for()),
+                Box::new((*left).into_transparent_for()),
+                Box::new((*right).into_transparent_for()),
             ),
             VStackValue::Trapped => VStackValue::Trapped,
-            VStackValue::ArrayRepeat(val, count) => VStackValue::ArrayRepeat(
-                Box::new(Box::into_inner(val).into_transparent_for()),
-                count,
-            ),
+            VStackValue::ArrayRepeat(val, count) => {
+                VStackValue::ArrayRepeat(Box::new((*val).into_transparent_for()), count)
+            }
         }
     }
 }
@@ -271,22 +270,15 @@ impl LValue<NoOpaque> {
     pub fn into_transparent_for<T: ValLocation>(self) -> LValue<T> {
         match self {
             LValue::OpaquePointer(val) => match val {},
-            LValue::Temporary(val) => {
-                LValue::Temporary(Box::new(Box::into_inner(val).into_transparent_for()))
-            }
             LValue::Local(n) => LValue::Local(n),
             LValue::GlobalAddress(path) => LValue::GlobalAddress(path),
             LValue::Label(n) => LValue::Label(n),
-            LValue::Field(ty, base, field) => LValue::Field(
-                ty,
-                Box::new(Box::into_inner(base).into_transparent_for()),
-                field,
-            ),
-            LValue::StringLiteral(enc, bytes) => LValue::StringLiteral(enc, bytes),
-            LValue::Offset(base, bytes) => LValue::Offset(
-                Box::new(Box::into_inner(base).into_transparent_for()),
-                bytes,
-            ),
+            LValue::Field(ty, base, field) => {
+                LValue::Field(ty, Box::new((*base).into_transparent_for()), field)
+            }
+            LValue::Offset(base, bytes) => {
+                LValue::Offset(Box::new((*base).into_transparent_for()), bytes)
+            }
             LValue::Null => LValue::Null,
             LValue::TransparentAddr(addr) => LValue::TransparentAddr(addr),
         }
diff --git a/xlang/xlang_backend/src/intrinsic.rs b/xlang/xlang_backend/src/intrinsic.rs
index df1c5823..8b137891 100644
--- a/xlang/xlang_backend/src/intrinsic.rs
+++ b/xlang/xlang_backend/src/intrinsic.rs
@@ -1,183 +1 @@
-use xlang::{
-    abi::option::Some as XLangSome,
-    abi::pair::Pair,
-    abi::vec::Vec,
-    ir::{FnType, PathComponent},
-    targets::properties::TargetProperties,
-};
 
-use crate::{
-    expr::{Trap, VStackValue},
-    FunctionCodegen, FunctionRawCodegen,
-};
-
-///
-/// Calls an intrinsic function defined
-///
-pub fn call_intrinsic<F: crate::FunctionRawCodegen>(
-    path: &::xlang::ir::Path,
-    codegen: &mut crate::FunctionCodegen<F>,
-    fnty: &::xlang::ir::FnType,
-    properties: &::xlang::targets::properties::TargetProperties,
-    params: &mut Vec<VStackValue<F::Loc>>,
-) -> bool {
-    if call_generic_intrinsic(path, codegen, fnty, properties, params) {
-        true
-    } else if call_nongeneric_intrinsic(path, codegen, fnty, properties, params) {
-        true
-    } else if call_target_intrinsic(path, codegen, fnty, properties, params) {
-        true
-    } else {
-        false
-    }
-}
-
-macro_rules! define_generic_xlang_intrinsics{
-    {$($($path:ident)::* :: <($($generics:pat),*)>  | $codegen:pat, $properties:pat, $ty:pat, $params:pat | => $expr:expr),* $(,)?} => {
-        fn call_generic_intrinsic<F: $crate::FunctionRawCodegen>(path: &::xlang::ir::Path, codegen: &mut $crate::FunctionCodegen<F>, fnty: &::xlang::ir::FnType,properties: &::xlang::targets::properties::TargetProperties, params: &mut Vec<VStackValue<F::Loc>>) -> bool{
-            match &*path.components{
-                [::xlang::ir::PathComponent::Root,rest @ ..]
-                    | [rest @ ..] => {
-                        match rest{
-                            [rest @ .., ::xlang::ir::PathComponent::Generics(generics)] => {
-                                $(match &[$(::core::stringify!($path)),*]{
-                                    [idents @ ..] if rest.iter().map(|comp: &::xlang::ir::PathComponent| {match comp{
-                                        ::xlang::ir::PathComponent::Text(__name) => ::std::option::Option::Some(&**__name),
-                                        _ => ::std::option::Option::None
-                                    }}).eq(idents.iter().map(|n|::std::option::Option::Some(*n)))=> return {(|$codegen: &mut $crate::FunctionCodegen<F>, $properties: &::xlang::targets::properties::TargetProperties,$ty: &::xlang::ir::FnType, generics: &[::xlang::ir::GenericParameter], $params: Vec<VStackValue<F::Loc>>| match generics{
-                                        [$($generics),*] => $expr,
-                                        _ => panic!("invalid signature")
-                                })(codegen, properties,fnty,generics, core::mem::take(params)); true},
-                                    _ => {}
-                                })*
-                            }
-                            _ => {}
-                        }
-                    }
-
-            }
-            return false
-        }
-    }
-}
-
-macro_rules! define_xlang_intrinsics{
-    {
-        $($($path:ident)::* | $codegen:pat, $properties:pat, $ty:pat, $params:pat | => $expr:expr),* $(,)?
-    } => {
-
-        #[allow(clippy::redundant_closure_call)] // needed for hygine
-        fn call_nongeneric_intrinsic<F: $crate::FunctionRawCodegen>(path: &::xlang::ir::Path, codegen: &mut $crate::FunctionCodegen<F>, fnty: &::xlang::ir::FnType,properties: &::xlang::targets::properties::TargetProperties, params: &mut Vec<VStackValue<F::Loc>>) -> bool{
-            match &*path.components{
-                [::xlang::ir::PathComponent::Root,rest @ ..]
-                    | [rest @ ..] => {
-                        $(match &[$(::core::stringify!($path)),*]{
-                            [idents @ ..] if rest.iter().map(|comp: &::xlang::ir::PathComponent| {match comp{
-                                ::xlang::ir::PathComponent::Text(__name) => ::std::option::Option::Some(&**__name),
-                                _ => ::std::option::Option::None
-                            }}).eq(idents.iter().map(|n|::std::option::Option::Some(*n)))=> return {(|$codegen: &mut $crate::FunctionCodegen<F>, $properties: &::xlang::targets::properties::TargetProperties,$ty: &::xlang::ir::FnType, $params: Vec<VStackValue<F::Loc>> | $expr)(codegen,properties,fnty, core::mem::take(params)); true},
-                            _ => {}
-                        })*
-                    }
-            }
-            return false
-        }
-    }
-}
-
-fn call_target_intrinsic<F: FunctionRawCodegen>(
-    path: &xlang::ir::Path,
-    code: &mut FunctionCodegen<F>,
-    _fnty: &FnType,
-    properties: &TargetProperties,
-    params: &mut Vec<VStackValue<F::Loc>>,
-) -> bool {
-    match &*path.components {
-        [PathComponent::Text(lccc), PathComponent::Text(intrinsics), PathComponent::Text(aname), PathComponent::Text(iname)]
-            if lccc.strip_suffix("__").unwrap_or(lccc) == "lccc"
-                && intrinsics
-                    .strip_prefix("__")
-                    .map_or(&**intrinsics, |s| s.strip_suffix("__").unwrap_or(s))
-                    == "intrinsics" =>
-        {
-            for name in properties.arch.arch_names {
-                if name == &**aname {
-                    for Pair(name, _) in properties.arch.builtins {
-                        if name == &**iname {
-                            let params = core::mem::take(params);
-                            let val = code.raw_inner().write_intrinsic(*name, params);
-                            code.push_value(val);
-                            return true;
-                        }
-                    }
-                }
-            }
-
-            return false;
-        }
-        [..] => false,
-    }
-}
-
-define_xlang_intrinsics! {
-    __lccc::intrinsics::C::__builtin_trap | codegen, _, _, _ | => {
-        codegen.raw_inner().write_trap(Trap::Abort);
-        codegen.push_value(VStackValue::Trapped);
-    },
-    __lccc::xlang::deoptimize |codegen, _, fnty,params| => {
-        let value = params.into_iter().next().unwrap();
-        let ret = &fnty.ret;
-
-
-
-        let loc = if let XLangSome(loc) = value.opaque_location(){
-            loc.clone()
-        }else{
-            let loc = codegen.raw_inner().allocate(ret,false);
-            codegen.move_val(value,loc.clone());
-            loc
-        };
-
-        let loc = codegen.raw_inner().write_deoptimize(loc);
-
-        let ret = codegen.opaque_value(ret, loc);
-        codegen.push_value(ret);
-    },
-    __lccc::xlang::likely |codegen, _, _, params| => {
-        let value = params.into_iter().next().unwrap();
-        codegen.push_value(value);
-    },
-    __lccc::xlang::unlikely |codegen, _, _, params| => {
-        let value = params.into_iter().next().unwrap();
-        codegen.push_value(value);
-    }
-}
-
-define_generic_xlang_intrinsics! {
-    __lccc::xlang::__atomic_is_always_lockfree::<(xlang::ir::GenericParameter::Type(ty))> | codegen, _, fnty, _ | => {
-        if fnty.params.len()!=0{panic!("bad signature for intrinsic __lccc::xlang::__atomic_is_always_lockfree")}
-        match &fnty.ret{
-            xlang::ir::Type::Scalar(retty @ xlang::ir::ScalarType{kind: xlang::ir::ScalarTypeKind::Integer{..},..}) => {
-
-                let val = codegen.get_type_information().atomic_is_lock_free(ty).expect("__lccc::xlang::__atomic_is_always_lockfree requires a complete value type") as u128;
-
-                let val = VStackValue::Constant(xlang::ir::Value::Integer{ty: *retty, val});
-                codegen.push_value(val);
-            }
-            _ => panic!("bad signature for intrinsic __lccc::xlang::__atomic_is_always_lockfree")
-        }
-    },
-    __lccc::xlang::__atomic_required_alignment::<(xlang::ir::GenericParameter::Type(ty))> | codegen, _, fnty, _ | => {
-        if fnty.params.len()!=0{panic!("bad signature for intrinsic __lccc::xlang::__atomic_required_alignment")}
-        match &fnty.ret{
-            xlang::ir::Type::Scalar(retty @ xlang::ir::ScalarType{kind: xlang::ir::ScalarTypeKind::Integer{..},..}) => {
-
-                let val = codegen.get_type_information().atomic_required_alignment(ty).expect("__lccc::xlang::__atomic_required_alignment requires a complete value type") as u128;
-
-                let val = VStackValue::Constant(xlang::ir::Value::Integer{ty: *retty, val});
-                codegen.push_value(val);
-            }
-            _ => panic!("bad signature for intrinsic __lccc::xlang::__atomic_required_alignment")
-        }
-    }
-}
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index f39a0888..595ef704 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -1,32 +1,26 @@
-#![deny(missing_docs, warnings)] // No clippy::nursery
+// #![deny(missing_docs, warnings)] // No clippy::nursery
 #![allow(dead_code)] // I'm not deleting a bunch of randomly placed shit
 //! A helper crate for implementing [`xlang::plugin::XLangCodegen`]s without duplicating code (also can be used to evaluate constant expressions)
 //! the `xlang_backend` crate provides a general interface for writing expressions to an output.
-use std::{
-    collections::{HashSet, VecDeque},
-    convert::TryInto,
-    fmt::Debug,
-    io::Write,
-    mem::MaybeUninit,
-    option::Option::Some as StdSome,
-    rc::Rc,
-};
 
-use self::str::Encoding;
-use callconv::CallingConvention;
-use expr::{LValue, Trap, VStackValue, ValLocation};
+use std::rc::Rc;
+
+use arch_ops::traits::InsnWrite;
+use mach::Machine;
+use ssa::FunctionBuilder;
 use ty::TypeInformation;
 use xlang::{
-    abi::string::StringView,
-    ir::{
-        AccessClass, AsmExpr, BinaryOp, Block, BranchCondition, CharFlags, Expr, FnType,
-        OverflowBehaviour, Path, PointerType, ScalarType, ScalarTypeHeader, ScalarTypeKind,
-        ScalarValidity, Type, UnaryOp, Value,
-    },
-    prelude::v1::*,
+    abi::{io::WriteAdapter, option::Some as XLangSome, pair::Pair, try_},
+    ir::{self, Linkage},
+    plugin::{XLangCodegen, XLangPlugin},
     targets::properties::TargetProperties,
 };
 
+use binfmt::{
+    fmt::{Section, SectionFlag},
+    sym::{Symbol, SymbolKind, SymbolType},
+};
+
 /// Module for handling and internalizing string literal values
 pub mod str;
 
@@ -45,1757 +39,261 @@ pub mod callconv;
 /// Module for name mangling
 pub mod mangle;
 
-/// Module for generic Machine Code
-pub mod mc;
+/// Module for Machine Support
+pub mod mach;
 
 /// Module for building SSA from XIR that can be readily lowered to machine code
 /// Does not use FunctionCodegen
 pub mod ssa;
 
-///
-/// Basic Trait for creating the code generator
-pub trait FunctionRawCodegen {
-    /// The type for Locations
-    type Loc: ValLocation;
-
-    /// The type of calling conventions used by this backend
-    type CallConv: CallingConvention<Loc = Self::Loc> + ?Sized;
-
-    /// Handles the `__lccc::xlang::deoptimize` intrinsic. Implemented as a no-op by default.
-    /// Implementations that generate IR that is run through a separate optimizer should override the default impl
-    fn write_deoptimize(&mut self, val: Self::Loc) -> Self::Loc {
-        val
-    }
-
-    /// Writes an instruction corresponding to the given [`Trap`]
-    fn write_trap(&mut self, trap: Trap);
-
-    /// Writes a full thread fence for the given AccessClass
-    fn write_barrier(&mut self, acc: AccessClass);
-
-    /// Performs a binary operatation on a val location and a constant
-    fn write_int_binary_imm(
-        &mut self,
-        dest: Self::Loc,
-        a: Self::Loc,
-        b: u128,
-        ty: &Type,
-        op: BinaryOp,
-    );
-
-    /// Performs a binary operatation on two val locations
-    fn write_int_binary(
-        &mut self,
-        dest: Self::Loc,
-        src1: Self::Loc,
-        src2: Self::Loc,
-        ty: &Type,
-        op: BinaryOp,
-    );
-
-    /// Performs a unary operation on  a val location
-    fn write_unary(&mut self, val: Self::Loc, ty: &Type, op: UnaryOp);
-
-    /// Moves a value between two [`ValLocation`]s
-    fn move_val(&mut self, src: Self::Loc, dest: Self::Loc);
-
-    /// Stores an immediate value into the given location
-    fn move_imm(&mut self, src: u128, dest: Self::Loc, ty: &Type);
-
-    /// Stores an immediate value into the pointer in `ptr`
-    fn store_indirect_imm(&mut self, src: Value, ptr: Self::Loc);
-
-    /// Loads a value into the pointer in the given value location
-    fn load_val(&mut self, lvalue: Self::Loc, loc: Self::Loc);
-
-    /// Stores a value into the given value location
-    fn store_indirect(&mut self, lvalue: Self::Loc, loc: Self::Loc, ty: &Type);
-
-    /// Obtains the calling convention for the current function
-    fn get_callconv(&self) -> &Self::CallConv;
-
-    /// The maximum integer size (in bits) supported natively (without emulation)
-    fn native_int_size(&self) -> u16;
-    /// The maximum floating point size (in bits) supported natively, or None if no floating-point support exists
-    fn native_float_size(&self) -> Option<u16>;
-
-    /// The maximum Vector size supported natively, in bytes
-    fn native_vec_size(&self) -> Option<u64> {
-        None
-    }
-
-    /// Preferred Vector size of the current codegen, in total bytes
-    /// This need not be the same as the [`FunctionRawCodegen::native_vec_size`], for example, if some vector types incur a significant runtime performance penalty
-    /// (such as AVX-512)
-    fn preferred_vec_size(&self) -> Option<u64> {
-        None
-    }
-
-    /// Writes a call to a target intrinsic (such as `x86::_mm_addp_i8`)
-    fn write_intrinsic(
-        &mut self,
-        name: StringView,
-        params: Vec<VStackValue<Self::Loc>>,
-    ) -> VStackValue<Self::Loc>;
-
-    /// Writes a new target at the current location
-    fn write_target(&mut self, target: u32);
-    /// Performs a direct call to a named function
-    fn call_direct(&mut self, path: &Path, realty: &FnType);
-    /// Performs an indirect call to the pointer stored in `value`
-    fn call_indirect(&mut self, value: Self::Loc);
-    /// Performs a direct call to the given address
-    fn call_absolute(&mut self, addr: u128, realty: &FnType);
-
-    /// Performs a guaranteed tail call to the target
-    /// Note: The signature is assumed to be compatible with the current function
-    fn tailcall_direct(&mut self, value: &Path, realty: &FnType);
-
-    /// Performs a guaranteed tail call to the target
-    /// Note: The signature is assumed to be compatible with the current function
-    fn tailcall_indirect(&mut self, value: Self::Loc, realty: &FnType);
-
-    /// Performs the exit sequence of a function
-    fn leave_function(&mut self);
-
-    /// Performs a conditional branch to `target` based on `condition` and `val`
-    fn branch(&mut self, target: u32, condition: BranchCondition, val: Self::Loc);
-    /// Performs a conditional branch based on comparing `v1` and `v2` according to `condition`
-    /// This is used for the sequence `cmp; branch <condition> @<target>`
-    fn branch_compare(
-        &mut self,
-        target: u32,
-        condition: BranchCondition,
-        v1: VStackValue<Self::Loc>,
-        v2: VStackValue<Self::Loc>,
-    );
-    /// Branches to the `target` unconditionally (IE. when the condition is always, or based on constant-folded values)
-    fn branch_unconditional(&mut self, target: u32);
-
-    /// Branches to the target given in `target`
-    fn branch_indirect(&mut self, target: Self::Loc);
-
-    /// Computes the address of a global, and moves the pointer into `Self::Loc`
-    fn compute_global_address(&mut self, path: &Path, loc: Self::Loc);
-
-    /// Computes the address of a label, and moves the pointer into `Self::Loc`
-    fn compute_label_address(&mut self, target: u32, loc: Self::Loc);
-
-    /// Computes the address of a parameter and moves the pointer into `Self::Loc`
-    fn compute_parameter_address(&mut self, param: u32, loc: Self::Loc);
-
-    /// Computes the address of a local variable in `inloc` (used only if addressable), and moves the pointer into `Self::Loc`
-    fn compute_local_address(&mut self, inloc: Self::Loc, loc: Self::Loc);
-
-    /// Computes the address of a string literal
-    fn compute_string_address(&mut self, enc: Encoding, bytes: Vec<u8>, loc: Self::Loc);
-
-    /// Marks the given location as freed and allows other allocations to use the location without clobbering it
-    fn free(&mut self, loc: Self::Loc);
-
-    /// Clobbers the given location, saving the value and then freeing it.
-    fn clobber(&mut self, loc: Self::Loc);
-
-    /// Allocates space to store a local variable or stack value of type `Type`
-    fn allocate(&mut self, ty: &Type, needs_addr: bool) -> Self::Loc;
-
-    /// Allocates space to store an lvalue
-    fn allocate_lvalue(&mut self, needs_addr: bool) -> Self::Loc;
-
-    /// Prepares the stack frame (as necessary) for a call to a function with the given `callty` and `realty`
-    fn prepare_call_frame(&mut self, callty: &FnType, realty: &FnType);
-
-    /// Whether or not lock-free atomic ops of some size should issue a call to libatomic for this backend.
-    fn lockfree_use_libatomic(&mut self, size: u64) -> bool;
-
-    /// Whether or not lock-free atomic rmws use libatomic
-    fn lockfree_cmpxchg_use_libatomic(&mut self, size: u64) -> bool;
-
-    /// Whether or not BinaryOp can be implemented directly by the CPU
-    fn has_wait_free_compound(&mut self, op: BinaryOp, size: u64) -> bool;
-
-    /// Whether or not the fecth version of BinaryOp can be implemented directly by the CPU
-    fn has_wait_free_compound_fetch(&mut self, op: BinaryOp, size: u64) -> bool;
-
-    /// Writes a Compare Exchange Instruction, according to the atomic Access class in `ord`
-    /// Padding bytes in `ctrl` and `val` are zeroed prior to the call to this funtion
-    /// dest and ctrl both contain pointers to the destination and the compare
-    fn compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: AccessClass,
-    );
-
-    /// Writes a Weak Compare Exchange Instruction, according to the atomic Access class in `ord`
-    /// Padding bytes in `ctrl` and `val` are zeroed prior to the call to this funtion
-    /// dest and ctrl both contain pointers to the destination and the compare
-    fn weak_compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: AccessClass,
-    );
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum SectionSpec {
+    Global,
+}
 
-    /// Generates a sequence (compiler) fence - synchronizing with signal handlers on the current thread of execution
-    /// This is generally a runtime no-op
-    fn sequence(&mut self, _: AccessClass) {
-        /* by default, do nothing. This is for something like xlangcodegen-llvm that drops down to a lower-level IR */
+impl core::fmt::Display for SectionSpec {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        match self {
+            Self::Global => Ok(()),
+        }
     }
-
-    /// Writes an assembly expression
-    fn write_asm(&mut self, asm: &AsmExpr, inputs: Vec<VStackValue<Self::Loc>>) -> Vec<Self::Loc>;
-
-    /// Converts between two scalar types
-    fn write_scalar_convert(
-        &mut self,
-        target_ty: ScalarType,
-        incoming_ty: ScalarType,
-        new_loc: Self::Loc,
-        old_loc: Self::Loc,
-    );
 }
 
-#[derive(Default, Debug)]
-struct BranchToInfo {
-    fallthrough_from: u32,
-    branch_from: HashSet<u32>,
+pub struct FunctionDef<M> {
+    section: SectionSpec,
+    linkage: Linkage,
+    fnty: Rc<ir::FnType>,
+    body: Option<FunctionBuilder<M>>,
 }
-/// A type for handling the generation of code for functions.
-pub struct FunctionCodegen<F: FunctionRawCodegen> {
-    inner: F,
-    vstack: VecDeque<VStackValue<F::Loc>>,
-    properties: &'static TargetProperties<'static>,
-    targets: HashMap<u32, Vec<VStackValue<F::Loc>>>,
-    diverged: bool,
-    locals: Vec<(VStackValue<F::Loc>, Type)>,
-    fnty: FnType,
-    locals_opaque: bool,
-    tys: Rc<TypeInformation>,
-    ctarg: u32,
-    cfg: HashMap<u32, BranchToInfo>,
+
+pub struct SsaCodegenPlugin<M> {
+    mach: Rc<M>,
+    targ: Option<&'static TargetProperties<'static>>,
+    functions: Vec<(String, FunctionDef<M>)>,
 }
 
-impl<F: FunctionRawCodegen> FunctionCodegen<F> {
-    /// Constructs a new [`FunctionCodegen`] with a given [`FunctionRawCodegen`], the given function name and signature, and the target properties
-    pub fn new(
-        inner: F,
-        _path: Path,
-        fnty: FnType,
-        properties: &'static TargetProperties,
-        tys: Rc<TypeInformation>,
-    ) -> Self {
+impl<M> SsaCodegenPlugin<M> {
+    pub fn new(mach: M) -> Self {
         Self {
-            inner,
-            properties,
-            vstack: VecDeque::new(),
-            targets: HashMap::new(),
-            diverged: false,
-            locals: Vec::new(),
-            fnty,
-            locals_opaque: false,
-            tys,
-            ctarg: !0,
-            cfg: HashMap::new(),
-        }
-    }
-
-    fn get_type_information(&self) -> &TypeInformation {
-        &self.tys
-    }
-
-    fn print_vstack(&self) {
-        let mut iter = self.vstack.iter();
-        let stdout = std::io::stdout();
-        let mut stdout = stdout.lock();
-        core::write!(stdout, "[").unwrap();
-        if let StdSome(val) = iter.next() {
-            core::write!(stdout, "{}", val).unwrap();
-        }
-
-        for val in iter {
-            core::write!(stdout, ", {}", val).unwrap();
-        }
-
-        core::writeln!(stdout, "]").unwrap();
-    }
-
-    /// Obtains the target properties.
-    /// Convience Method for some code generators
-    pub fn properties(&self) -> &'static TargetProperties {
-        self.properties
-    }
-
-    /// Obtains a mutable reference to the inner `F`
-    pub fn raw_inner(&mut self) -> &mut F {
-        &mut self.inner
-    }
-
-    /// Obtains the inner `F` from self
-    pub fn into_inner(self) -> F {
-        self.inner
-    }
-
-    /// Obtains the inner `F` from self
-    pub fn is_atomic_lock_free(&self, asize: u64) -> bool {
-        let lockfree_mask = self.properties.primitives.lock_free_atomic_mask
-            | self.properties.arch.lock_free_atomic_masks;
-
-        if asize > (1 << 15) {
-            return false;
-        } else {
-            let bits = (asize.next_power_of_two() - 1).count_ones();
-
-            (lockfree_mask & (1 << bits)) != 0
-        }
-    }
-
-    /// Writes a value according to access class to the pointer in `ptr`
-    pub fn store_val(&mut self, ptr: F::Loc, val: VStackValue<F::Loc>, cl: AccessClass) {
-        if cl.0 & 0xF != 0 {
-            let ty = self.type_of(&val);
-            let size = self.tys.type_size(&ty).unwrap();
-
-            let align = ty::scalar_align(size, self.properties.primitives.max_atomic_align);
-            let asize = ty::align_size(size, align);
-
-            if !self.is_atomic_lock_free(asize) || self.inner.lockfree_use_libatomic(asize) {
-                todo!("libatomic call")
-            }
-        }
-        match val {
-            VStackValue::Constant(Value::Invalid(_)) => {
-                self.inner.write_trap(Trap::Unreachable);
-                self.vstack.push_back(VStackValue::Trapped);
-            }
-            VStackValue::Constant(Value::Uninitialized(_)) | VStackValue::Trapped => {}
-            VStackValue::Constant(val) => {
-                self.inner.store_indirect_imm(val, ptr);
-            }
-            VStackValue::LValue(_, _) => panic!("Cannot store an lvalue"),
-            VStackValue::Pointer(ty, val) => match val {
-                LValue::OpaquePointer(loc) => {
-                    self.inner.store_indirect(ptr, loc, &Type::Pointer(ty))
-                }
-                lval => {
-                    let loc = self.inner.allocate_lvalue(false);
-                    self.move_val(VStackValue::Pointer(ty.clone(), lval), loc.clone());
-                    self.inner.store_indirect(ptr, loc, &Type::Pointer(ty));
-                }
-            },
-            VStackValue::OpaqueScalar(ty, loc) => {
-                self.inner.store_indirect(ptr, loc, &Type::Scalar(ty))
-            }
-            VStackValue::AggregatePieced(_, _) => todo!(),
-            VStackValue::OpaqueAggregate(ty, loc) => self.inner.store_indirect(ptr, loc, &ty),
-            VStackValue::CompareResult(_, _) => todo!(),
-            VStackValue::ArrayRepeat(_, _) => todo!(),
-        }
-    }
-
-    /// Moves a given value into the given value location
-    pub fn move_val(&mut self, val: VStackValue<F::Loc>, loc: F::Loc) {
-        match val {
-            VStackValue::Constant(Value::Invalid(_)) => {
-                self.inner.write_trap(Trap::Unreachable);
-                self.vstack.push_back(VStackValue::Trapped);
-            }
-            VStackValue::Constant(Value::Uninitialized(_)) | VStackValue::Trapped => {}
-            VStackValue::Constant(Value::GlobalAddress { item, .. }) => {
-                self.inner.compute_global_address(&item, loc)
-            }
-            VStackValue::Constant(Value::LabelAddress(n)) => {
-                self.inner.compute_label_address(n, loc)
-            }
-            VStackValue::Constant(Value::String {
-                encoding,
-                utf8,
-                ty: Type::Pointer(_),
-            }) => {
-                self.inner
-                    .compute_string_address(Encoding::XLang(encoding), utf8.into_bytes(), loc)
-            }
-            VStackValue::Constant(Value::String { ty, .. }) => todo!("string {:?}", ty),
-            VStackValue::Constant(Value::ByteString { content }) => self
-                .inner
-                .compute_string_address(Encoding::Byte, content, loc),
-            VStackValue::Constant(Value::Integer { val, ty }) => {
-                self.inner.move_imm(val, loc, &Type::Scalar(ty))
-            }
-            VStackValue::Constant(Value::GenericParameter(n)) => todo!("%{}", n),
-            VStackValue::Constant(Value::Empty) => panic!("Cannot move an empty value"),
-            VStackValue::Pointer(pty, lvalue) => match lvalue {
-                LValue::OpaquePointer(loc2) => self.inner.move_val(loc2, loc),
-                LValue::Temporary(_) => todo!("temporary address"),
-                LValue::Local(n) => todo!("local {:?}", n),
-                LValue::GlobalAddress(item) => self.inner.compute_global_address(&item, loc),
-                LValue::Label(n) => self.inner.compute_label_address(n, loc),
-                LValue::Field(_, _, _) => todo!("field"),
-                LValue::StringLiteral(enc, bytes) => {
-                    self.inner.compute_string_address(enc, bytes, loc)
-                }
-                LValue::Offset(_, _) => todo!("offset"),
-                LValue::Null => self.inner.move_imm(0, loc, &Type::Pointer(pty)),
-                LValue::TransparentAddr(addr) => {
-                    self.inner.move_imm(addr.get(), loc, &Type::Pointer(pty))
-                }
-            },
-            VStackValue::LValue(ty, lvalue) => {
-                let pty = PointerType {
-                    inner: Box::new(ty),
-                    ..Default::default()
-                };
-                match lvalue {
-                    LValue::OpaquePointer(loc2) => self.inner.move_val(loc2, loc),
-                    LValue::Temporary(_) => todo!("temporary address"),
-                    LValue::Local(n) => todo!("local {:?}", n),
-                    LValue::GlobalAddress(item) => self.inner.compute_global_address(&item, loc),
-                    LValue::Label(n) => self.inner.compute_label_address(n, loc),
-                    LValue::Field(_, _, _) => todo!("field"),
-                    LValue::StringLiteral(enc, bytes) => {
-                        self.inner.compute_string_address(enc, bytes, loc)
-                    }
-                    LValue::Offset(_, _) => todo!("offset"),
-                    LValue::Null => self.inner.move_imm(0, loc, &Type::Pointer(pty)),
-                    LValue::TransparentAddr(addr) => {
-                        self.inner.move_imm(addr.get(), loc, &Type::Pointer(pty))
-                    }
-                }
-            }
-            VStackValue::OpaqueScalar(_, loc2) => self.inner.move_val(loc2, loc),
-            VStackValue::AggregatePieced(ty, fields) => {
-                if self.tys.type_size(&ty) != StdSome(0) {
-                    let fields = fields.iter().collect::<Vec<_>>();
-
-                    if fields.len() == 1 {
-                        self.move_val(fields[0].1.clone(), loc);
-                    } else if fields.len() == 0 {
-                    } else {
-                        todo!("pieced aggregate")
-                    }
-                }
-            }
-            VStackValue::OpaqueAggregate(_, loc2) => self.inner.move_val(loc2, loc),
-            VStackValue::CompareResult(_, _) => todo!("compare result"),
-            VStackValue::ArrayRepeat(_, _) => todo!("array repeat"),
-        }
-    }
-
-    ///
-    /// Pushes a single value onto the vstack
-    pub fn push_value(&mut self, val: VStackValue<F::Loc>) {
-        self.vstack.push_back(val)
-    }
-
-    ///
-    /// Pops a single value from the vstack
-    pub fn pop_value(&mut self) -> Option<VStackValue<F::Loc>> {
-        self.vstack.pop_back().into()
-    }
-
-    ///
-    /// Pops `n` values from the vstack
-    pub fn pop_values(&mut self, n: usize) -> Option<Vec<VStackValue<F::Loc>>> {
-        let len = self.vstack.len();
-        if len < n {
-            None
-        } else {
-            Some(self.vstack.drain((len - n)..).collect())
-        }
-    }
-
-    /// Pops `N` values from the stack, and returns them in a statically-sized array, or otherwise returns `None`.
-    pub fn pop_values_static<const N: usize>(&mut self) -> Option<[VStackValue<F::Loc>; N]> {
-        let len = self.vstack.len();
-        if len < N {
-            None
-        } else {
-            let mut array = MaybeUninit::<[VStackValue<F::Loc>; N]>::uninit();
-            let ptr = array.as_mut_ptr().cast::<VStackValue<F::Loc>>();
-
-            let vals = self.vstack.drain((len - N)..);
-
-            for (i, val) in vals.enumerate() {
-                // SAFETY:
-                // i is less than the length of the array
-                unsafe {
-                    ptr.add(i).write(val);
-                }
-            }
-
-            // SAFETY:
-            // The loop above has initialized array
-            Some(unsafe { array.assume_init() })
-        }
-    }
-
-    ///
-    /// Pushes all of the incoming values to the stack, in order
-    pub fn push_values<I: IntoIterator<Item = VStackValue<F::Loc>>>(&mut self, vals: I) {
-        self.vstack.extend(vals);
-    }
-
-    /// Obtains an opaque value of the given type that is placed in `loc`
-    pub fn opaque_value(&mut self, ty: &Type, loc: F::Loc) -> VStackValue<F::Loc> {
-        match ty {
-            Type::Null | Type::Void | Type::FnType(_) => panic!("Invalid type"),
-            Type::Scalar(sty) => VStackValue::OpaqueScalar(*sty, loc),
-            Type::Pointer(pty) => VStackValue::Pointer(pty.clone(), LValue::OpaquePointer(loc)),
-            Type::Array(_) => todo!("array"),
-            Type::TaggedType(_, ty) => self.opaque_value(ty, loc),
-            Type::Product(_) | Type::Aggregate(_) => VStackValue::OpaqueAggregate(ty.clone(), loc),
-            Type::Aligned(_, ty) => self.opaque_value(ty, loc),
-            Type::Named(_) => VStackValue::OpaqueAggregate(ty.clone(), loc),
-        }
-    }
-
-    /// Determines the type of a vstack value
-    pub fn type_of(&mut self, val: &VStackValue<F::Loc>) -> Type {
-        match val {
-            VStackValue::Constant(val) => match val {
-                Value::Invalid(ty) | Value::Uninitialized(ty) => ty.clone(),
-                Value::GenericParameter(_) => panic!("Generic Parameter held too late"),
-                Value::Integer { ty, .. } => Type::Scalar(*ty),
-                Value::GlobalAddress { ty, .. } => Type::Pointer(PointerType {
-                    inner: Box::new(ty.clone()),
-                    ..Default::default()
-                }),
-                Value::ByteString { .. } => todo!("byte string"),
-                Value::String { ty, .. } => ty.clone(),
-                Value::LabelAddress(_) => Type::Pointer(PointerType {
-                    inner: Box::new(Type::Void),
-                    ..Default::default()
-                }),
-                Value::Empty => panic!("Cannot use an empty value"),
-            },
-            VStackValue::LValue(_, _) => panic!("Cannot typeof an lvalue"),
-            VStackValue::Pointer(pty, _) => Type::Pointer(pty.clone()),
-            VStackValue::OpaqueScalar(sty, _) => Type::Scalar(*sty),
-            VStackValue::AggregatePieced(ty, _) => ty.clone(),
-            VStackValue::OpaqueAggregate(ty, _) => ty.clone(),
-            VStackValue::CompareResult(_, _) => todo!("compare result"),
-            VStackValue::Trapped => Type::Null,
-            VStackValue::ArrayRepeat(_, _) => todo!("array repeat"),
-        }
-    }
-
-    /// Makes the given value opaque, if it is not already.
-    pub fn make_opaque(&mut self, val: VStackValue<F::Loc>) -> VStackValue<F::Loc> {
-        match val {
-            VStackValue::Constant(v) => match v {
-                Value::Invalid(ty) => {
-                    self.inner.write_trap(Trap::Unreachable);
-                    let loc = self.inner.allocate(&ty, false);
-                    self.opaque_value(&ty, loc)
-                }
-                Value::Uninitialized(ty) => {
-                    let loc = self.inner.allocate(&ty, false);
-                    self.opaque_value(&ty, loc)
-                }
-                Value::GenericParameter(_) => todo!("generic parameters"),
-                Value::Integer { ty, val } => {
-                    let loc = self.inner.allocate(&Type::Scalar(ty), false);
-                    self.move_val(
-                        VStackValue::Constant(Value::Integer { ty, val }),
-                        loc.clone(),
-                    );
-                    VStackValue::OpaqueScalar(ty, loc)
-                }
-                Value::GlobalAddress { ty, item } => {
-                    let pty = PointerType {
-                        inner: Box::new(ty.clone()),
-                        ..Default::default()
-                    };
-                    let loc = self.inner.allocate(&Type::Pointer(pty.clone()), false);
-                    self.move_val(
-                        VStackValue::Constant(Value::GlobalAddress { ty, item }),
-                        loc.clone(),
-                    );
-                    VStackValue::Pointer(pty, LValue::OpaquePointer(loc))
-                }
-                Value::ByteString { content } => {
-                    let pty = PointerType {
-                        inner: Box::new(Type::Scalar(ScalarType {
-                            header: ScalarTypeHeader {
-                                bitsize: 8,
-                                ..Default::default()
-                            },
-                            kind: ScalarTypeKind::Char {
-                                flags: CharFlags::empty(),
-                            },
-                        })),
-                        ..Default::default()
-                    };
-                    let loc = self.inner.allocate(&Type::Pointer(pty.clone()), false);
-                    self.move_val(
-                        VStackValue::Constant(Value::ByteString { content }),
-                        loc.clone(),
-                    );
-                    VStackValue::Pointer(pty, LValue::OpaquePointer(loc))
-                }
-                Value::String { encoding, utf8, ty } => {
-                    let loc = self.inner.allocate(&ty, false);
-                    self.move_val(
-                        VStackValue::Constant(Value::String {
-                            encoding,
-                            utf8,
-                            ty: ty.clone(),
-                        }),
-                        loc.clone(),
-                    );
-                    self.opaque_value(&ty, loc)
-                }
-                Value::LabelAddress(n) => {
-                    let pty = PointerType {
-                        inner: Box::new(Type::Void),
-                        ..Default::default()
-                    };
-                    let loc = self.inner.allocate(&Type::Pointer(pty.clone()), false);
-                    self.move_val(VStackValue::Constant(Value::LabelAddress(n)), loc.clone());
-                    VStackValue::Pointer(pty, LValue::OpaquePointer(loc))
-                }
-                Value::Empty => panic!("Cannot use an empty value"),
-            },
-            VStackValue::LValue(ty, LValue::OpaquePointer(loc)) => {
-                VStackValue::LValue(ty, LValue::OpaquePointer(loc))
-            }
-            VStackValue::Pointer(ty, LValue::OpaquePointer(loc)) => {
-                VStackValue::Pointer(ty, LValue::OpaquePointer(loc))
-            }
-            VStackValue::LValue(ty, lval) => {
-                let loc = self.inner.allocate_lvalue(false);
-                self.move_val(VStackValue::LValue(ty.clone(), lval), loc.clone());
-                VStackValue::LValue(ty, LValue::OpaquePointer(loc))
-            }
-            VStackValue::Pointer(ty, lval) => {
-                let loc = self.inner.allocate_lvalue(false);
-                self.move_val(VStackValue::Pointer(ty.clone(), lval), loc.clone());
-                VStackValue::Pointer(ty, LValue::OpaquePointer(loc))
-            }
-            VStackValue::OpaqueScalar(sty, loc) => VStackValue::OpaqueScalar(sty, loc),
-            VStackValue::AggregatePieced(ty, pieces) => {
-                let loc = self.inner.allocate(&ty, false);
-                self.move_val(
-                    VStackValue::AggregatePieced(ty.clone(), pieces),
-                    loc.clone(),
-                );
-                VStackValue::OpaqueAggregate(ty, loc)
-            }
-            VStackValue::OpaqueAggregate(ty, loc) => VStackValue::OpaqueAggregate(ty, loc),
-            VStackValue::CompareResult(_, _) => todo!("compare results"),
-            VStackValue::Trapped => VStackValue::Trapped,
-            VStackValue::ArrayRepeat(_, _) => todo!("array repeat"),
-        }
-    }
-
-    /// Pushes an opaque value of the given type
-    pub fn push_opaque(&mut self, ty: &Type, loc: F::Loc) {
-        let val = self.opaque_value(ty, loc);
-        self.push_value(val);
-    }
-
-    /// Clears the expression stack
-    pub fn clear_stack(&mut self) {
-        self.vstack.clear()
-    }
-
-    /// Calls a function by memory address stored in `loc`
-    pub fn call_indirect(
-        &mut self,
-        callty: &FnType,
-        realty: &FnType,
-        loc: F::Loc,
-        vals: Vec<VStackValue<F::Loc>>,
-        is_tailcall: bool,
-    ) {
-        self.inner.prepare_call_frame(callty, realty);
-        if let std::option::Option::Some(place) =
-            self.inner.get_callconv().pass_return_place(&callty.ret)
-        {
-            todo!("return place {:?}", place);
-        }
-
-        for (i, val) in vals.into_iter().enumerate() {
-            let param_loc =
-                self.inner
-                    .get_callconv()
-                    .find_param(callty, realty, i.try_into().unwrap(), false);
-            self.move_val(val, param_loc);
-        }
-
-        if is_tailcall {
-            self.inner.tailcall_indirect(loc, realty);
-            self.diverged = true;
-        } else {
-            self.inner.call_indirect(loc);
-            match &callty.ret {
-                Type::Void => {}
-                Type::Scalar(ScalarType {
-                    kind: kind @ ScalarTypeKind::Integer { .. },
-                    header: header @ ScalarTypeHeader { bitsize: 0, .. },
-                }) if header.validity.contains(ScalarValidity::NONZERO) => {
-                    // special case uint nonzero(0)/int nonzero(0)
-                    self.push_value(VStackValue::Constant(Value::Uninitialized(Type::Scalar(
-                        ScalarType {
-                            kind: *kind,
-                            header: *header,
-                        },
-                    ))));
-                }
-                ty => {
-                    let retloc = self.inner.get_callconv().find_return_val(callty);
-                    self.push_opaque(ty, retloc);
-                }
-            }
+            mach: Rc::new(mach),
+            targ: None,
+            functions: Vec::new(),
         }
     }
+}
 
-    /// Calls a function by name
-    pub fn call_fn(
+impl<M: Machine> XLangPlugin for SsaCodegenPlugin<M> {
+    fn accept_ir(
         &mut self,
-        callty: &FnType,
-        realty: &FnType,
-        path: &Path,
-        mut vals: Vec<VStackValue<F::Loc>>,
-        is_tailcall: bool,
-    ) {
-        if intrinsic::call_intrinsic(path, self, realty, self.properties, &mut vals) {
-            if is_tailcall {
-                self.write_exit(1);
-                self.diverged = true;
-            }
-            return;
-        }
-
-        self.inner.prepare_call_frame(callty, realty);
-        if let std::option::Option::Some(place) =
-            self.inner.get_callconv().pass_return_place(&callty.ret)
-        {
-            todo!("return place {:?}", place);
-        }
-
-        for (i, val) in vals.into_iter().enumerate() {
-            let param_loc =
-                self.inner
-                    .get_callconv()
-                    .find_param(callty, realty, i.try_into().unwrap(), false);
-            self.move_val(val, param_loc);
-        }
-        if is_tailcall {
-            self.inner.tailcall_direct(path, realty);
-            self.diverged = true;
-        } else {
-            self.inner.call_direct(path, realty);
-            match &callty.ret {
-                Type::Void => {}
-                Type::Scalar(ScalarType {
-                    kind: kind @ ScalarTypeKind::Integer { .. },
-                    header: header @ ScalarTypeHeader { bitsize: 0, .. },
-                }) if header.validity.contains(ScalarValidity::NONZERO) => {
-                    // special case uint nonzero(0)/int nonzero(0)
-                    self.push_value(VStackValue::Constant(Value::Invalid(Type::Scalar(
-                        ScalarType {
-                            kind: *kind,
-                            header: *header,
-                        },
-                    ))));
-                }
-                ty => {
-                    let retloc = self.inner.get_callconv().find_return_val(callty);
-                    self.push_opaque(ty, retloc);
-                }
-            }
-        }
-    }
-
-    /// Writes the exit point of the given block with the given number of values
-    pub fn write_exit(&mut self, values: u16) {
-        self.diverged = true;
-        if values == 1 {
-            let val = self.pop_value().unwrap();
-            match val {
-                VStackValue::Constant(Value::Invalid(_)) => {
-                    self.inner.write_trap(Trap::Unreachable);
-                    return;
-                }
-                VStackValue::Trapped => return,
-                val => {
-                    let loc = self.inner.get_callconv().find_return_val(&self.fnty);
-                    self.move_val(val, loc);
-                }
+        ir: &mut ir::File,
+    ) -> xlang::abi::result::Result<(), xlang::plugin::Error> {
+        let targ = self.targ.expect("set_target must be called first");
+        let mut tys = TypeInformation::from_properties(targ);
+        for Pair(path, field) in &ir.root.members {
+            match &field.member_decl {
+                ir::MemberDeclaration::Scope(_) => todo!("non-root scope"),
+                ir::MemberDeclaration::OpaqueAggregate(_) => tys.add_opaque_aggregate(path.clone()),
+                ir::MemberDeclaration::AggregateDefinition(def) => {
+                    tys.add_aggregate(path.clone(), def.clone())
+                }
+                ir::MemberDeclaration::Function(_)
+                | ir::MemberDeclaration::Static(_)
+                | ir::MemberDeclaration::Empty => {}
             }
-            self.inner.leave_function();
-        } else if values == 0 {
-            self.inner.leave_function();
-        } else {
-            panic!("Attempt to exit function with more than one value");
         }
-    }
-
-    /// Writes the given binary operator to the stream
-    pub fn write_binary_op(&mut self, op: BinaryOp, v: OverflowBehaviour) {
-        let [val1, val2] = self.pop_values_static().unwrap();
-
-        match (val1, val2) {
-            (VStackValue::Trapped, _) | (_, VStackValue::Trapped) => {
-                self.push_value(VStackValue::Trapped)
-            }
-            (VStackValue::LValue(_, _), _) | (_, VStackValue::LValue(_, _)) => {
-                panic!("Cannot apply {:?} to an lvalue", op)
-            }
-            (VStackValue::Constant(Value::Invalid(_)), _)
-            | (_, VStackValue::Constant(Value::Invalid(_))) => {
-                self.inner.write_trap(Trap::Unreachable);
-                self.push_value(VStackValue::Trapped);
-            }
-            (VStackValue::Constant(Value::Uninitialized(ty)), _)
-            | (_, VStackValue::Constant(Value::Uninitialized(ty))) => match op {
-                BinaryOp::Cmp | BinaryOp::CmpInt => self.push_value(VStackValue::Constant(
-                    Value::Uninitialized(Type::Scalar(ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: true,
-                            min: None,
-                            max: None,
-                        },
-                    })),
-                )),
-                BinaryOp::CmpLt
-                | BinaryOp::CmpGt
-                | BinaryOp::CmpLe
-                | BinaryOp::CmpGe
-                | BinaryOp::CmpEq
-                | BinaryOp::CmpNe => self.push_value(VStackValue::Constant(Value::Uninitialized(
-                    Type::Scalar(ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: true,
-                            min: None,
-                            max: None,
-                        },
-                    }),
-                ))),
-                _ => match v {
-                    OverflowBehaviour::Wrap | OverflowBehaviour::Unchecked => {
-                        self.push_value(VStackValue::Constant(Value::Uninitialized(ty)))
-                    }
-                    OverflowBehaviour::Trap => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    OverflowBehaviour::Checked => {
-                        self.push_values([
-                            VStackValue::Constant(Value::Uninitialized(ty)),
-                            VStackValue::Constant(Value::Uninitialized(Type::Scalar(ScalarType {
-                                header: ScalarTypeHeader {
-                                    bitsize: 1,
-                                    ..Default::default()
-                                },
-                                kind: ScalarTypeKind::Integer {
-                                    signed: false,
-                                    min: None,
-                                    max: None,
-                                },
-                            }))),
-                        ]);
-                    }
-                    v => todo!("Unexpected Overflow behaviour {:?}", v),
-                },
-            },
-            (
-                VStackValue::Constant(Value::Integer {
-                    ty:
-                        ty1 @ ScalarType {
-                            header:
-                                ScalarTypeHeader {
-                                    vectorsize: None, ..
-                                },
-                            kind: ScalarTypeKind::Integer { signed: false, .. },
-                        },
-                    val: val1,
-                }),
-                VStackValue::Constant(Value::Integer {
-                    ty:
-                        ty2 @ ScalarType {
-                            header:
-                                ScalarTypeHeader {
-                                    vectorsize: None, ..
-                                },
-                            kind: ScalarTypeKind::Integer { signed: false, .. },
-                        },
-                    val: val2,
-                }),
-            ) if ty1.header.bitsize == ty2.header.bitsize => match op {
-                BinaryOp::Cmp | BinaryOp::CmpInt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = match val1.cmp(&val2) {
-                        std::cmp::Ordering::Less => !0,
-                        std::cmp::Ordering::Equal => 0,
-                        std::cmp::Ordering::Greater => 1,
-                    };
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpLt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 < val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpGt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 > val2) as u128;
 
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpLe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 <= val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpGe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 >= val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpEq => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 == val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpNe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = (val1 != val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                _ => {
-                    let (val, overflow) = match op {
-                        BinaryOp::Add => val1.overflowing_add(val2),
-                        BinaryOp::Sub => val1.overflowing_sub(val2),
-                        BinaryOp::Mul => val1.overflowing_mul(val2),
-                        BinaryOp::Div => {
-                            if val2 == 0 {
-                                (0, true)
-                            } else {
-                                val1.overflowing_div(val2)
-                            }
+        let tys = Rc::new(tys);
+        for Pair(path, field) in &ir.root.members {
+            match &field.member_decl {
+                ir::MemberDeclaration::Scope(_) => todo!("non-root scope"),
+                ir::MemberDeclaration::Function(f) => {
+                    let sym = match &*path.components {
+                        [ir::PathComponent::Text(name)]
+                        | [ir::PathComponent::Root, ir::PathComponent::Text(name)] => {
+                            name.to_string()
                         }
-                        BinaryOp::Mod => {
-                            if val2 == 0 {
-                                (0, true)
-                            } else {
-                                val1.overflowing_rem(val2)
-                            }
+                        [ir::PathComponent::Root, rest @ ..] | [rest @ ..] => {
+                            self.mach.mangle(rest)
                         }
-                        BinaryOp::BitOr => (val1 | val2, false),
-                        BinaryOp::BitAnd => (val1 & val2, false),
-                        BinaryOp::BitXor => (val1 ^ val2, false),
-                        BinaryOp::Lsh => (
-                            val1.wrapping_shl(val2 as u32),
-                            val2 > (ty1.header.bitsize.into()),
-                        ),
-                        BinaryOp::Rsh => (
-                            val1.wrapping_shr(val2 as u32),
-                            val2 > (ty1.header.bitsize.into()),
-                        ),
-                        BinaryOp::Cmp
-                        | BinaryOp::CmpInt
-                        | BinaryOp::CmpLt
-                        | BinaryOp::CmpLe
-                        | BinaryOp::CmpEq
-                        | BinaryOp::CmpNe
-                        | BinaryOp::CmpGe
-                        | BinaryOp::CmpGt => unreachable!(),
-                        op => todo!("{:?}", op),
                     };
-
-                    let overflow = overflow || (val.leading_zeros() < (ty1.header.bitsize as u32));
-                    let val = val & (!((!0u128).wrapping_shl(128 - (ty1.header.bitsize as u32))));
-
-                    match v {
-                        OverflowBehaviour::Wrap => self
-                            .vstack
-                            .push_back(VStackValue::Constant(Value::Integer { ty: ty1, val })),
-                        OverflowBehaviour::Unchecked => {
-                            if overflow {
-                                self.vstack
-                                    .push_back(VStackValue::Constant(Value::Uninitialized(
-                                        Type::Scalar(ty1),
-                                    )))
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }))
-                            }
+                    let ty = Rc::new(f.ty.clone());
+
+                    let section = SectionSpec::Global;
+                    let linkage = f.linkage;
+                    let body = if let XLangSome(body) = &f.body {
+                        let mut builder = ssa::FunctionBuilder::new(
+                            sym.clone(),
+                            self.mach.clone(),
+                            tys.clone(),
+                            targ,
+                            ty.clone(),
+                        );
+                        for local in &body.locals {
+                            builder.push_local(local.clone());
                         }
-                        OverflowBehaviour::Checked => {
-                            self.vstack
-                                .push_back(VStackValue::Constant(Value::Integer { ty: ty1, val }));
-                            self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                ty: ScalarType {
-                                    header: ScalarTypeHeader {
-                                        bitsize: 1,
-                                        ..Default::default()
-                                    },
-                                    kind: ScalarTypeKind::Integer {
-                                        signed: false,
-                                        min: None,
-                                        max: None,
-                                    },
-                                },
-                                val: overflow as u128,
-                            }));
+                        for block in &body.blocks {
+                            builder.push_incoming(block.target, &block.incoming_stack);
                         }
-                        OverflowBehaviour::Trap => {
-                            if overflow {
-                                self.inner.write_trap(Trap::Overflow);
-                                self.vstack.push_back(VStackValue::Trapped);
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }));
+                        for block in &body.blocks {
+                            let block_builder =
+                                builder.new_basic_block(block.target, &block.incoming_stack);
+                            for expr in &block.expr {
+                                block_builder.write_expr(expr);
                             }
+                            block_builder.write_terminator(&block.term);
                         }
-                        OverflowBehaviour::Saturate => {
-                            if (op == BinaryOp::Sub || op == BinaryOp::Rsh) && overflow {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val: 0,
-                                }));
-                            } else if overflow {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val: !((!0u128)
-                                        .wrapping_shl(128 - (ty1.header.bitsize as u32))),
-                                }));
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }));
-                            }
-                        }
-                        v => todo!("{:?} {:?}", op, v),
-                    }
-                }
-            },
-            (
-                VStackValue::Constant(Value::Integer {
-                    ty:
-                        ty1 @ ScalarType {
-                            header:
-                                ScalarTypeHeader {
-                                    vectorsize: None, ..
-                                },
-                            kind: ScalarTypeKind::Integer { signed: true, .. },
-                        },
-                    val: val1,
-                }),
-                VStackValue::Constant(Value::Integer {
-                    ty:
-                        ty2 @ ScalarType {
-                            header:
-                                ScalarTypeHeader {
-                                    vectorsize: None, ..
-                                },
-                            kind: ScalarTypeKind::Integer { signed: true, .. },
-                        },
-                    val: val2,
-                }),
-            ) if ty1.header.bitsize == ty2.header.bitsize => match op {
-                BinaryOp::Cmp | BinaryOp::CmpInt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = match (val1 as i128).cmp(&(val2 as i128)) {
-                        std::cmp::Ordering::Less => !0,
-                        std::cmp::Ordering::Equal => 0,
-                        std::cmp::Ordering::Greater => 1,
-                    };
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpLt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = ((val1 as i128) < (val2 as i128)) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpGt => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = ((val1 as i128) > (val2 as i128)) as u128;
 
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpLe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = ((val1 as i128) <= (val2 as i128)) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpGe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    let val = ((val1 as i128) >= (val2 as i128)) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpEq => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
+                        Some(builder)
+                    } else {
+                        None
                     };
-                    let val = (val1 == val2) as u128;
 
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                BinaryOp::CmpNe => {
-                    let sty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 32,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
+                    self.functions.push((
+                        sym,
+                        FunctionDef {
+                            section,
+                            linkage,
+                            fnty: ty,
+                            body,
                         },
-                    };
-                    let val = (val1 != val2) as u128;
-
-                    self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                }
-                _ => {
-                    let val1 = val1 as i128;
-                    let val2 = val2 as i128;
-                    let (val, overflow) = match op {
-                        BinaryOp::Add => val1.overflowing_add(val2),
-                        BinaryOp::Sub => val1.overflowing_sub(val2),
-                        BinaryOp::Mul => val1.overflowing_mul(val2),
-                        BinaryOp::Div => {
-                            if val2 == 0 {
-                                (0, true)
-                            } else {
-                                val1.overflowing_div(val2)
-                            }
-                        }
-                        BinaryOp::Mod => {
-                            if val2 == 0 {
-                                (0, true)
-                            } else {
-                                val1.overflowing_rem(val2)
-                            }
-                        }
-                        BinaryOp::BitOr => (val1 | val2, false),
-                        BinaryOp::BitAnd => (val1 & val2, false),
-                        BinaryOp::BitXor => (val1 ^ val2, false),
-                        BinaryOp::Lsh => (
-                            val1.wrapping_shl(val2 as u32),
-                            val2 > (ty1.header.bitsize.into()),
-                        ),
-                        BinaryOp::Rsh => (
-                            val1.wrapping_shr(val2 as u32),
-                            val2 > (ty1.header.bitsize.into()),
-                        ),
-                        BinaryOp::Cmp
-                        | BinaryOp::CmpInt
-                        | BinaryOp::CmpLt
-                        | BinaryOp::CmpLe
-                        | BinaryOp::CmpEq
-                        | BinaryOp::CmpNe
-                        | BinaryOp::CmpGe
-                        | BinaryOp::CmpGt => unreachable!(),
-                        op => todo!("{:?}", op),
-                    };
-
-                    let overflow = overflow
-                        || ((val.leading_zeros() < (ty1.header.bitsize as u32))
-                            && (val.leading_ones() < (ty1.header.bitsize as u32)));
-                    let val = val & (!((!0i128).wrapping_shl(128 - (ty1.header.bitsize as u32))));
-
-                    let val = (((val as i128) << ((128 - (ty1.header.bitsize - 1)) as u32))
-                        >> ((128 - (ty1.header.bitsize - 1)) as u32))
-                        as u128; // sign extend signed integers. This makes implementing Cmp et. al above easier
-
-                    match v {
-                        OverflowBehaviour::Wrap => self
-                            .vstack
-                            .push_back(VStackValue::Constant(Value::Integer { ty: ty1, val })),
-                        OverflowBehaviour::Unchecked => {
-                            if overflow {
-                                self.vstack
-                                    .push_back(VStackValue::Constant(Value::Uninitialized(
-                                        Type::Scalar(ty1),
-                                    )))
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }))
-                            }
-                        }
-                        OverflowBehaviour::Checked => {
-                            self.vstack
-                                .push_back(VStackValue::Constant(Value::Integer { ty: ty1, val }));
-                            self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                ty: ScalarType {
-                                    header: ScalarTypeHeader {
-                                        bitsize: 1,
-                                        ..Default::default()
-                                    },
-                                    kind: ScalarTypeKind::Integer {
-                                        signed: false,
-                                        min: None,
-                                        max: None,
-                                    },
-                                },
-                                val: overflow as u128,
-                            }));
-                        }
-                        OverflowBehaviour::Trap => {
-                            if overflow {
-                                self.inner.write_trap(Trap::Abort);
-                                self.vstack.push_back(VStackValue::Trapped);
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }));
-                            }
-                        }
-                        OverflowBehaviour::Saturate => {
-                            if (op == BinaryOp::Sub || op == BinaryOp::Rsh) && overflow {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val: 0,
-                                }));
-                            } else if overflow {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val: !((!0u128)
-                                        .wrapping_shl(128 - (ty1.header.bitsize as u32))),
-                                }));
-                            } else {
-                                self.vstack.push_back(VStackValue::Constant(Value::Integer {
-                                    ty: ty1,
-                                    val,
-                                }));
-                            }
-                        }
-                        v => todo!("{:?} {:?}", op, v),
-                    }
+                    ));
                 }
-            },
-            (
-                VStackValue::OpaqueScalar(
-                    st @ ScalarType {
-                        kind: ScalarTypeKind::Integer { .. },
-                        ..
-                    },
-                    loc,
-                ),
-                VStackValue::Constant(Value::Integer { ty, val }),
-            ) if st == ty => {
-                let header = st.header;
-                match header.vectorsize {
-                    None => {
-                        if header.bitsize.is_power_of_two()
-                            && header.bitsize <= self.inner.native_int_size()
-                        {
-                            match v {
-                                OverflowBehaviour::Wrap | OverflowBehaviour::Unchecked => {
-                                    let new_loc = match op {
-                                        BinaryOp::CmpEq
-                                        | BinaryOp::CmpNe
-                                        | BinaryOp::CmpGt
-                                        | BinaryOp::CmpLt
-                                        | BinaryOp::CmpGe
-                                        | BinaryOp::CmpLe => self.inner.allocate(
-                                            &Type::Scalar(ScalarType {
-                                                kind: ScalarTypeKind::Integer {
-                                                    signed: false,
-                                                    min: None,
-                                                    max: None,
-                                                },
-                                                header: ScalarTypeHeader {
-                                                    bitsize: 1,
-                                                    vectorsize: None,
-                                                    validity: Default::default(),
-                                                },
-                                            }),
-                                            false,
-                                        ),
-                                        BinaryOp::CmpInt => self.inner.allocate(
-                                            &Type::Scalar(ScalarType {
-                                                kind: ScalarTypeKind::Integer {
-                                                    signed: true,
-                                                    min: None,
-                                                    max: None,
-                                                },
-                                                header: ScalarTypeHeader {
-                                                    bitsize: 32,
-                                                    vectorsize: None,
-                                                    validity: Default::default(),
-                                                },
-                                            }),
-                                            false,
-                                        ),
-                                        _ => self.inner.allocate(&Type::Scalar(st), false),
-                                    };
-                                    self.inner.write_int_binary_imm(
-                                        new_loc.clone(),
-                                        loc,
-                                        val,
-                                        &Type::Scalar(st),
-                                        op,
-                                    );
-                                    self.push_value(VStackValue::OpaqueScalar(st, new_loc));
-                                }
-                                v => todo!("{:?} {:?}", op, v),
-                            }
-                        } else {
-                            todo!("Non-native integer")
-                        }
-                    }
-                    Some(vector) => todo!("vectorsize({:?})", vector),
-                }
-            }
-            (a, b) => todo!("{:?}: {:?}, {:?}", op, a, b),
-        }
-    }
-
-    fn branch_to(&mut self, target: u32) {
-        let values = self.pop_values(self.targets[&target].len()).unwrap();
-        for (targ_val, val) in self.targets[&target].clone().into_iter().zip(values) {
-            let loc = targ_val.opaque_location().unwrap().clone();
-            self.move_val(val, loc);
-        }
-
-        if !self.locals_opaque {
-            let mut locals = std::mem::take(&mut self.locals);
-
-            for (local, _) in &mut locals {
-                let val = core::mem::replace(local, VStackValue::Trapped);
-
-                *local = self.make_opaque(val);
-            }
-
-            self.locals = locals;
-            self.locals_opaque = true;
-        }
-
-        self.diverged = true;
-        if let StdSome(targ) = self.cfg.get(&target) {
-            if targ.fallthrough_from == self.ctarg {
-                return;
-            }
-        }
-
-        self.inner.branch_unconditional(target);
-    }
-
-    fn branch_conditional_to(&mut self, target: u32, cond: BranchCondition, loc: F::Loc) {
-        let values = self.pop_values(self.targets[&target].len()).unwrap();
-        for (targ_val, val) in self.targets[&target].clone().into_iter().zip(values) {
-            let loc = targ_val.opaque_location().unwrap().clone();
-            self.move_val(val, loc);
-            self.push_value(targ_val);
-        }
-
-        if !self.locals_opaque {
-            let mut locals = std::mem::take(&mut self.locals);
-
-            for (local, _) in &mut locals {
-                let val = core::mem::replace(local, VStackValue::Trapped);
-
-                *local = self.make_opaque(val);
+                ir::MemberDeclaration::Static(_) => todo!("static"),
+                ir::MemberDeclaration::OpaqueAggregate(_)
+                | ir::MemberDeclaration::AggregateDefinition(_)
+                | ir::MemberDeclaration::Empty => {}
             }
-
-            self.locals = locals;
-            self.locals_opaque = true;
         }
 
-        if let StdSome(targ) = self.cfg.get(&target) {
-            if targ.fallthrough_from == self.ctarg {
-                return;
+        for (name, def) in &self.functions {
+            print!("{}{} {}{}", def.section, def.linkage, name, def.fnty);
+            if let Some(body) = &def.body {
+                println!("{}", body);
+            } else {
+                println!(";");
             }
         }
 
-        self.inner.branch(target, cond, loc);
+        xlang::abi::result::Ok(())
     }
 
-    /// Writes a (potentially conditional) branch to `target` based on `cond`
-    pub fn write_branch(&mut self, cond: BranchCondition, target: u32) {
-        match cond {
-            BranchCondition::Always => {
-                self.branch_to(target);
-            }
-            BranchCondition::Never => {}
-            cond => {
-                let control = self.pop_value().unwrap();
-                match control {
-                    VStackValue::Constant(Value::Uninitialized(_))
-                    | VStackValue::Constant(Value::Invalid(_)) => {
-                        self.inner.write_trap(Trap::Unreachable);
-                        self.vstack.push_back(VStackValue::Trapped);
-                    }
-                    VStackValue::Constant(Value::Integer {
-                        ty:
-                            ScalarType {
-                                kind: ScalarTypeKind::Integer { signed, .. },
-                                ..
-                            },
-                        val,
-                    }) => {
-                        let taken = match cond {
-                            BranchCondition::Equal => val == 0,
-                            BranchCondition::NotEqual => val != 0,
-                            BranchCondition::Less => signed && ((val as i128) < 0),
-                            BranchCondition::LessEqual => {
-                                (signed && ((val as i128) <= 0)) || val == 0
-                            }
-                            BranchCondition::Greater => {
-                                if signed {
-                                    (val as i128) > 0
-                                } else {
-                                    val > 0
-                                }
-                            }
-                            BranchCondition::GreaterEqual => (!signed) || ((val as i128) >= 0),
-                            _ => unreachable!(),
-                        };
-
-                        if taken {
-                            self.branch_to(target);
-                        }
-                    }
-                    VStackValue::OpaqueScalar(_, loc) => {
-                        self.branch_conditional_to(target, cond, loc);
-                    }
-                    VStackValue::CompareResult(_, _) => todo!("compare"),
-                    VStackValue::Trapped => {
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    val => panic!("Invalid Branch Control {:?}", val),
-                }
-            }
-        }
+    fn set_target(&mut self, targ: &'static xlang::targets::properties::TargetProperties<'static>) {
+        Rc::get_mut(&mut self.mach).unwrap().init_from_target(targ);
+        self.targ = Some(targ);
     }
+}
 
-    fn get_field_paths(
-        &self,
-        lval: LValue<F::Loc>,
-        ty: &Type,
-    ) -> (Type, LValue<F::Loc>, Vec<String>) {
-        match lval {
-            LValue::Field(base_ty, base, field) => {
-                let base_type = self.tys.get_field_type(&base_ty, &field).unwrap();
-                if &base_type == ty {
-                    let (inner_ty, base, mut fields) =
-                        self.get_field_paths(Box::into_inner(base), &base_ty);
-                    fields.push(field);
-                    (inner_ty, base, fields)
-                } else {
-                    (
-                        ty.clone(),
-                        LValue::Field(base_ty, base, field),
-                        xlang::abi::vec![],
-                    )
-                }
-            }
-            lval => (ty.clone(), lval, xlang::abi::vec![]),
-        }
+impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
+    fn target_matches(&self, x: xlang::abi::string::StringView) -> bool {
+        self.mach.matches_target(x)
     }
 
-    /// Writes a unary operator
-    pub fn write_unary_op(&mut self, op: UnaryOp, v: OverflowBehaviour) {
-        let val = self.pop_value().unwrap();
-        match val {
-            VStackValue::Constant(Value::Invalid(_)) => {
-                self.inner.write_trap(Trap::Unreachable);
-                self.push_value(VStackValue::Trapped);
-            }
-            VStackValue::Constant(Value::Uninitialized(ty)) => match v {
-                OverflowBehaviour::Checked => {
-                    let check_ty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 1,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    self.push_value(VStackValue::Constant(Value::Uninitialized(ty)));
-                    self.push_value(VStackValue::Constant(Value::Uninitialized(Type::Scalar(
-                        check_ty,
-                    ))));
-                }
-                OverflowBehaviour::Trap => {
-                    self.inner.write_trap(Trap::Unreachable);
-                    self.push_value(VStackValue::Trapped);
-                }
-                _ => self.push_value(VStackValue::Constant(Value::Uninitialized(ty))),
-            },
-            VStackValue::Constant(Value::Integer {
-                ty:
-                    sty @ ScalarType {
-                        kind: ScalarTypeKind::Integer { signed: false, .. },
-                        ..
-                    },
-                val,
-            }) => {
-                let base_val = match op {
-                    UnaryOp::Minus => (-(val as i128)) as u128,
-                    UnaryOp::BitNot => !val,
-                    UnaryOp::LogicNot => (val == 0) as u128,
-                    op => panic!("Invalid unary op {:?}", op),
+    fn write_output(
+        &mut self,
+        x: xlang::prelude::v1::DynMut<dyn xlang::abi::io::Write>,
+        mode: xlang::plugin::OutputMode,
+    ) -> xlang::abi::io::Result<()> {
+        let targ = self.targ.expect("set_target must have been called first");
+        if mode == xlang::plugin::OutputMode::Obj {
+            let mut writer = WriteAdapter::new(x);
+            let fmt =
+                binfmt::format_by_name(&targ.link.obj_binfmt).expect("obj_binfmt is not supported");
+
+            let mut output = fmt.create_file(binfmt::fmt::FileType::Relocatable);
+
+            let mut sections = vec![
+                Section {
+                    name: format!(".text"),
+                    align: 1024,
+                    ty: binfmt::fmt::SectionType::ProgBits,
+                    flags: Some(SectionFlag::Alloc | SectionFlag::Executable),
+                    ..Section::default()
+                },
+                Section {
+                    name: format!(".rodata"),
+                    align: 1024,
+                    ty: binfmt::fmt::SectionType::ProgBits,
+                    flags: Some(SectionFlag::Alloc.into()),
+                    ..Section::default()
+                },
+                Section {
+                    name: format!(".data"),
+                    align: 1024,
+                    ty: binfmt::fmt::SectionType::ProgBits,
+                    flags: Some(SectionFlag::Alloc | SectionFlag::Writable),
+                    ..Section::default()
+                },
+                Section {
+                    name: format!(".bss"),
+                    align: 1024,
+                    ty: binfmt::fmt::SectionType::NoBits,
+                    flags: Some(SectionFlag::Alloc | SectionFlag::Writable),
+                    ..Section::default()
+                },
+            ];
+            let mut syms = vec![];
+
+            for (sym_name, def) in core::mem::take(&mut self.functions) {
+                let sym_kind = match def.linkage {
+                    Linkage::External => SymbolKind::Global,
+                    Linkage::Internal => SymbolKind::Local,
+                    Linkage::Constant => SymbolKind::Local,
+                    Linkage::Weak => SymbolKind::Weak,
                 };
 
-                let mask = (!0u128).wrapping_shr((128 - sty.header.bitsize) as u32);
+                if let Some(mut body) = def.body {
+                    let section = match def.section {
+                        SectionSpec::Global => 0,
+                    };
+                    let offset = sections[section as usize].offset();
+                    let sym_idx = syms.len();
+                    let sym = Symbol::new(
+                        sym_name,
+                        section,
+                        offset as u128,
+                        SymbolType::Function,
+                        sym_kind,
+                    );
+                    syms.push(sym);
 
-                self.push_value(VStackValue::Constant(Value::Integer {
-                    ty: sty,
-                    val: base_val & mask,
-                }));
+                    try_!(body
+                        .write(&mut sections[section as usize], |name, offset| {
+                            let inner_sym = Symbol::new(
+                                name,
+                                section,
+                                offset,
+                                SymbolType::Null,
+                                SymbolKind::Local,
+                            );
+                            syms.push(inner_sym);
+                        })
+                        .map_err(Into::into));
 
-                if v == OverflowBehaviour::Checked {
-                    let check_ty = ScalarType {
-                        header: ScalarTypeHeader {
-                            bitsize: 1,
-                            ..Default::default()
-                        },
-                        kind: ScalarTypeKind::Integer {
-                            signed: false,
-                            min: None,
-                            max: None,
-                        },
-                    };
-                    self.push_value(VStackValue::Constant(Value::Integer {
-                        ty: check_ty,
-                        val: 1,
-                    }));
+                    *syms[sym_idx].size_mut() =
+                        Some((sections[section as usize].offset() - offset) as u64);
+                } else if sym_kind == SymbolKind::Weak {
+                    syms.push(Symbol::new_undef(sym_name, SymbolType::Function, sym_kind));
                 }
             }
 
-            VStackValue::Constant(Value::Integer {
-                ty:
-                    sty @ ScalarType {
-                        kind: ScalarTypeKind::Integer { signed: true, .. },
-                        ..
-                    },
-                val,
-            }) => {
-                let base_val = match op {
-                    UnaryOp::Minus => (-(val as i128)) as u128,
-                    UnaryOp::BitNot => !val,
-                    UnaryOp::LogicNot => (val == 0) as u128,
-                    op => panic!("Invalid unary op {:?}", op),
-                };
-
-                let overflow = op == UnaryOp::Minus && (base_val == val);
-
-                let mask = (!0u128).wrapping_shr((128 - sty.header.bitsize) as u32);
-
-                let val = base_val & mask;
-
-                let val = (((val as i128) << ((128 - (sty.header.bitsize - 1)) as u32))
-                    >> ((128 - (sty.header.bitsize - 1)) as u32)) as u128;
+            let mut section_map = vec![];
+            for section in sections {
+                let new_off = output
+                    .add_section(section)
+                    .expect("Could not add a section");
+                section_map.push(new_off)
+            }
 
-                match (v, overflow) {
-                    (OverflowBehaviour::Wrap | OverflowBehaviour::Saturate, _)
-                    | (OverflowBehaviour::Unchecked | OverflowBehaviour::Trap, false) => {
-                        self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }))
-                    }
-                    (OverflowBehaviour::Unchecked, true) => self.push_value(VStackValue::Constant(
-                        Value::Uninitialized(Type::Scalar(sty)),
-                    )),
-                    (OverflowBehaviour::Trap, true) => {
-                        self.inner.write_trap(Trap::Abort);
-                        self.push_value(VStackValue::Trapped);
-                    }
-                    (OverflowBehaviour::Checked, overflow) => {
-                        self.push_value(VStackValue::Constant(Value::Integer { ty: sty, val }));
-                        let check_ty = ScalarType {
-                            header: ScalarTypeHeader {
-                                bitsize: 1,
-                                ..Default::default()
-                            },
-                            kind: ScalarTypeKind::Integer {
-                                signed: false,
-                                min: None,
-                                max: None,
-                            },
-                        };
-                        self.push_value(VStackValue::Constant(Value::Integer {
-                            ty: check_ty,
-                            val: overflow as u128,
-                        }));
-                    }
-                    (v, _) => panic!("Invalid overflow behaviour {:?}", v),
+            for sym in syms.iter_mut() {
+                if let Some(sect) = sym.section_mut() {
+                    *sect = section_map[(*sect) as usize];
                 }
             }
-            VStackValue::OpaqueScalar(sty, loc) => {
-                todo!("OpaqueScalar({},{:?})", sty, loc);
-            }
-            val => panic!("Invalid value {}", val),
+            output.add_symbols(syms).expect("Could not add symbols");
+            try_!(fmt.write_file(&mut writer, &output).map_err(Into::into));
+            xlang::abi::result::Ok(())
+        } else {
+            todo!("asm file")
         }
     }
-
-    /// Writes an expression in linear order into the codegen
-    pub fn write_expr(&mut self, _: &Expr) {
-        unimplemented!()
-    }
-
-    /// Writes an asm-expr
-    pub fn write_asm(&mut self, _: &AsmExpr) {
-        unimplemented!()
-    }
-
-    /// Writes the elements of a block to the codegen, usually the top level block of a function
-    pub fn write_block(&mut self, _: &Block, _: u32) {
-        unimplemented!()
-    }
 }
diff --git a/xlang/xlang_backend/src/mach.rs b/xlang/xlang_backend/src/mach.rs
new file mode 100644
index 00000000..e5b7f516
--- /dev/null
+++ b/xlang/xlang_backend/src/mach.rs
@@ -0,0 +1,42 @@
+use xlang::{abi::string::StringView, targets::properties::TargetProperties};
+
+use crate::{
+    mangle::mangle_itanium,
+    ssa::{OpaqueLocation, SsaInstruction},
+};
+
+use arch_ops::traits::InsnWrite;
+
+use std::io::Result;
+
+pub trait Machine {
+    type Assignments;
+    type BlockClobbers;
+    fn matches_target(&self, targ: StringView) -> bool;
+    fn init_from_target(&mut self, targ: &TargetProperties);
+    fn new_assignments(&self) -> Self::Assignments;
+    fn assign_locations(
+        &self,
+        assignments: &mut Self::Assignments,
+        insns: &[SsaInstruction],
+        incoming: &[OpaqueLocation],
+        which: u32,
+    ) -> Self::BlockClobbers;
+    fn codegen_prologue<W: InsnWrite>(
+        &self,
+        assignments: &Self::Assignments,
+        out: &mut W,
+    ) -> std::io::Result<()>;
+    fn codegen_block<W: InsnWrite, F: Fn(u32) -> String>(
+        &self,
+        assignments: &Self::Assignments,
+        insns: &[SsaInstruction],
+        block_clobbers: Self::BlockClobbers,
+        out: &mut W,
+        label_sym: F,
+        which: u32,
+    ) -> std::io::Result<()>;
+    fn mangle(&self, path: &[xlang::ir::PathComponent]) -> String {
+        mangle_itanium(path)
+    }
+}
diff --git a/xlang/xlang_backend/src/mc.rs b/xlang/xlang_backend/src/mc.rs
deleted file mode 100644
index 067e1bda..00000000
--- a/xlang/xlang_backend/src/mc.rs
+++ /dev/null
@@ -1,1036 +0,0 @@
-use core::convert::TryFrom;
-use std::{cell::RefCell, io::Write, rc::Rc};
-
-use arch_ops::traits::InsnWrite;
-use binfmt::{
-    fmt::{FileType, Section},
-    sym::Symbol,
-};
-use xlang::{
-    abi::{
-        collection::HashMap, io::WriteAdapter, option::None as XLangNone, pair::Pair,
-        result::Result::Ok as XLangOk, span::Span, string::StringView, try_,
-    },
-    ir::{
-        AccessClass, BinaryOp, FnType, Linkage, PathComponent, PointerKind, ScalarType,
-        ScalarTypeHeader, ScalarTypeKind, Type, UnaryOp,
-    },
-    plugin::{OutputMode, XLangCodegen, XLangPlugin},
-    targets::properties::{StackAttributeControlStyle, TargetProperties},
-};
-
-use crate::{
-    callconv::CallingConvention,
-    expr::{Trap, VStackValue, ValLocation},
-    str::StringMap,
-    ty::TypeInformation,
-    FunctionCodegen, FunctionRawCodegen,
-};
-
-/// Register Allocation
-pub mod regalloc;
-
-/// Calling Convention Abstraction
-pub mod callconv;
-
-/// Converts the u128 `val` into bytes according to the platform endianness in `props`
-pub fn u128_to_targ_bytes(val: u128, props: &TargetProperties) -> [u8; 16] {
-    match props.arch.byte_order {
-        xlang::targets::properties::ByteOrder::LittleEndian => val.to_le_bytes(),
-        xlang::targets::properties::ByteOrder::BigEndian => val.to_be_bytes(),
-        xlang::targets::properties::ByteOrder::MiddleEndian => {
-            let mut bytes = val.to_be_bytes();
-            for i in 0..8 {
-                bytes.swap(2 * i, 2 * i + 1);
-            }
-            bytes
-        }
-    }
-}
-
-/// Basic Queries about Machine Features
-pub trait MachineFeatures {
-    /// The type of Value Locations
-    type Loc: ValLocation;
-
-    /// The type of Value Locations
-    type CallConv: CallingConvention<Loc = Self::Loc>;
-
-    /// The maximum integer size (in bits) supported natively (without emulation)
-    fn native_int_size(&self) -> u16;
-    /// The maximum floating point size (in bits) supported natively, or None if no floating-point support exists
-    fn native_float_size(&self) -> Option<u16>;
-
-    /// The maximum Vector size supported natively, in bytes
-    fn native_vec_size(&self) -> Option<u64> {
-        None
-    }
-
-    /// Preferred Vector size of the current codegen, in total bytes
-    /// This need not be the same as the [`FunctionRawCodegen::native_vec_size`], for example, if some vector types incur a significant runtime performance penalty
-    /// (such as AVX-512)
-    fn preferred_vec_size(&self) -> Option<u64> {
-        None
-    }
-
-    /// Whether or not lock-free atomic ops of some size should issue a call to libatomic for this backend.
-    fn lockfree_use_libatomic(&self, size: u64) -> bool;
-
-    /// Whether or not lock-free atomic rmws use libatomic
-    fn lockfree_cmpxchg_use_libatomic(&self, size: u64) -> bool;
-
-    /// Whether or not BinaryOp can be implemented directly by the CPU
-    fn has_wait_free_compound(&self, op: BinaryOp, size: u64) -> bool;
-
-    /// Whether or not the fecth version of BinaryOp can be implemented directly by the CPU
-    fn has_wait_free_compound_fetch(&self, op: BinaryOp, size: u64) -> bool;
-
-    /// Whether or not volatile has any effect on codegen
-    fn propagate_side_effects(&self) -> bool {
-        false
-    }
-
-    /// Whether or not the `sequence` XIR instruction has any effect on codegen
-    fn propagate_sequence(&self) -> bool {
-        false
-    }
-
-    /// Mangle the given path. Note: This has already stripped the `Root` and won't be non-mangled paths
-    fn mangle(&self, path: &[PathComponent]) -> String;
-}
-
-/// An abstract machine instruction, converted by `xlang_backend` from XIR.
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum MCInsn<Loc> {
-    /// Performs no-operation
-    Null,
-    /// Move a value from one location to another
-    Mov {
-        /// The destination location
-        dest: MaybeResolved<Loc>,
-        /// The source location
-        src: MaybeResolved<Loc>,
-    },
-    /// Moves an immediate value into a location
-    MovImm {
-        /// The destination location
-        dest: MaybeResolved<Loc>,
-        /// The Source Value
-        src: u128,
-    },
-    /// Stores from src into the pointer in `dest_ptr`
-    StoreIndirect {
-        /// The destination pointer
-        dest_ptr: MaybeResolved<Loc>,
-        /// The Source value
-        src: MaybeResolved<Loc>,
-        /// Class
-        cl: AccessClass,
-    },
-    /// Stores of an immediate integer into the pointer in `dest_ptr`
-    StoreIndirectImm {
-        /// The destination pointer
-        dest_ptr: MaybeResolved<Loc>,
-        /// The source value
-        src: u128,
-    },
-    /// Emits a trap
-    Trap {
-        /// The kind of trap
-        kind: Trap,
-    },
-    /// Emits a Barrier (Runtime Fence)
-    Barrier(AccessClass),
-    /// Performs a binary operation, with an immediate as the rhs
-    BinaryOpImm {
-        /// The destination
-        dest: MaybeResolved<Loc>,
-        /// The first operand
-        src: MaybeResolved<Loc>,
-        /// The second operand (an immediate)
-        val: u128,
-        /// The Operation performed
-        op: BinaryOp,
-    },
-    /// Performs a binary operation with unknown values on both sides
-    BinaryOp {
-        /// The destination
-        dest: MaybeResolved<Loc>,
-        /// The first operand
-        src1: MaybeResolved<Loc>,
-        /// The second operand
-        src2: MaybeResolved<Loc>,
-        /// The Operation performed
-        op: BinaryOp,
-    },
-    /// Performs a unary operation
-    UnaryOp {
-        /// The operand
-        dest: MaybeResolved<Loc>,
-        /// The operation performed
-        op: UnaryOp,
-    },
-    /// Calls the given String by address
-    CallSym(String, String),
-    /// Tailcalls the given String by address
-    TailcallSym(String),
-    /// Cleans up the frame and does a return
-    Return,
-    /// Loads the address of a symbol into the given location
-    LoadSym {
-        /// The location in which to place the symbol
-        loc: MaybeResolved<Loc>,
-        /// The symbol to resolve
-        sym: String,
-    },
-
-    /// A Label
-    Label(String),
-    /// Unconditional Branch
-    UnconditionalBranch(String),
-    /// A Load operation that reads from a pointer
-    LoadIndirect {
-        /// The (immediate) destination location
-        dest: MaybeResolved<Loc>,
-        /// The location with the pointer to load from
-        src_ptr: MaybeResolved<Loc>,
-        /// The Access Class
-        cl: AccessClass,
-    },
-    /// Zero-extends (or truncates) from src to dest
-    ZeroExtend {
-        /// Destination register
-        dest: MaybeResolved<Loc>,
-        /// Source register
-        src: MaybeResolved<Loc>,
-        /// Width of the destination value
-        new_width: u16,
-        /// Wdith of the source value
-        old_width: u16,
-    },
-    /// Conditional Branch
-    Branch {
-        /// Target upon successful condition check
-        targ: String,
-        /// Condition for branching
-        cond: xlang::ir::BranchCondition,
-        /// Value to test
-        val: MaybeResolved<Loc>,
-    },
-}
-
-impl<Loc> Default for MCInsn<Loc> {
-    fn default() -> Self {
-        Self::Null
-    }
-}
-
-/// A location (register) allocated by the backend
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub struct Location {
-    id: u32,
-    has_addr: bool,
-    ty: Type,
-    size: u64,
-    align: u64,
-}
-
-impl Location {
-    /// The id of the `Location`
-    pub const fn id(&self) -> u32 {
-        self.id
-    }
-
-    /// Whether or not the location needs/has an address
-    pub const fn has_addr(&self) -> bool {
-        self.has_addr
-    }
-
-    /// Yields the type of the `Location`
-    pub const fn type_of(&self) -> &Type {
-        &self.ty
-    }
-
-    /// Yields the size of the `Location`
-    pub const fn size_of(&self) -> u64 {
-        self.size
-    }
-
-    /// Yields the alignment requirement of the `Location`
-    pub const fn align_of(&self) -> u64 {
-        self.align
-    }
-}
-
-impl ValLocation for Location {
-    fn addressible(&self) -> bool {
-        self.has_addr
-    }
-
-    fn unassigned(n: usize) -> Self {
-        Self {
-            id: u32::try_from(n).unwrap(),
-            has_addr: false,
-            ty: Type::Null,
-            size: 0,
-            align: 1,
-        }
-    }
-}
-
-/// A value location that is either unresolved or a resolved machine-specific location (such as a register or stack memory)
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum MaybeResolved<Loc> {
-    /// An unresolved location that is assigned during output
-    Unresolved(Location),
-    /// A known, resolved, location
-    Resolved(Type, Loc),
-}
-
-impl<Loc: ValLocation> ValLocation for MaybeResolved<Loc> {
-    fn addressible(&self) -> bool {
-        match self {
-            Self::Unresolved(loc) => loc.has_addr,
-            Self::Resolved(_, loc) => loc.addressible(),
-        }
-    }
-
-    fn unassigned(n: usize) -> Self {
-        Self::Unresolved(Location::unassigned(n))
-    }
-}
-
-/// An Adaptor to a calling convention that yields [`MaybeResolved`] as the location type
-pub struct CallConvAdaptor<C>(C);
-
-impl<C: CallingConvention> CallingConvention for CallConvAdaptor<C> {
-    type Loc = MaybeResolved<C::Loc>;
-
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        self.0
-            .pass_return_place(ty)
-            .map(|loc| MaybeResolved::Resolved(ty.clone(), loc))
-    }
-
-    fn find_param(
-        &self,
-        fnty: &xlang::ir::FnType,
-        real: &xlang::ir::FnType,
-        param: u32,
-        infn: bool,
-    ) -> Self::Loc {
-        MaybeResolved::Resolved(
-            real.params[usize::try_from(param).unwrap()].clone(),
-            self.0.find_param(fnty, real, param, infn),
-        )
-    }
-
-    fn find_return_val(&self, fnty: &xlang::ir::FnType) -> Self::Loc {
-        MaybeResolved::Resolved(fnty.ret.clone(), self.0.find_return_val(fnty))
-    }
-}
-
-/// Raw codegen for generating MCIR from XIR
-pub struct MCFunctionCodegen<F: MachineFeatures> {
-    inner: F,
-    next_loc_id: u32,
-    tys: Rc<TypeInformation>,
-    mc_insns: Vec<MCInsn<F::Loc>>,
-    callconv: CallConvAdaptor<F::CallConv>,
-    strings: Rc<RefCell<StringMap>>,
-    fn_name: String,
-    fnty: FnType,
-}
-
-#[allow(unused_variables)]
-impl<F: MachineFeatures> FunctionRawCodegen for MCFunctionCodegen<F> {
-    type Loc = MaybeResolved<F::Loc>;
-
-    type CallConv = CallConvAdaptor<F::CallConv>;
-
-    fn write_trap(&mut self, trap: crate::expr::Trap) {
-        self.mc_insns.push(MCInsn::Trap { kind: trap });
-    }
-
-    fn write_barrier(&mut self, acc: xlang::ir::AccessClass) {
-        self.mc_insns.push(MCInsn::Barrier(acc));
-    }
-
-    fn write_int_binary_imm(
-        &mut self,
-        dest: Self::Loc,
-        a: Self::Loc,
-        b: u128,
-        _: &Type,
-        op: xlang::ir::BinaryOp,
-    ) {
-        self.mc_insns.push(MCInsn::BinaryOpImm {
-            dest,
-            src: a,
-            val: b,
-            op,
-        });
-    }
-
-    fn write_int_binary(
-        &mut self,
-        dest: Self::Loc,
-        src1: Self::Loc,
-        src2: Self::Loc,
-        _: &Type,
-        op: xlang::ir::BinaryOp,
-    ) {
-        self.mc_insns.push(MCInsn::BinaryOp {
-            dest,
-            src1,
-            src2,
-            op,
-        });
-    }
-
-    fn write_unary(&mut self, val: Self::Loc, _: &Type, op: xlang::ir::UnaryOp) {
-        self.mc_insns.push(MCInsn::UnaryOp { dest: val, op });
-    }
-
-    fn move_val(&mut self, src: Self::Loc, dest: Self::Loc) {
-        self.mc_insns.push(MCInsn::Mov { dest, src });
-    }
-
-    fn move_imm(&mut self, src: u128, dest: Self::Loc, ty: &Type) {
-        self.mc_insns.push(MCInsn::MovImm { dest, src });
-    }
-
-    fn store_indirect_imm(&mut self, src: xlang::ir::Value, ptr: Self::Loc) {
-        match src {
-            xlang::ir::Value::Integer { ty, val } => self.mc_insns.push(MCInsn::StoreIndirectImm {
-                dest_ptr: ptr,
-                src: val,
-            }),
-            _ => todo!(),
-        }
-    }
-
-    fn load_val(&mut self, lvalue: Self::Loc, loc: Self::Loc) {
-        self.mc_insns.push(MCInsn::LoadIndirect {
-            dest: loc,
-            src_ptr: lvalue,
-            cl: AccessClass::Normal,
-        })
-    }
-
-    fn store_indirect(&mut self, lvalue: Self::Loc, loc: Self::Loc, _: &Type) {
-        self.mc_insns.push(MCInsn::StoreIndirect {
-            dest_ptr: lvalue,
-            src: loc,
-            cl: AccessClass::Normal,
-        })
-    }
-
-    fn get_callconv(&self) -> &Self::CallConv {
-        &self.callconv
-    }
-
-    fn native_int_size(&self) -> u16 {
-        self.inner.native_int_size()
-    }
-
-    fn native_float_size(&self) -> xlang::abi::option::Option<u16> {
-        self.inner.native_float_size().into()
-    }
-
-    fn write_intrinsic(
-        &mut self,
-        name: xlang::abi::string::StringView,
-        params: xlang::vec::Vec<crate::expr::VStackValue<Self::Loc>>,
-    ) -> crate::expr::VStackValue<Self::Loc> {
-        todo!()
-    }
-
-    fn write_target(&mut self, target: u32) {
-        let targ = format!("{}._T{}", self.fn_name, target);
-        self.mc_insns.push(MCInsn::Label(targ));
-    }
-
-    fn call_direct(&mut self, path: &xlang::ir::Path, realty: &xlang::ir::FnType) {
-        let addr = match &*path.components {
-            [PathComponent::Text(a)] | [PathComponent::Root, PathComponent::Text(a)] => {
-                a.to_string()
-            }
-            [PathComponent::Root, rest @ ..] | [rest @ ..] => self.inner.mangle(rest),
-        };
-        self.mc_insns
-            .push(MCInsn::CallSym(realty.tag.to_string(), addr))
-    }
-
-    fn call_indirect(&mut self, value: Self::Loc) {
-        todo!()
-    }
-
-    fn call_absolute(&mut self, addr: u128, realty: &xlang::ir::FnType) {
-        todo!()
-    }
-
-    fn tailcall_direct(&mut self, path: &xlang::ir::Path, realty: &xlang::ir::FnType) {
-        let addr = match &*path.components {
-            [PathComponent::Text(a)] | [PathComponent::Root, PathComponent::Text(a)] => {
-                a.clone().to_string()
-            }
-            [PathComponent::Root, rest @ ..] | [rest @ ..] => self.inner.mangle(rest),
-        };
-        if self.callconv.can_tail(realty, &self.fnty) {
-            self.mc_insns.push(MCInsn::TailcallSym(addr))
-        } else {
-            self.mc_insns
-                .push(MCInsn::CallSym(realty.tag.to_string(), addr));
-            self.mc_insns.push(MCInsn::Return);
-        }
-    }
-
-    fn tailcall_indirect(&mut self, value: Self::Loc, realty: &xlang::ir::FnType) {
-        todo!("tailcall_indirect")
-    }
-
-    fn leave_function(&mut self) {
-        self.mc_insns.push(MCInsn::Return)
-    }
-
-    fn branch(&mut self, target: u32, cond: xlang::ir::BranchCondition, val: Self::Loc) {
-        let targ = format!("{}._T{}", self.fn_name, target);
-        self.mc_insns.push(MCInsn::Branch { targ, cond, val });
-    }
-
-    fn branch_compare(
-        &mut self,
-        target: u32,
-        condition: xlang::ir::BranchCondition,
-        v1: crate::expr::VStackValue<Self::Loc>,
-        v2: crate::expr::VStackValue<Self::Loc>,
-    ) {
-        todo!()
-    }
-
-    fn branch_unconditional(&mut self, target: u32) {
-        let targ = format!("{}._T{}", self.fn_name, target);
-        self.mc_insns.push(MCInsn::UnconditionalBranch(targ));
-    }
-
-    fn branch_indirect(&mut self, target: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_global_address(&mut self, path: &xlang::ir::Path, loc: Self::Loc) {
-        let sym = match &*path.components {
-            [xlang::ir::PathComponent::Root, xlang::ir::PathComponent::Text(text)]
-            | [xlang::ir::PathComponent::Text(text)] => text.to_string(),
-            [xlang::ir::PathComponent::Root, rest @ ..] | [rest @ ..] => self.inner.mangle(rest),
-        };
-
-        self.mc_insns.push(MCInsn::LoadSym { loc, sym });
-    }
-
-    fn compute_label_address(&mut self, target: u32, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_parameter_address(&mut self, param: u32, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_local_address(&mut self, inloc: Self::Loc, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn compute_string_address(
-        &mut self,
-        enc: crate::str::Encoding,
-        bytes: xlang::vec::Vec<u8>,
-        loc: Self::Loc,
-    ) {
-        let sym = self
-            .strings
-            .borrow_mut()
-            .get_string_symbol(bytes, enc)
-            .to_string();
-
-        self.mc_insns.push(MCInsn::LoadSym { loc, sym });
-    }
-
-    fn free(&mut self, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn clobber(&mut self, loc: Self::Loc) {
-        todo!()
-    }
-
-    fn allocate(&mut self, ty: &Type, needs_addr: bool) -> Self::Loc {
-        let id = self.next_loc_id;
-        self.next_loc_id += 1;
-        let size = self.tys.type_size(ty).unwrap();
-        let align = self.tys.type_align(ty).unwrap();
-        MaybeResolved::Unresolved(Location {
-            id,
-            size,
-            align,
-            has_addr: needs_addr,
-            ty: ty.clone(),
-        })
-    }
-
-    fn allocate_lvalue(&mut self, needs_addr: bool) -> Self::Loc {
-        let size = self.tys.pointer_size(&Type::Void, PointerKind::Default);
-        let align = self.tys.pointer_align(&Type::Void, PointerKind::Default);
-
-        let ty = Type::Pointer(xlang::ir::PointerType {
-            inner: xlang::abi::boxed::Box::new(Type::Void),
-            ..Default::default()
-        });
-
-        let id = self.next_loc_id;
-        self.next_loc_id += 1;
-        MaybeResolved::Unresolved(Location {
-            id,
-            size,
-            align,
-            has_addr: needs_addr,
-            ty,
-        })
-    }
-
-    fn prepare_call_frame(&mut self, callty: &xlang::ir::FnType, realty: &xlang::ir::FnType) {}
-
-    fn lockfree_use_libatomic(&mut self, size: u64) -> bool {
-        todo!()
-    }
-
-    fn lockfree_cmpxchg_use_libatomic(&mut self, size: u64) -> bool {
-        todo!()
-    }
-
-    fn has_wait_free_compound(&mut self, op: xlang::ir::BinaryOp, size: u64) -> bool {
-        todo!()
-    }
-
-    fn has_wait_free_compound_fetch(&mut self, op: xlang::ir::BinaryOp, size: u64) -> bool {
-        todo!()
-    }
-
-    fn compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: xlang::ir::AccessClass,
-    ) {
-        todo!()
-    }
-
-    fn weak_compare_exchange(
-        &mut self,
-        dest: Self::Loc,
-        ctrl: Self::Loc,
-        val: Self::Loc,
-        ty: &Type,
-        ord: xlang::ir::AccessClass,
-    ) {
-        todo!()
-    }
-
-    fn write_asm(
-        &mut self,
-        _: &xlang::ir::AsmExpr,
-        _: xlang::vec::Vec<VStackValue<MaybeResolved<<F as MachineFeatures>::Loc>>>,
-    ) -> xlang::vec::Vec<Self::Loc> {
-        todo!()
-    }
-
-    fn write_scalar_convert(
-        &mut self,
-        target_ty: xlang::ir::ScalarType,
-        incoming_ty: xlang::ir::ScalarType,
-        new_loc: Self::Loc,
-        old_loc: Self::Loc,
-    ) {
-        match (target_ty, incoming_ty) {
-            (
-                ScalarType {
-                    header:
-                        ScalarTypeHeader {
-                            bitsize: new_width,
-                            vectorsize: XLangNone,
-                            ..
-                        },
-                    kind: ScalarTypeKind::Integer { signed, .. },
-                },
-                ScalarType {
-                    header:
-                        ScalarTypeHeader {
-                            bitsize: old_width,
-                            vectorsize: XLangNone,
-                            ..
-                        },
-                    kind: ScalarTypeKind::Integer { signed: false, .. },
-                },
-            ) => {
-                self.mc_insns.push(MCInsn::ZeroExtend {
-                    dest: new_loc,
-                    src: old_loc,
-                    new_width,
-                    old_width,
-                });
-            }
-            _ => todo!(),
-        }
-    }
-}
-
-/// Trait for types that can write [`MCInsn`]s to an [`InsnWrite`]
-pub trait MCWriter {
-    /// The [`MachineFeatures`] type
-    type Features: MachineFeatures;
-    /// The type used to indicate what locations were clobbered at what instruction.
-    type Clobbers;
-    /// Resolves locations in-place for the given machine code
-    fn resolve_locations(
-        &self,
-        insns: &mut [MCInsn<<Self::Features as MachineFeatures>::Loc>],
-        callconv: &<Self::Features as MachineFeatures>::CallConv,
-    ) -> Self::Clobbers;
-    /// Writes the machine code to the given stream
-    fn write_machine_code<I: InsnWrite, F: FnMut(String, u64)>(
-        &self,
-        insns: &[MCInsn<<Self::Features as MachineFeatures>::Loc>],
-        clobbers: Self::Clobbers,
-        tys: Rc<TypeInformation>,
-        out: &mut I,
-        sym_accepter: F,
-    ) -> std::io::Result<()>;
-    /// Obtains the calling convention for the given `realty`
-    fn get_call_conv(
-        &self,
-        realty: &FnType,
-        targ: &'static TargetProperties<'static>,
-        features: Span<StringView>,
-        ty_info: Rc<TypeInformation>,
-    ) -> <Self::Features as MachineFeatures>::CallConv;
-    /// Obtains the features from the target
-    fn get_features(
-        &self,
-        properties: &'static TargetProperties<'static>,
-        features: Span<StringView>,
-    ) -> Self::Features;
-
-    /// Checks if the given target name matches
-    fn target_matches(&self, name: &str) -> bool;
-}
-
-#[allow(dead_code)] // These will be used more properly later
-enum SectionSpec {
-    GlobalSection,
-    UniqueSection,
-    Comdat(String),
-    Section(String),
-}
-
-struct MCFunctionDecl<W: MCWriter> {
-    linkage: Linkage,
-    body: Option<(SectionSpec, FunctionCodegen<MCFunctionCodegen<W::Features>>)>,
-}
-
-struct MCStaticDef {
-    section: SectionSpec,
-    init: xlang::ir::Value,
-    space: u64,
-    align: u64,
-    specifier: xlang::ir::StaticSpecifier,
-}
-
-struct MCStaticDecl {
-    linkage: Linkage,
-    init: Option<MCStaticDef>,
-}
-
-/// Backend that generates MCIR from XIR then writes to a binary file
-pub struct MCBackend<W: MCWriter> {
-    properties: Option<&'static TargetProperties<'static>>,
-    feature: Span<'static, StringView<'static>>,
-    strings: Rc<RefCell<StringMap>>,
-    writer: W,
-    functions: HashMap<String, MCFunctionDecl<W>>,
-    statics: HashMap<String, MCStaticDecl>,
-    tys: Option<Rc<TypeInformation>>,
-}
-
-impl<W: MCWriter> MCBackend<W> {
-    /// Creates a new backend writer
-    pub fn new(x: W) -> Self {
-        Self {
-            properties: None,
-            feature: Span::empty(),
-            strings: Rc::new(RefCell::new(StringMap::new())),
-            writer: x,
-            functions: HashMap::new(),
-            statics: HashMap::new(),
-            tys: None,
-        }
-    }
-}
-
-impl<W: MCWriter> XLangPlugin for MCBackend<W> {
-    fn accept_ir(
-        &mut self,
-        _: &mut xlang::ir::File,
-    ) -> xlang::abi::result::Result<(), xlang::plugin::Error> {
-        unimplemented!()
-    }
-
-    fn set_target(&mut self, targ: &'static TargetProperties<'static>) {
-        self.properties = Some(targ);
-    }
-}
-
-impl<W: MCWriter> XLangCodegen for MCBackend<W> {
-    fn target_matches(&self, x: StringView) -> bool {
-        self.writer.target_matches(&x)
-    }
-
-    fn write_output(
-        &mut self,
-        x: xlang::abi::traits::DynMut<dyn xlang::abi::io::Write>,
-        mode: xlang::plugin::OutputMode,
-    ) -> xlang::abi::io::Result<()> {
-        assert!(matches!(mode, OutputMode::Obj));
-        let mut syms = Vec::new();
-        let props = self.properties.unwrap();
-        let binfmt = binfmt::format_by_name(&props.link.obj_binfmt).unwrap();
-
-        let features = self.writer.get_features(props, self.feature);
-
-        let mut binfile = binfmt.create_file(FileType::Relocatable);
-
-        let mut rodata = Section {
-            name: String::from(".rodata"),
-            align: 1024,
-            ty: binfmt::fmt::SectionType::ProgBits,
-            flags: Some(binfmt::fmt::SectionFlag::Alloc.into()),
-            ..Default::default()
-        };
-
-        let mut text = Section {
-            name: String::from(".text"),
-            align: 1024,
-            ty: binfmt::fmt::SectionType::ProgBits,
-            flags: Some(binfmt::fmt::SectionFlag::Alloc | binfmt::fmt::SectionFlag::Executable),
-            ..Default::default()
-        };
-        let mut data = Section {
-            name: String::from(".data"),
-            align: 1024,
-            ty: binfmt::fmt::SectionType::NoBits,
-            flags: Some(binfmt::fmt::SectionFlag::Alloc | binfmt::fmt::SectionFlag::Writable),
-            ..Default::default()
-        };
-        let mut bss = Section {
-            name: String::from(".bss"),
-            align: 1024,
-            ty: binfmt::fmt::SectionType::NoBits,
-            flags: Some(binfmt::fmt::SectionFlag::Alloc | binfmt::fmt::SectionFlag::Writable),
-            ..Default::default()
-        };
-
-        for (enc, name, content) in self.strings.borrow().symbols() {
-            let st = Symbol::new(
-                name.to_string(),
-                Some(0),
-                Some(rodata.offset() as u128),
-                binfmt::sym::SymbolType::Object,
-                binfmt::sym::SymbolKind::Local,
-            );
-            let bytes = enc.encode_utf8(content);
-            try_!(rodata.write_all(&bytes).map_err(Into::into));
-            syms.push(st);
-        }
-
-        for Pair(name, func) in core::mem::take(&mut self.functions) {
-            let symty = match func.linkage {
-                Linkage::External => binfmt::sym::SymbolKind::Global,
-                Linkage::Internal | Linkage::Constant => binfmt::sym::SymbolKind::Local,
-                Linkage::Weak => binfmt::sym::SymbolKind::Weak,
-            };
-
-            if let Some((_, func)) = func.body {
-                let mut inner = func.into_inner();
-                let cc = &inner.callconv;
-                let clobbers = self.writer.resolve_locations(&mut inner.mc_insns, &cc.0);
-
-                let sym = Symbol::new(
-                    name,
-                    Some(1),
-                    Some(text.offset() as u128),
-                    binfmt::sym::SymbolType::Function,
-                    symty,
-                );
-
-                try_!(self
-                    .writer
-                    .write_machine_code(
-                        &inner.mc_insns,
-                        clobbers,
-                        self.tys.clone().unwrap(),
-                        &mut text,
-                        |label, offset| {
-                            syms.push(Symbol::new(
-                                label,
-                                Some(1),
-                                Some(offset as u128),
-                                binfmt::sym::SymbolType::Function,
-                                binfmt::sym::SymbolKind::Local,
-                            ))
-                        }
-                    )
-                    .map_err(Into::into));
-
-                syms.push(sym);
-            } else if func.linkage == Linkage::Weak {
-                let sym = Symbol::new(name, None, None, binfmt::sym::SymbolType::Function, symty);
-
-                syms.push(sym);
-            }
-        }
-
-        for Pair(name, decl) in core::mem::take(&mut self.statics) {
-            let symty = match decl.linkage {
-                Linkage::External => binfmt::sym::SymbolKind::Global,
-                Linkage::Internal | Linkage::Constant => binfmt::sym::SymbolKind::Local,
-                Linkage::Weak => binfmt::sym::SymbolKind::Weak,
-            };
-
-            if let Some(init) = decl.init {
-                let (secno, section) = match init.section {
-                    SectionSpec::GlobalSection => {
-                        if let xlang::ir::Value::Uninitialized(_) = init.init {
-                            (3, &mut bss)
-                        } else if init
-                            .specifier
-                            .contains(xlang::ir::StaticSpecifier::IMMUTABLE)
-                        {
-                            (0, &mut rodata)
-                        } else {
-                            (2, &mut data)
-                        }
-                    }
-                    _ => todo!(),
-                };
-
-                section.align = section.align.max(init.align as usize);
-                let total_len = section.content.len() + section.tail_size;
-                let size = init.space as usize;
-                if (total_len as u64 & (init.align - 1)) != 0 {
-                    section.tail_size +=
-                        (init.align - (total_len as u64 & (init.align - 1))) as usize;
-                }
-                let sym = Symbol::new(
-                    name,
-                    Some(secno),
-                    Some(section.offset() as u128),
-                    binfmt::sym::SymbolType::Object,
-                    symty,
-                );
-
-                match init.init {
-                    xlang::ir::Value::Invalid(_) | xlang::ir::Value::Uninitialized(_) => {
-                        section.tail_size += size;
-                    }
-                    xlang::ir::Value::GenericParameter(_) => panic!("late generic"),
-                    xlang::ir::Value::Integer { val, .. } => {
-                        let val = u128_to_targ_bytes(val, props);
-
-                        let leading = val.len().min(size);
-
-                        try_!(section.write_all(&val[..leading]).map_err(Into::into));
-                        if leading < size {
-                            try_!(section.write_zeroes(size - leading).map_err(Into::into));
-                        }
-                    }
-                    xlang::ir::Value::GlobalAddress { item, .. } => {
-                        let mangled_name = match &*item.components {
-                            [xlang::ir::PathComponent::Text(name)]
-                            | [xlang::ir::PathComponent::Root, xlang::ir::PathComponent::Text(name)] => {
-                                name.to_string()
-                            }
-                            [xlang::ir::PathComponent::Root, rest @ ..] | rest => {
-                                features.mangle(rest)
-                            }
-                        };
-
-                        try_!(section
-                            .write_addr(
-                                size * 8,
-                                arch_ops::traits::Address::Symbol {
-                                    name: mangled_name,
-                                    disp: 0
-                                },
-                                false
-                            )
-                            .map_err(Into::into));
-                    }
-                    xlang::ir::Value::ByteString { .. } => todo!("byte string"),
-                    xlang::ir::Value::String { .. } => todo!("string"),
-                    xlang::ir::Value::LabelAddress(_) => {
-                        panic!("Cannot use label_address in a global static")
-                    }
-                    xlang::ir::Value::Empty => unreachable!(),
-                }
-                syms.push(sym);
-            } else if decl.linkage == Linkage::Weak {
-                let sym = Symbol::new(name, None, None, binfmt::sym::SymbolType::Object, symty);
-
-                syms.push(sym);
-            }
-        }
-
-        let rodatano = binfile.add_section(rodata).unwrap();
-        let textno = binfile.add_section(text).unwrap();
-        let datano = binfile.add_section(data).unwrap();
-        let bssno = binfile.add_section(bss).unwrap();
-
-        if let StackAttributeControlStyle::GnuStack = props.link.stack_attribute_control {
-            let note_gnustack = Section {
-                name: String::from(".note.GNU-stack"),
-                align: 1024,
-                ty: binfmt::fmt::SectionType::NoBits,
-                flags: Some(binfmt::fmt::SectionFlags::default()),
-                ..Default::default()
-            };
-
-            binfile.add_section(note_gnustack).unwrap();
-        }
-
-        for mut sym in syms {
-            match sym.section_mut() {
-                Some(x @ 0) => *x = rodatano,
-                Some(x @ 1) => *x = textno,
-                Some(x @ 2) => *x = datano,
-                Some(x @ 3) => *x = bssno,
-                None => {}
-                Some(x) => panic!("Unexpected section number for symbol {}", x),
-            }
-
-            let insym = binfile.get_or_create_symbol(sym.name()).unwrap();
-
-            if sym.value().is_some() || insym.value().is_none() {
-                *insym = sym;
-            }
-        }
-
-        let mut adaptor = WriteAdapter::new(x);
-
-        try_!(binfmt
-            .write_file(&mut adaptor, &binfile)
-            .map_err(Into::into));
-
-        XLangOk(())
-    }
-}
diff --git a/xlang/xlang_backend/src/mc/callconv.rs b/xlang/xlang_backend/src/mc/callconv.rs
deleted file mode 100644
index 96fb2e31..00000000
--- a/xlang/xlang_backend/src/mc/callconv.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// use xlang::ir::FloatFormat;
-
-// pub enum TypeMode {
-//     Null,
-//     Memory,
-//     Integer,
-//     Float(FloatFormat),
-//     IntVector,
-//     FloatVector,
-//     Struct(Vec<(u64, TypeMode)>),
-//     Union(Vec<TypeMode>),
-//     ComplexFloat(FloatFormat),
-// }
-
-// pub trait CallConvTag {
-//     type Register: Clone + PartialEq + Hash;
-
-//     type CallMode: Clone + PartialEq + Hash;
-
-//     /// All modes available
-//     fn all_modes(&self) -> &[Self::CallMode];
-
-//     /// All registers available for a particular call mode
-//     fn param_registers_for_mode(&self, mode: Self::CallMode) -> &[Self::Register];
-
-//     /// Converts a [`TypeMode`] into the appropriate [`CallConvTag::CallMode`]
-//     fn call_mode(&self, ty_mode: &TypeMode) -> Self::CallMode;
-
-//     /// Maximum Size of values in the registers for the [`CallConvTag::CallMode`]
-//     fn register_width(&self, mode: Self::CallMode) -> u64;
-// }
diff --git a/xlang/xlang_backend/src/mc/regalloc.rs b/xlang/xlang_backend/src/mc/regalloc.rs
deleted file mode 100644
index 276af408..00000000
--- a/xlang/xlang_backend/src/mc/regalloc.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use core::hash::Hash;
-use std::num::NonZeroU64;
-
-/// A set of registers available for use by regalloc
-pub trait RegSet {
-    /// The register type to use
-    type Register: Clone + PartialEq + Hash;
-
-    /// All of the registers in the set
-    fn all_registers(&self) -> &[Self::Register];
-
-    /// The maximum size of values that can be stored in the register
-    fn max_size(&self) -> u64;
-
-    /// The maximum alignment of values that can be stored in the register.
-    ///
-    /// Typically, this is the same as [`RegSet::max_size`], and [`None`] means this value.
-    /// This may be smaller if the register is a synthetic one placed in memory and does not have the required alignment.
-    ///
-    /// Returns a power of 2 less than [`RegSet::max_size`]
-    fn max_align(&self) -> Option<NonZeroU64>;
-}
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 9c8296fa..820b1b75 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -1,20 +1,105 @@
 #![allow(missing_docs)]
+use core::cell::{Cell, RefCell};
+use std::panic::Location;
 use std::rc::Rc;
 
-use xlang::ir::*;
+use crate::expr::ValLocation;
+use crate::expr::*;
+use crate::mach::Machine;
+use crate::ty::TypeInformation;
+
+use arch_ops::traits::InsnWrite;
+use xlang::targets::properties::TargetProperties;
+
+use xlang::ir;
+
+use xlang::abi::{boxed::Box as XLangBox, collection::HashMap, vec::Vec};
+
+struct SharedCounter(Cell<u32>);
+
+impl SharedCounter {
+    const fn new() -> Self {
+        Self(Cell::new(0))
+    }
+    fn next(&self) -> u32 {
+        let val = self.0.get();
+        self.0.set(val + 1);
+
+        val
+    }
+}
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum SsaTerminator {
-    Fallthrough(u32, Vec<OpaqueLocation>),
+pub enum SsaInstruction {
     Jump(u32, Vec<OpaqueLocation>),
-    Exit(u16),
+    Fallthrough(u32, Vec<OpaqueLocation>),
+    Exit(Vec<OpaqueLocation>),
     Tailcall(CallTarget, Vec<OpaqueLocation>),
+    Trap(Trap),
+    LoadImmediate(OpaqueLocation, u128),
+}
+
+impl core::fmt::Display for SsaInstruction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SsaInstruction::Jump(val, stack) => {
+                f.write_fmt(format_args!("jump @{} [", val))?;
+                let mut sep = "";
+                for item in stack {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str("]")
+            }
+            SsaInstruction::Fallthrough(val, stack) => {
+                f.write_fmt(format_args!("fallthrough @{} [", val))?;
+                let mut sep = "";
+                for item in stack {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str("]")
+            }
+            SsaInstruction::Exit(estack) => {
+                f.write_fmt(format_args!("exit ["))?;
+                let mut sep = "";
+                for item in estack {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str("]")
+            }
+            SsaInstruction::Tailcall(targ, params) => {
+                f.write_fmt(format_args!("tailcall {}(", targ))?;
+                let mut sep = "";
+                for item in params {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str(")")
+            }
+            SsaInstruction::Trap(trap) => f.write_fmt(format_args!("trap {}", trap)),
+            SsaInstruction::LoadImmediate(dest, val) => {
+                f.write_fmt(format_args!("loadimm {}, {}", dest, val))
+            }
+        }
+    }
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct CallTarget {
     pub ptr: OpaquePtr,
-    pub real_ty: FnType,
+    pub real_ty: ir::FnType,
+}
+
+impl core::fmt::Display for CallTarget {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}: {}", self.ptr, self.real_ty))
+    }
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -23,8 +108,404 @@ pub enum OpaquePtr {
     Pointer(OpaqueLocation),
 }
 
+impl core::fmt::Display for OpaquePtr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OpaquePtr::Symbol(s) => f.write_str(s),
+            OpaquePtr::Pointer(ptr) => f.write_fmt(format_args!("[{}]", ptr)),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct OpaqueLocation {
-    pub ty: Rc<Type>,
+    pub ty: Rc<ir::Type>,
+    pub kind: ir::StackValueKind,
     pub num: u32,
+    has_addr: bool,
+}
+
+impl core::fmt::Display for OpaqueLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("%{}: ", self.num))?;
+        if self.kind == ir::StackValueKind::LValue {
+            f.write_str("lvalue ")?;
+        }
+        self.ty.fmt(f)
+    }
+}
+
+impl ValLocation for OpaqueLocation {
+    fn addressible(&self) -> bool {
+        self.has_addr
+    }
+}
+
+pub struct FunctionBuilder<M> {
+    tys: Rc<TypeInformation>,
+    sym_name: String,
+    mach: Rc<M>,
+    basic_blocks: Vec<BasicBlockBuilder<M>>,
+    target: &'static TargetProperties<'static>,
+    locals: Rc<Vec<OpaqueLocation>>,
+    loc_id_counter: Rc<SharedCounter>,
+    incoming_locations: HashMap<u32, Vec<OpaqueLocation>>,
+    incoming_count: Rc<HashMap<u32, usize>>,
+    fnty: Rc<ir::FnType>,
+}
+
+impl<M> FunctionBuilder<M> {
+    pub fn new(
+        sym_name: String,
+        mach: Rc<M>,
+        tys: Rc<TypeInformation>,
+        target: &'static TargetProperties<'static>,
+        fnty: Rc<ir::FnType>,
+    ) -> Self {
+        Self {
+            sym_name,
+            mach,
+            tys,
+            target,
+            basic_blocks: Vec::new(),
+            locals: Rc::new(Vec::new()),
+            loc_id_counter: Rc::new(SharedCounter::new()),
+            incoming_locations: HashMap::new(),
+            fnty,
+            incoming_count: Rc::new(HashMap::new()),
+        }
+    }
+}
+
+impl<M: Machine> FunctionBuilder<M> {
+    pub fn push_local(&mut self, ty: ir::Type) {
+        Rc::get_mut(&mut self.locals)
+            .expect("No basic blocks may have been pushed yet")
+            .push(OpaqueLocation {
+                ty: Rc::new(ty),
+                kind: ir::StackValueKind::RValue,
+                num: self.loc_id_counter.next(),
+                has_addr: true,
+            })
+    }
+
+    pub fn push_incoming(&mut self, id: u32, incoming: &Vec<ir::StackItem>) {
+        let incoming_count = Rc::get_mut(&mut self.incoming_count)
+            .expect("new_basic_block may not have been called yet");
+        incoming_count.insert(id, incoming.len());
+    }
+
+    pub fn new_basic_block(
+        &mut self,
+        id: u32,
+        incoming: &Vec<ir::StackItem>,
+    ) -> &mut BasicBlockBuilder<M> {
+        let mut vstack = Vec::new();
+        let mut incoming_locs = Vec::new();
+
+        for nloc in incoming {
+            let ty = nloc.ty.clone();
+            let loc = OpaqueLocation {
+                ty: Rc::new(ty.clone()),
+                kind: nloc.kind,
+                num: self.loc_id_counter.next(),
+                has_addr: false,
+            };
+
+            match nloc.kind {
+                ir::StackValueKind::LValue => {
+                    vstack.push(VStackValue::opaque_lvalue(ty, loc.clone()))
+                }
+                ir::StackValueKind::RValue => {
+                    vstack.push(VStackValue::opaque_value(ty, loc.clone()))
+                }
+            }
+            incoming_locs.push(loc);
+        }
+
+        self.incoming_locations.insert(id, incoming_locs);
+
+        let builder = BasicBlockBuilder {
+            id,
+            tys: self.tys.clone(),
+            mach: self.mach.clone(),
+            insns: Vec::new(),
+            target: self.target,
+            locals: self.locals.clone(),
+            vstack,
+            incoming_count: self.incoming_count.clone(),
+            loc_id_counter: self.loc_id_counter.clone(),
+        };
+
+        self.basic_blocks.push_mut(builder)
+    }
+
+    pub fn write<W: InsnWrite, F: FnMut(String, u128)>(
+        &mut self,
+        out: &mut W,
+        mut sym_accepter: F,
+    ) -> std::io::Result<()> {
+        let mut assigns = self.mach.new_assignments();
+        let mut block_clobbers = vec![];
+        for bb in &self.basic_blocks {
+            block_clobbers.push(self.mach.assign_locations(
+                &mut assigns,
+                &bb.insns,
+                self.incoming_locations.get(&bb.id).unwrap(),
+                bb.id,
+            ));
+        }
+
+        self.mach.codegen_prologue(&assigns, out)?;
+        for (bb, block_clobbers) in self.basic_blocks.iter().zip(block_clobbers) {
+            let symbol = format!("{}._B{}", self.sym_name, bb.id);
+            self.mach.codegen_block(
+                &assigns,
+                &bb.insns,
+                block_clobbers,
+                out,
+                |id| format!("{}._B{}", self.sym_name, id),
+                bb.id,
+            )?;
+        }
+        Ok(())
+    }
+}
+
+impl<M> core::fmt::Display for FunctionBuilder<M> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("{\n")?;
+        for (i, loc) in self.locals.iter().enumerate() {
+            f.write_fmt(format_args!("  local _{}: {};\n", i, loc.ty))?;
+        }
+        for bb in &self.basic_blocks {
+            bb.fmt(f)?;
+        }
+        f.write_str("}\n")?;
+        Ok(())
+    }
+}
+
+pub struct BasicBlockBuilder<M> {
+    id: u32,
+    tys: Rc<TypeInformation>,
+    mach: Rc<M>,
+    insns: Vec<SsaInstruction>,
+    target: &'static TargetProperties<'static>,
+    locals: Rc<Vec<OpaqueLocation>>,
+    vstack: Vec<VStackValue<OpaqueLocation>>,
+    incoming_count: Rc<HashMap<u32, usize>>,
+    loc_id_counter: Rc<SharedCounter>,
+}
+
+impl<M: Machine> BasicBlockBuilder<M> {
+    pub fn move_into(&mut self, val: VStackValue<OpaqueLocation>, loc: OpaqueLocation) {
+        match val {
+            VStackValue::Constant(val) => match val {
+                ir::Value::Invalid(_) => self.insns.push(SsaInstruction::Trap(Trap::Unreachable)),
+                ir::Value::Uninitialized(_) => {}
+                ir::Value::GenericParameter(_) => panic!("Cannot handle generics this late"),
+                ir::Value::Integer { val, .. } => {
+                    self.insns.push(SsaInstruction::LoadImmediate(loc, val))
+                }
+                ir::Value::GlobalAddress { ty, item } => todo!(),
+                ir::Value::ByteString { content } => todo!(),
+                ir::Value::String { encoding, utf8, ty } => todo!(),
+                ir::Value::LabelAddress(_) => todo!(),
+                ir::Value::Empty => panic!("Empty IR value"),
+            },
+            VStackValue::LValue(_, _) => todo!(),
+            VStackValue::Pointer(_, _) => todo!(),
+            VStackValue::OpaqueScalar(_, _) => todo!(),
+            VStackValue::AggregatePieced(_, _) => todo!(),
+            VStackValue::OpaqueAggregate(_, _) => todo!(),
+            VStackValue::CompareResult(_, _) => todo!(),
+            VStackValue::Trapped => todo!(),
+            VStackValue::ArrayRepeat(_, _) => todo!(),
+        }
+    }
+
+    pub fn push(&mut self, val: VStackValue<OpaqueLocation>) {
+        self.vstack.push(val);
+    }
+
+    pub fn pop(&mut self) -> VStackValue<OpaqueLocation> {
+        self.vstack
+            .pop()
+            .expect("BasicBlockBuilder::pop called with an empty stack")
+    }
+
+    pub fn pop_values_static<const N: usize>(&mut self) -> [VStackValue<OpaqueLocation>; N] {
+        use core::mem::MaybeUninit;
+        let mut val = MaybeUninit::<[_; N]>::uninit();
+        let mut ptr = val.as_mut_ptr().cast::<VStackValue<OpaqueLocation>>();
+
+        for val in self.vstack.drain_back(N) {
+            unsafe { ptr.write(val) };
+            ptr = unsafe { ptr.add(1) };
+        }
+        // SAFETY: We just initialized all `N` elements
+        unsafe { val.assume_init() }
+    }
+
+    pub fn pop_values(&mut self, n: usize) -> Vec<VStackValue<OpaqueLocation>> {
+        self.vstack.split_off_back(n)
+    }
+    pub fn pop_opaque(&mut self, n: usize) -> Vec<OpaqueLocation> {
+        let mut vstack = core::mem::take(&mut self.vstack);
+
+        let ret = vstack
+            .drain_back(n)
+            .map(|val| self.make_opaque(val))
+            .collect();
+        self.vstack = vstack;
+        ret
+    }
+
+    pub fn make_opaque(&mut self, val: VStackValue<OpaqueLocation>) -> OpaqueLocation {
+        if let Some(loc) = val.opaque_location() {
+            loc.clone()
+        } else {
+            let loc = match &val {
+                VStackValue::LValue(ty, _) => OpaqueLocation {
+                    ty: Rc::new(ty.clone()),
+                    kind: ir::StackValueKind::LValue,
+                    num: self.loc_id_counter.next(),
+                    has_addr: false,
+                },
+                val => OpaqueLocation {
+                    ty: Rc::new(val.value_type()),
+                    kind: ir::StackValueKind::RValue,
+                    num: self.loc_id_counter.next(),
+                    has_addr: false,
+                },
+            };
+
+            self.move_into(val, loc.clone());
+            loc
+        }
+    }
+
+    pub fn write_call(
+        &mut self,
+        targ: VStackValue<OpaqueLocation>,
+        params: Vec<VStackValue<OpaqueLocation>>,
+        next: Option<ir::JumpTarget>,
+    ) {
+        match targ {
+            VStackValue::Constant(ir::Value::GlobalAddress { ty, item }) => {
+                let real_ty = match ty {
+                    ir::Type::FnType(fnty) => XLangBox::into_inner(fnty),
+                    ty => panic!("Cannot call a global constant of type {}", ty),
+                };
+
+                let params = params
+                    .into_iter()
+                    .map(|val| self.make_opaque(val))
+                    .collect::<Vec<_>>();
+
+                let sym = match &*item.components {
+                    [ir::PathComponent::Text(name)]
+                    | [ir::PathComponent::Root, ir::PathComponent::Text(name)] => name.to_string(),
+                    [ir::PathComponent::Root, rest @ ..] | [rest @ ..] => self.mach.mangle(rest),
+                };
+
+                if let Some(next) = next {
+                    todo!("Call with next")
+                } else {
+                    self.insns.push(SsaInstruction::Tailcall(
+                        CallTarget {
+                            ptr: OpaquePtr::Symbol(sym),
+                            real_ty,
+                        },
+                        params,
+                    ));
+                }
+            }
+            VStackValue::Constant(val) => todo!("{}", val),
+            VStackValue::LValue(_, _) => todo!(),
+            VStackValue::Pointer(_, _) => todo!(),
+            VStackValue::OpaqueScalar(_, _) => todo!(),
+            VStackValue::AggregatePieced(_, _) => todo!(),
+            VStackValue::OpaqueAggregate(_, _) => todo!(),
+            VStackValue::CompareResult(_, _) => todo!(),
+            VStackValue::Trapped => todo!(),
+            VStackValue::ArrayRepeat(_, _) => todo!(),
+        }
+    }
+
+    pub fn write_expr(&mut self, expr: &ir::Expr) {
+        match expr {
+            ir::Expr::Sequence(_) => todo!("sequence"),
+            ir::Expr::Const(val) => {
+                self.push(VStackValue::Constant(val.clone()));
+            }
+            ir::Expr::BinaryOp(_, _) => todo!("binary op"),
+            ir::Expr::UnaryOp(_, _) => todo!("unary op"),
+            ir::Expr::Convert(_, _) => todo!("convert"),
+            ir::Expr::Derive(_, _) => todo!("derive"),
+            ir::Expr::Local(_) => todo!("local"),
+            ir::Expr::Pop(_) => todo!("pop"),
+            ir::Expr::Dup(_) => todo!("dup"),
+            ir::Expr::Pivot(_, _) => todo!("pivot"),
+            ir::Expr::Aggregate(_) => todo!("aggregate"),
+            ir::Expr::Member(_) => todo!("member"),
+            ir::Expr::MemberIndirect(_) => todo!("member indirect"),
+            ir::Expr::Assign(_) => todo!("assign"),
+            ir::Expr::AsRValue(_) => todo!("as_rvalue"),
+            ir::Expr::CompoundAssign(_, _, _) => todo!("compound_assign"),
+            ir::Expr::FetchAssign(_, _, _) => todo!("fetch_assign"),
+            ir::Expr::LValueOp(_, _) => todo!("lvalue op"),
+            ir::Expr::UnaryLValue(_, _, _) => todo!("unary lvalue op"),
+            ir::Expr::Indirect => todo!("indirect"),
+            ir::Expr::AddrOf => todo!("addr_of"),
+            ir::Expr::Fence(_) => todo!("fence"),
+            ir::Expr::BeginStorage(_) => todo!("begin storage"),
+            ir::Expr::EndStorage(_) => todo!("end storage"),
+            ir::Expr::Select(_) => todo!("select"),
+        }
+    }
+
+    pub fn write_terminator(&mut self, term: &ir::Terminator) {
+        match term {
+            ir::Terminator::Jump(targ) => {
+                let vals = self.incoming_count[&targ.target];
+
+                let vals = self.pop_opaque(vals);
+
+                if targ.flags.contains(ir::JumpTargetFlags::FALLTHROUGH) {
+                    self.insns
+                        .push(SsaInstruction::Fallthrough(targ.target, vals));
+                } else {
+                    self.insns.push(SsaInstruction::Jump(targ.target, vals));
+                }
+            }
+            ir::Terminator::Branch(_, _, _) => todo!("branch"),
+            ir::Terminator::BranchIndirect => todo!("branch indirect"),
+            ir::Terminator::Call(_, _, _) => todo!("call"),
+            ir::Terminator::Tailcall(_, call_fnty) => {
+                let params_count = call_fnty.params.len();
+                let vals = self.pop_values(params_count);
+
+                let target = self.pop();
+
+                self.write_call(target, vals, None);
+            }
+            ir::Terminator::Exit(_) => todo!("exit"),
+            ir::Terminator::Asm(_) => todo!("asm"),
+            ir::Terminator::Switch(_) => todo!("switch"),
+            ir::Terminator::Unreachable => todo!("unreachable"),
+        }
+    }
+}
+
+impl<M> core::fmt::Display for BasicBlockBuilder<M> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("  target @{}:\n", self.id))?;
+
+        for insn in &self.insns {
+            f.write_fmt(format_args!("    {};\n", insn))?;
+        }
+        Ok(())
+    }
 }
diff --git a/xlang/xlang_backend/src/ty.rs b/xlang/xlang_backend/src/ty.rs
index 5e9ae22d..54402799 100644
--- a/xlang/xlang_backend/src/ty.rs
+++ b/xlang/xlang_backend/src/ty.rs
@@ -5,7 +5,7 @@ use xlang::{
         AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule, PointerKind,
         ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type, ValidRangeType, Value,
     },
-    prelude::v1::{format, Box, HashMap, Pair, Some as XLangSome},
+    prelude::v1::{HashMap, Pair, Some as XLangSome},
     targets::properties::TargetProperties,
 };
 
diff --git a/xlang/xlang_host/build.rs b/xlang/xlang_host/build.rs
index 9ce9f1cc..cfdd8f7a 100644
--- a/xlang/xlang_host/build.rs
+++ b/xlang/xlang_host/build.rs
@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
     let rustc = std::env::var_os("RUSTC").unwrap();
     let rustflags = std::env::var("CARGO_ENCODED_RUSTFLAGS")
         .ok()

From 54c02a9477a74d27310faba6a2269861bb6b69d0 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 31 Jan 2024 23:25:18 -0500
Subject: [PATCH 10/74] feat(x86-codegen): Implement support for Tailcall and
 Jump

---
 codegen-clever/src/lib.rs              |   5 +-
 codegen-w65/src/lib.rs                 |   5 +-
 codegen-x86/src/callconv.rs            | 491 ++++++++++++-------------
 codegen-x86/src/lib.rs                 | 273 +++++++++++++-
 lc-binutils                            |   2 +-
 lcrust/libraries/liballoc/src/alloc.rs |   5 +-
 xlang/xlang_backend/src/callconv.rs    | 428 +++++++++++++++++----
 xlang/xlang_backend/src/lib.rs         |  21 +-
 xlang/xlang_backend/src/mach.rs        |   9 +-
 xlang/xlang_backend/src/ssa.rs         |   9 +-
 xlang/xlang_backend/src/ty.rs          | 139 +++++--
 11 files changed, 993 insertions(+), 394 deletions(-)

diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index 9b351b27..fde692bd 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -3,7 +3,7 @@ use xlang::{
     abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
     targets::properties::TargetProperties,
 };
-use xlang_backend::{mach::Machine, SsaCodegenPlugin};
+use xlang_backend::{mach::Machine, ssa::OpaqueLocation, ty::TypeInformation, SsaCodegenPlugin};
 
 pub struct CleverAssignments {}
 
@@ -32,6 +32,8 @@ impl Machine for CleverMachine {
         insns: &[xlang_backend::ssa::SsaInstruction],
         incoming: &[xlang_backend::ssa::OpaqueLocation],
         which: u32,
+        incoming_set: &HashMap<u32, xlang::abi::vec::Vec<OpaqueLocation>>,
+        tys: &TypeInformation,
     ) -> Self::BlockClobbers {
         todo!()
     }
@@ -52,6 +54,7 @@ impl Machine for CleverMachine {
         out: &mut W,
         label_sym: F,
         which: u32,
+        tys: &TypeInformation,
     ) -> std::io::Result<()> {
         todo!()
     }
diff --git a/codegen-w65/src/lib.rs b/codegen-w65/src/lib.rs
index 1883dbd5..5fee482a 100644
--- a/codegen-w65/src/lib.rs
+++ b/codegen-w65/src/lib.rs
@@ -3,7 +3,7 @@ use xlang::{
     abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
     targets::properties::TargetProperties,
 };
-use xlang_backend::{mach::Machine, SsaCodegenPlugin};
+use xlang_backend::{mach::Machine, ssa::OpaqueLocation, ty::TypeInformation, SsaCodegenPlugin};
 
 pub struct W65Assignments {}
 
@@ -32,6 +32,8 @@ impl Machine for W65Machine {
         insns: &[xlang_backend::ssa::SsaInstruction],
         incoming: &[xlang_backend::ssa::OpaqueLocation],
         which: u32,
+        incoming_set: &HashMap<u32, xlang::abi::vec::Vec<OpaqueLocation>>,
+        tys: &TypeInformation,
     ) -> Self::BlockClobbers {
         todo!()
     }
@@ -52,6 +54,7 @@ impl Machine for W65Machine {
         out: &mut W,
         label_sym: F,
         which: u32,
+        tys: &TypeInformation,
     ) -> std::io::Result<()> {
         todo!()
     }
diff --git a/codegen-x86/src/callconv.rs b/codegen-x86/src/callconv.rs
index 1689fd6f..5ecdce9f 100644
--- a/codegen-x86/src/callconv.rs
+++ b/codegen-x86/src/callconv.rs
@@ -1,299 +1,280 @@
-use std::{collections::HashSet, rc::Rc};
-
-use arch_ops::x86::{features::X86Feature, X86Register, X86RegisterClass};
-
-use xlang::{
-    prelude::v1::{Pair, Some as XLangSome},
-    targets::properties::TargetProperties,
-};
-use xlang_backend::{callconv::CallingConvention, ty::TypeInformation};
-use xlang_struct::{
-    AggregateDefinition, FloatFormat, FnType, ScalarType, ScalarTypeHeader, ScalarTypeKind, Type,
+use arch_ops::x86::{X86Mode, X86Register, X86RegisterClass};
+use xlang_backend::callconv::{
+    CallConvInfo, ClassifyAggregateDisposition, ParamPosition, RegisterDisposition,
+    ReturnPointerBehaviour, StackedParamsOrder, Tag,
 };
 
-use crate::ValLocation;
+use xlang::abi::option::Some as XLangSome;
 
-#[allow(dead_code)]
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum TypeClass {
-    Float,
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum X86TypeClass {
+    NoClass,
     X87,
+    X87Up,
     Sse,
+    SseUp,
+    SseWide(X86RegisterClass),
+    Float,
     Integer,
     Memory,
-    Zero,
 }
 
-#[allow(clippy::missing_panics_doc)] // TODO: remove todo!()
-#[must_use]
-pub fn classify_type(ty: &Type) -> Option<TypeClass> {
-    match ty {
-        Type::Scalar(ScalarType {
-            header:
-                ScalarTypeHeader {
-                    vectorsize: XLangSome(1..=65535),
-                    ..
-                },
-            ..
-        }) => Some(TypeClass::Sse),
-        Type::Scalar(ScalarType {
-            header: ScalarTypeHeader { bitsize: 80, .. },
-            kind:
-                ScalarTypeKind::Float {
-                    format: FloatFormat::IeeeExtPrecision,
-                },
-            ..
-        }) => Some(TypeClass::X87),
-        Type::Scalar(ScalarType {
-            header: ScalarTypeHeader {
-                bitsize: 65..=128, ..
-            },
-            kind: ScalarTypeKind::Float { .. },
-        }) => Some(TypeClass::Sse),
-        Type::Scalar(ScalarType {
-            kind: ScalarTypeKind::Float { .. },
-            ..
-        }) => Some(TypeClass::Float),
-        Type::Scalar(_) | Type::Pointer(_) => Some(TypeClass::Integer),
-        Type::Void | Type::FnType(_) | Type::Null => None,
-        Type::Array(ty) => classify_type(&ty.ty),
-        Type::TaggedType(_, ty) => classify_type(ty),
-        Type::Product(tys) => {
-            let mut infected = TypeClass::Zero;
-            for ty in tys {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (TypeClass::Float, TypeClass::Sse) => TypeClass::Sse,
-                    (TypeClass::Float, TypeClass::X87) => TypeClass::X87,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Aligned(_, _) => todo!(),
-        Type::Aggregate(AggregateDefinition { fields, .. }) => {
-            let mut infected = TypeClass::Zero;
-            for ty in fields.iter().map(|Pair(_, ty)| ty) {
-                infected = match (classify_type(ty)?, infected) {
-                    (a, TypeClass::Zero) => a,
-                    (_, TypeClass::Memory) => TypeClass::Memory,
-                    (TypeClass::Float, TypeClass::Sse) => TypeClass::Sse,
-                    (TypeClass::Float, TypeClass::X87) => TypeClass::X87,
-                    (a, b) if a == b => a,
-                    _ => TypeClass::Memory,
-                };
-            }
-            Some(infected)
-        }
-        Type::Named(path) => todo!("named type {:?}", path),
-    }
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum X86Tag {
+    SysV64,
 }
 
-pub trait X86CallConv {
-    fn prepare_stack(&self, ty: &FnType, frame_size: usize) -> usize;
-    fn find_parameter(&self, off: u32, ty: &FnType, infn: bool) -> ValLocation;
-    fn find_return_val(&self, ty: &Type) -> Option<ValLocation>;
-    fn pass_return_place(&self, ty: &Type, frame_size: usize) -> Option<ValLocation>;
-    fn with_tag(&self, tag: &str) -> Option<Box<dyn X86CallConv>>;
-    fn callee_saved(&self) -> &[X86Register];
-}
+impl Tag for X86Tag {
+    type Register = X86Register;
+    type TypeClass = X86TypeClass;
 
-#[derive(Clone, Debug)]
-pub struct SysV64CC<S: std::hash::BuildHasher + Clone = std::collections::hash_map::RandomState>(
-    &'static TargetProperties<'static>,
-    HashSet<X86Feature, S>,
-    Rc<TypeInformation>,
-);
-
-impl<S: std::hash::BuildHasher + Clone + 'static> X86CallConv for SysV64CC<S> {
-    fn prepare_stack(&self, _ty: &FnType, _frame_size: usize) -> usize {
-        todo!()
+    fn tag_name(&self) -> &'static str {
+        match self {
+            Self::SysV64 => "SysV64",
+        }
     }
 
-    #[allow(clippy::no_effect_underscore_binding)] // TODO: use xmm_regs
-    fn find_parameter(&self, off: u32, ty: &FnType, _: bool) -> ValLocation {
-        let mut int_regs: &[X86Register] = &[
-            X86Register::Rdi,
-            X86Register::Rsi,
-            X86Register::Rdx,
-            X86Register::Rcx,
-            X86Register::R8,
-            X86Register::R9,
-        ];
-        let mut _xmm_regs: &[X86Register] = &[
-            X86Register::Xmm(0),
-            X86Register::Xmm(1),
-            X86Register::Xmm(2),
-            X86Register::Xmm(3),
-            X86Register::Xmm(4),
-            X86Register::Xmm(5),
-        ];
+    fn param_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register] {
+        match (self, cl) {
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Tmm)) => &[],
+            (X86Tag::SysV64, X86TypeClass::Sse)
+            | (X86Tag::SysV64, X86TypeClass::SseUp)
+            | (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Xmm))
+            | (X86Tag::SysV64, X86TypeClass::Float) => &[
+                X86Register::Xmm(0),
+                X86Register::Xmm(1),
+                X86Register::Xmm(2),
+                X86Register::Xmm(3),
+                X86Register::Xmm(4),
+                X86Register::Xmm(5),
+            ],
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Ymm)) => &[
+                X86Register::Ymm(0),
+                X86Register::Ymm(1),
+                X86Register::Ymm(2),
+                X86Register::Ymm(3),
+                X86Register::Ymm(4),
+                X86Register::Ymm(5),
+            ],
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Zmm)) => &[
+                X86Register::Zmm(0),
+                X86Register::Zmm(1),
+                X86Register::Zmm(2),
+                X86Register::Zmm(3),
+                X86Register::Zmm(4),
+                X86Register::Zmm(5),
+            ],
+            (X86Tag::SysV64, X86TypeClass::Integer) => &[
+                X86Register::Rdi,
+                X86Register::Rsi,
+                X86Register::Rdx,
+                X86Register::Rcx,
+                X86Register::R8,
+                X86Register::R9,
+            ],
+            (X86Tag::SysV64, _) => &[],
+        }
+    }
 
-        let has_return_param = self.pass_return_place(&ty.ret, 0).is_some();
-        if has_return_param {
-            int_regs = &int_regs[1..];
+    fn return_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register] {
+        match (self, cl) {
+            (X86Tag::SysV64, X86TypeClass::X87) => &[X86Register::Fp(0), X86Register::Fp(1)],
+            (X86Tag::SysV64, X86TypeClass::Sse)
+            | (X86Tag::SysV64, X86TypeClass::SseUp)
+            | (X86Tag::SysV64, X86TypeClass::Float) => &[X86Register::Xmm(0), X86Register::Xmm(1)],
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Tmm)) => &[],
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Xmm)) => {
+                &[X86Register::Xmm(0)]
+            }
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Ymm)) => {
+                &[X86Register::Ymm(0)]
+            }
+            (X86Tag::SysV64, X86TypeClass::SseWide(X86RegisterClass::Zmm)) => {
+                &[X86Register::Zmm(0)]
+            }
+            (X86Tag::SysV64, X86TypeClass::Integer) => &[X86Register::Rax, X86Register::Rdx],
+            (X86Tag::SysV64, _) => &[],
         }
-        let mut last_val = ValLocation::Unassigned(0);
-        for ty in ty.params.iter().take(off as usize + 1) {
-            match (classify_type(ty).unwrap(), self.2.type_size(ty).unwrap()) {
-                (_, 0) => last_val = ValLocation::Null,
-                (TypeClass::Integer, 1) => {
-                    int_regs.get(0).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[1..];
-                            let reg =
-                                X86Register::from_class(X86RegisterClass::ByteRex, reg.regnum())
-                                    .unwrap();
-                            last_val = ValLocation::Register(reg);
-                        },
-                    );
-                }
-                (TypeClass::Integer, 2) => {
-                    int_regs.get(0).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[1..];
-                            let reg = X86Register::from_class(X86RegisterClass::Word, reg.regnum())
-                                .unwrap();
-                            last_val = ValLocation::Register(reg);
-                        },
-                    );
-                }
-                (TypeClass::Integer, 3 | 4) => {
-                    int_regs.get(0).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[1..];
-                            let reg =
-                                X86Register::from_class(X86RegisterClass::Double, reg.regnum())
-                                    .unwrap();
-                            last_val = ValLocation::Register(reg);
-                        },
-                    );
-                }
-                (TypeClass::Integer, 5..=8) => {
-                    int_regs.get(0).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[1..];
-                            last_val = ValLocation::Register(*reg);
-                        },
-                    );
-                }
-                (TypeClass::Integer, 9..=16) => {
-                    int_regs.get(0..2).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[2..];
-                            last_val = ValLocation::Regs(reg.to_owned());
-                        },
-                    );
-                }
-                (TypeClass::Integer, 17..=24) => {
-                    int_regs.get(0..3).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[3..];
-                            last_val = ValLocation::Regs(reg.to_owned());
-                        },
-                    );
-                }
-                (TypeClass::Integer, 25..=32) => {
-                    int_regs.get(0..4).map_or_else(
-                        || todo!(),
-                        |reg| {
-                            int_regs = &int_regs[4..];
-                            last_val = ValLocation::Regs(reg.to_owned());
-                        },
-                    );
+    }
+
+    fn replace_param_with_pointer(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass> {
+        eprintln!("replace_param_with_pointer({:?})", cl);
+        match self {
+            Self::SysV64 => {
+                if cl.len() > 2 {
+                    Some(X86TypeClass::Integer)
+                } else if cl.iter().any(|x| {
+                    *x == X86TypeClass::Memory
+                        || *x == X86TypeClass::X87
+                        || *x == X86TypeClass::X87Up
+                }) {
+                    Some(X86TypeClass::Integer)
+                } else {
+                    None
                 }
-                _ => todo!(),
             }
         }
-
-        last_val
     }
 
-    #[allow(clippy::unnested_or_patterns)]
-    fn find_return_val(&self, ty: &Type) -> Option<ValLocation> {
-        match (classify_type(ty), self.2.type_size(ty)) {
-            (None, Some(_)) | (Some(_), None) => unreachable!(),
-            (Some(TypeClass::Zero), Some(0)) => Some(ValLocation::Null),
-            (Some(TypeClass::Zero), Some(_)) => {
-                panic!("Impossible situation (type has zst class, but has a size)")
-            }
-            (Some(TypeClass::Integer), Some(1)) => Some(ValLocation::Register(X86Register::Al)),
-            (Some(TypeClass::Integer), Some(2)) => Some(ValLocation::Register(X86Register::Ax)),
-            (Some(TypeClass::Integer), Some(4)) => Some(ValLocation::Register(X86Register::Eax)),
-            (Some(TypeClass::Integer), Some(8)) => Some(ValLocation::Register(X86Register::Rax)),
-            (Some(TypeClass::Integer), Some(16)) => {
-                Some(ValLocation::Regs(vec![X86Register::Rax, X86Register::Rdx]))
+    fn combine_wide(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass> {
+        match cl {
+            [X86TypeClass::Sse, X86TypeClass::SseUp] => {
+                Some(X86TypeClass::SseWide(X86RegisterClass::Xmm))
             }
-            (Some(TypeClass::X87), Some(16)) => Some(ValLocation::Register(X86Register::Fp(0))),
-            (Some(TypeClass::Float), Some(4))
-            | (Some(TypeClass::Float), Some(8))
-            | (Some(TypeClass::Float), Some(16)) => {
-                Some(ValLocation::Register(X86Register::Xmm(0)))
+            [X86TypeClass::Sse, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp] => {
+                Some(X86TypeClass::SseWide(X86RegisterClass::Ymm))
             }
-            (Some(TypeClass::Sse), Some(4))
-            | (Some(TypeClass::Sse), Some(8))
-            | (Some(TypeClass::Sse), Some(16)) => Some(ValLocation::Register(X86Register::Xmm(0))),
-            (Some(TypeClass::Sse), Some(32)) if self.1.contains(&X86Feature::Avx) => {
-                Some(ValLocation::Register(X86Register::Ymm(0)))
+            [X86TypeClass::Sse, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp, X86TypeClass::SseUp] => {
+                Some(X86TypeClass::SseWide(X86RegisterClass::Zmm))
             }
-            (Some(TypeClass::Sse), Some(64)) if self.1.contains(&X86Feature::Avx512f) => {
-                Some(ValLocation::Register(X86Register::Zmm(0)))
+            [X86TypeClass::X87, X86TypeClass::X87Up]
+            | [X86TypeClass::X87, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up]
+            | [X86TypeClass::X87, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up, X86TypeClass::X87Up] => {
+                Some(X86TypeClass::X87)
             }
             _ => None,
         }
     }
 
-    fn pass_return_place(&self, _ty: &Type, _frame_size: usize) -> Option<ValLocation> {
-        None // For now
+    fn replace_return_with_pointer(
+        &self,
+        cl: &[Self::TypeClass],
+    ) -> Option<ReturnPointerBehaviour<Self::Register, Self::TypeClass>> {
+        match self {
+            Self::SysV64 => {
+                if cl.len() > 2 {
+                    Some(ReturnPointerBehaviour::Param(
+                        ParamPosition::First,
+                        X86TypeClass::Integer,
+                    ))
+                } else if cl.iter().any(|x| *x == X86TypeClass::Memory) {
+                    Some(ReturnPointerBehaviour::Param(
+                        ParamPosition::First,
+                        X86TypeClass::Integer,
+                    ))
+                } else {
+                    None
+                }
+            }
+        }
     }
 
-    fn with_tag(&self, _: &str) -> Option<Box<dyn X86CallConv>> {
-        Some(Box::new((*self).clone()))
+    fn replace_class_as_varargs(&self, _: &Self::TypeClass) -> Option<Self::TypeClass> {
+        None
+    }
+
+    fn register_disposition(&self, cl: &Self::TypeClass) -> RegisterDisposition {
+        match self {
+            X86Tag::SysV64 => match cl {
+                X86TypeClass::Sse
+                | X86TypeClass::SseUp
+                | X86TypeClass::SseWide(_)
+                | X86TypeClass::Float => RegisterDisposition::Consume,
+                _ => RegisterDisposition::Interleave,
+            },
+        }
     }
 
-    fn callee_saved(&self) -> &[X86Register] {
-        &[
-            X86Register::Rbx,
-            X86Register::Rbp,
-            X86Register::Rsp, // note: This is hardcoded in the codegen
-            X86Register::R12,
-            X86Register::R13,
-            X86Register::R14,
-            X86Register::R15,
-        ]
+    fn stacked_params_order(&self) -> StackedParamsOrder {
+        match self {
+            X86Tag::SysV64 => StackedParamsOrder::Rtl,
+        }
     }
 }
 
-impl<'a> CallingConvention for dyn X86CallConv + 'a {
-    type Loc = ValLocation;
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct X86CallConvInfo {
+    pub mode: X86Mode,
+}
+
+impl CallConvInfo for X86CallConvInfo {
+    type Tag = X86Tag;
+
+    type TypeClass = X86TypeClass;
+
+    type Register = X86Register;
+
+    fn get_tag(&self, tag: &str) -> Self::Tag {
+        match (self.mode, tag) {
+            (X86Mode::Long, "SysV64") => X86Tag::SysV64,
+            (mode, tag) => todo!("{} in {:?}", tag, mode),
+        }
+    }
+
+    fn no_class(&self) -> Self::TypeClass {
+        X86TypeClass::NoClass
+    }
+
+    fn classify_scalar(&self, sty: xlang_struct::ScalarType) -> Vec<Self::TypeClass> {
+        let width = self.mode.width();
+        let scalar_regs = ((sty.header.bitsize + (width - 1)) as usize) >> (width.trailing_zeros());
+
+        if let XLangSome(elements) = sty.header.vectorsize {
+            let total_regs = (scalar_regs) * (elements as usize);
+            if total_regs > 0 {
+                let mut regs = Vec::with_capacity(total_regs);
+                regs.push(X86TypeClass::Sse);
+                for _ in 1..total_regs {
+                    regs.push(X86TypeClass::SseUp)
+                }
+                regs
+            } else {
+                vec![X86TypeClass::NoClass]
+            }
+        } else {
+            if scalar_regs == 0 {
+                vec![X86TypeClass::NoClass]
+            } else {
+                match sty.kind {
+                    xlang_struct::ScalarTypeKind::Empty => vec![X86TypeClass::NoClass; scalar_regs],
+                    xlang_struct::ScalarTypeKind::Integer { .. }
+                    | xlang_struct::ScalarTypeKind::Fixed { .. }
+                    | xlang_struct::ScalarTypeKind::Char { .. } => {
+                        vec![X86TypeClass::Integer; scalar_regs]
+                    }
+                    xlang_struct::ScalarTypeKind::Float {
+                        format: xlang::ir::FloatFormat::IeeeExtPrecision,
+                    } if sty.header.bitsize < 80 => {
+                        let mut regs = Vec::with_capacity(scalar_regs);
+                        regs.push(X86TypeClass::X87);
+                        for _ in 1..scalar_regs {
+                            regs.push(X86TypeClass::X87Up)
+                        }
+                        regs
+                    }
+                    xlang_struct::ScalarTypeKind::Float { .. } => {
+                        vec![X86TypeClass::Float; scalar_regs]
+                    }
+                    xlang_struct::ScalarTypeKind::Posit => vec![X86TypeClass::Float; scalar_regs],
+                }
+            }
+        }
+    }
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        self.pass_return_place(ty, 0)
+    fn classify_pointer(&self) -> Self::TypeClass {
+        X86TypeClass::Integer
     }
 
-    fn find_param(&self, fnty: &FnType, _: &FnType, param: u32, infn: bool) -> Self::Loc {
-        self.find_parameter(param, fnty, infn)
+    fn classify_aggregate_disposition(
+        &self,
+    ) -> xlang_backend::callconv::ClassifyAggregateDisposition<Self::TypeClass> {
+        ClassifyAggregateDisposition::SplitFlat((self.mode.width() as u64) >> 3)
     }
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        self.find_return_val(&fnty.ret).unwrap()
+    fn merge_class(&self, left: Self::TypeClass, right: Self::TypeClass) -> Self::TypeClass {
+        if left == right {
+            left
+        } else {
+            match (left, right) {
+                (X86TypeClass::NoClass, other) | (other, X86TypeClass::NoClass) => other,
+                (X86TypeClass::Memory, _) | (_, X86TypeClass::Memory) => X86TypeClass::Memory,
+                (X86TypeClass::Sse, X86TypeClass::SseUp)
+                | (X86TypeClass::SseUp, X86TypeClass::Sse) => X86TypeClass::Sse,
+                (X86TypeClass::Integer, _) | (_, X86TypeClass::Integer) => X86TypeClass::Integer,
+                _ => X86TypeClass::Memory,
+            }
+        }
     }
-}
 
-#[allow(clippy::module_name_repetitions)]
-pub fn get_callconv<S: std::hash::BuildHasher + Clone + 'static>(
-    _tag: &str,
-    target: &'static TargetProperties<'static>,
-    features: HashSet<X86Feature, S>,
-    tys: Rc<TypeInformation>,
-) -> Option<Box<dyn X86CallConv>> {
-    Some(Box::new(SysV64CC(target, features, tys)))
+    fn adjust_classes_after_combine(&self, _: &mut [Self::TypeClass]) {}
 }
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index a9bd4269..b7dfd6e1 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -1,12 +1,39 @@
-use arch_ops::x86::{X86Mode, X86Register};
+use arch_ops::{
+    traits::{Address, InsnWrite},
+    x86::{
+        codegen::{X86CodegenOpcode, X86Encoder, X86Instruction, X86Operand},
+        X86Mode, X86Register, X86RegisterClass,
+    },
+};
+use callconv::X86CallConvInfo;
 use target_tuples::{Architecture, Target};
 use xlang::{
-    abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
+    abi::{pair::Pair, string::StringView},
+    plugin::XLangCodegen,
+    prelude::v1::{DynBox, HashMap},
     targets::properties::TargetProperties,
 };
-use xlang_backend::{mach::Machine, SsaCodegenPlugin};
+use xlang_backend::{
+    callconv::{compute_call_conv, CallConvLocation},
+    expr::Trap,
+    mach::Machine,
+    ssa::OpaquePtr,
+    ty::TypeInformation,
+    SsaCodegenPlugin,
+};
+
+mod callconv;
 
-pub struct LocationAssignment {}
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum X86ValLocation {
+    Register(X86Register),
+}
+
+pub struct LocationAssignment {
+    foreign_location: X86ValLocation,
+    owning_bb: u32,
+    change_owner: Vec<(usize, X86ValLocation)>,
+}
 
 pub struct X86Machine {
     mode: Option<X86Mode>,
@@ -16,12 +43,93 @@ pub struct X86Assignments {
     mode: X86Mode,
     sp: X86Register,
     available_int_registers: Vec<X86Register>,
-    stack_width: u32,
+    stack_width: i32,
     assigns: HashMap<u32, LocationAssignment>,
 }
 
 pub struct X86Clobbers {}
 
+fn move_opcode(
+    class: X86RegisterClass,
+    align: Option<u64>,
+    hint_vec_is_int: bool,
+) -> X86CodegenOpcode {
+    match class {
+        X86RegisterClass::Xmm if align.unwrap_or(16) >= 16 => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Movdqa
+            } else {
+                X86CodegenOpcode::Movaps
+            }
+        }
+        X86RegisterClass::Ymm if align.unwrap_or(32) >= 32 => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vmovdqa
+            } else {
+                X86CodegenOpcode::Vmovaps
+            }
+        }
+        X86RegisterClass::Zmm if align.unwrap_or(64) >= 64 => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vmovdqa32
+            } else {
+                X86CodegenOpcode::Vmovaps
+            }
+        }
+        X86RegisterClass::Xmm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Movdqu
+            } else {
+                X86CodegenOpcode::Movups
+            }
+        }
+        X86RegisterClass::Ymm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vmovdqu
+            } else {
+                X86CodegenOpcode::Vmovups
+            }
+        }
+        X86RegisterClass::Zmm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vmovdqu32
+            } else {
+                X86CodegenOpcode::Vmovups
+            }
+        }
+        X86RegisterClass::Tmm => todo!("tmmreg"),
+        X86RegisterClass::St => todo!("fpreg"),
+        _ => X86CodegenOpcode::Mov,
+    }
+}
+
+impl X86Machine {
+    pub fn write_move<W: InsnWrite>(
+        &self,
+        writer: &mut X86Encoder<W>,
+        dest: &X86ValLocation,
+        src: &X86ValLocation,
+    ) -> std::io::Result<()> {
+        if dest == src {
+            return Ok(());
+        }
+        match (dest, src) {
+            (X86ValLocation::Register(dest), X86ValLocation::Register(src)) => {
+                if dest.class() != src.class() {
+                    panic!("Cannot move between register classes")
+                }
+
+                let opcode = move_opcode(dest.class(), None, false);
+
+                writer.write_insn(X86Instruction::new(
+                    opcode,
+                    vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
+                ))
+            }
+        }
+    }
+}
+
 impl Machine for X86Machine {
     fn matches_target(&self, targ: StringView) -> bool {
         let arch = Target::parse(&targ).arch();
@@ -43,7 +151,25 @@ impl Machine for X86Machine {
     type BlockClobbers = X86Clobbers;
 
     fn new_assignments(&self) -> Self::Assignments {
-        todo!()
+        let mode = self.mode.expect("Target must have been set");
+        let gpr_size = mode.largest_gpr();
+        let sp = X86Register::from_class(gpr_size, 4).unwrap();
+        let max_gpr_num = match mode {
+            X86Mode::Long => 16,
+            _ => 8,
+        };
+        let int_registers = (0..max_gpr_num)
+            .filter(|s| *s != 4)
+            .flat_map(|x| X86Register::from_class(gpr_size, x))
+            .collect();
+
+        X86Assignments {
+            mode,
+            sp,
+            available_int_registers: int_registers,
+            stack_width: 0,
+            assigns: HashMap::new(),
+        }
     }
 
     fn assign_locations(
@@ -52,8 +178,51 @@ impl Machine for X86Machine {
         insns: &[xlang_backend::ssa::SsaInstruction],
         incoming: &[xlang_backend::ssa::OpaqueLocation],
         which: u32,
+        incoming_set: &HashMap<u32, xlang::abi::vec::Vec<xlang_backend::ssa::OpaqueLocation>>,
+        tys: &TypeInformation,
     ) -> Self::BlockClobbers {
-        todo!()
+        let mut clobbers = X86Clobbers {};
+        for (num, insn) in insns.iter().enumerate() {
+            match insn {
+                xlang_backend::ssa::SsaInstruction::Jump(targ, old_locs)
+                | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
+                    let foreign_locs = &incoming_set[targ];
+
+                    for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
+                        todo!("jump remap {} => {}", old_loc, new_loc)
+                    }
+                }
+                xlang_backend::ssa::SsaInstruction::Exit(_) => todo!("exit"),
+                xlang_backend::ssa::SsaInstruction::Tailcall(targ, locs) => {
+                    let callconv = X86CallConvInfo {
+                        mode: assignments.mode,
+                    };
+
+                    let callconv = compute_call_conv(&callconv, &targ.real_ty, &targ.call_ty, tys);
+
+                    for (loc, call_loc) in locs.iter().zip(callconv.params()) {
+                        match call_loc {
+                            CallConvLocation::Null => {}
+                            CallConvLocation::Register(reg) => {
+                                assignments
+                                    .assigns
+                                    .get_or_insert_with_mut(loc.num, |_| LocationAssignment {
+                                        foreign_location: X86ValLocation::Register(*reg),
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                    })
+                                    .change_owner
+                                    .push((num, X86ValLocation::Register(*reg)));
+                            }
+                            loc => todo!("{:?}", loc),
+                        }
+                    }
+                }
+                xlang_backend::ssa::SsaInstruction::Trap(_) => {}
+                xlang_backend::ssa::SsaInstruction::LoadImmediate(_, _) => {}
+            }
+        }
+        clobbers
     }
 
     fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
@@ -64,8 +233,83 @@ impl Machine for X86Machine {
         out: &mut W,
         label_sym: F,
         which: u32,
+        tys: &TypeInformation,
     ) -> std::io::Result<()> {
-        todo!()
+        let mut encoder = X86Encoder::new(out, assignments.mode);
+        let mut cur_locations = HashMap::<_, _>::new();
+        for Pair(addr, loc) in &assignments.assigns {
+            if loc.owning_bb == which {
+                cur_locations.insert(*addr, loc.foreign_location.clone());
+            }
+        }
+        for (num, insn) in insns.iter().enumerate() {
+            for Pair(addr, loc) in &assignments.assigns {
+                if loc.owning_bb == which {
+                    for (at, new_loc) in &loc.change_owner {
+                        if *at == num {
+                            self.write_move(&mut encoder, new_loc, &cur_locations[addr])?;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            match insn {
+                xlang_backend::ssa::SsaInstruction::Jump(targ, _) => {
+                    encoder.write_insn(X86Instruction::new(
+                        X86CodegenOpcode::Jmp,
+                        vec![X86Operand::RelOffset(Address::Symbol {
+                            name: label_sym(*targ),
+                            disp: 0,
+                        })],
+                    ))?;
+                }
+                xlang_backend::ssa::SsaInstruction::Fallthrough(_, _) => {}
+                xlang_backend::ssa::SsaInstruction::Exit(_) => {
+                    if assignments.stack_width > 0 {
+                        encoder.write_insn(X86Instruction::new(
+                            X86CodegenOpcode::Add,
+                            vec![
+                                X86Operand::Register(assignments.sp),
+                                X86Operand::Immediate(assignments.stack_width as i64),
+                            ],
+                        ))?;
+                    }
+                    encoder.write_insn(X86Instruction::Ret)?;
+                }
+                xlang_backend::ssa::SsaInstruction::Tailcall(targ, _) => match &targ.ptr {
+                    OpaquePtr::Symbol(sym) => encoder.write_insn(X86Instruction::new(
+                        X86CodegenOpcode::Jmp,
+                        vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
+                    ))?,
+                    OpaquePtr::Pointer(ptr) => todo!("indirect call"),
+                },
+                xlang_backend::ssa::SsaInstruction::Trap(Trap::Breakpoint) => {
+                    encoder.write_insn(X86Instruction::Int3)?
+                }
+                xlang_backend::ssa::SsaInstruction::Trap(_) => {
+                    encoder.write_insn(X86Instruction::Ud2)?
+                }
+                xlang_backend::ssa::SsaInstruction::LoadImmediate(loc, val) => {
+                    if let Some(location) = cur_locations.get(&loc.num) {
+                        match location {
+                            X86ValLocation::Register(reg) => {
+                                let mov = move_opcode(reg.class(), None, true);
+                                encoder.write_insn(X86Instruction::new(
+                                    mov,
+                                    vec![
+                                        X86Operand::Register(*reg),
+                                        X86Operand::Immediate((*val) as i64),
+                                    ],
+                                ))?;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
     }
 
     fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
@@ -73,7 +317,18 @@ impl Machine for X86Machine {
         assignments: &Self::Assignments,
         out: &mut W,
     ) -> std::io::Result<()> {
-        todo!()
+        if assignments.stack_width != 0 {
+            let mut encoder = X86Encoder::new(out, assignments.mode);
+            encoder.write_insn(X86Instruction::new(
+                X86CodegenOpcode::Sub,
+                vec![
+                    X86Operand::Register(assignments.sp),
+                    X86Operand::Immediate(-assignments.stack_width as i64),
+                ],
+            ))?;
+        }
+
+        Ok(())
     }
 }
 
diff --git a/lc-binutils b/lc-binutils
index d97de389..967ded32 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit d97de389bd9a941c222320229bbe41f41294230b
+Subproject commit 967ded327dff8b16e8f04474b359fe565b3519f9
diff --git a/lcrust/libraries/liballoc/src/alloc.rs b/lcrust/libraries/liballoc/src/alloc.rs
index b341282b..c542f34f 100644
--- a/lcrust/libraries/liballoc/src/alloc.rs
+++ b/lcrust/libraries/liballoc/src/alloc.rs
@@ -265,7 +265,10 @@ unsafe impl Allocator for Global {
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         if layout.size() == 0 {
             Ok(unsafe {
-                NonNull::new_unchecked(core::ptr::slice_from_raw_parts_mut(1usize as *mut u8, 0))
+                NonNull::new_unchecked(core::ptr::slice_from_raw_parts_mut(
+                    layout.align() as *mut u8,
+                    0,
+                ))
             })
         } else {
             let ptr = unsafe { self::alloc(layout) };
diff --git a/xlang/xlang_backend/src/callconv.rs b/xlang/xlang_backend/src/callconv.rs
index fe514099..b92234e9 100644
--- a/xlang/xlang_backend/src/callconv.rs
+++ b/xlang/xlang_backend/src/callconv.rs
@@ -1,123 +1,389 @@
-use std::{rc::Rc, sync::Arc};
+use core::cmp::Eq;
+use core::hash::Hash;
 
-use xlang::ir::{FnType, Type};
+use xlang::{
+    abi::{collection::HashMap, pair::Pair},
+    ir::{ArrayType, FnType, ScalarType, Type},
+};
 
-use crate::expr::ValLocation;
+use crate::ty::{AggregateLayout, FlattenFieldsOf, TypeInformation};
 
-/// Represents a calling convention, which can
-pub trait CallingConvention {
-    /// The type for locations that the Calling Convention stores values
-    type Loc: ValLocation;
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum ParamPosition {
+    First,
+    Last,
+}
 
-    /// If a given type is passed in a return place, then obtain the location to store that place.
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc>;
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum CallConvLocation<R> {
+    Register(R),
+    Indirect(R),
+    StackOffset(i32),
+    Split(Vec<CallConvLocation<R>>),
+    Null,
+}
 
-    /// Find the `n`th parameter inside or outside of the context of the function
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc;
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum ReturnPointerBehaviour<R, C> {
+    Dedicated(R),
+    Param(ParamPosition, C),
+}
 
-    /// Finds the return value location
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc;
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum RegisterDisposition {
+    Interleave,
+    Consume,
+}
 
-    /// Determines whether tailcall is possible
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum StackedParamsOrder {
+    Rtl,
+    Ltr,
+}
 
-    fn can_tail(&self, fnty: &FnType, base_ty: &FnType) -> bool {
-        self.pass_return_place(&fnty.ret).is_some()
-            || !self.pass_return_place(&base_ty.ret).is_some()
-    }
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum ClassifyAggregateDisposition<C> {
+    Single(C),
+    Recursive,
+    SplitFlat(u64),
 }
 
-impl<C: CallingConvention + ?Sized> CallingConvention for &C {
-    type Loc = C::Loc;
+pub trait Tag {
+    type Register: Clone + Eq;
+    type TypeClass;
+    fn tag_name(&self) -> &'static str;
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
-    }
+    fn param_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register];
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
-    }
+    fn return_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register];
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
-    }
-}
+    fn replace_param_with_pointer(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass>;
 
-impl<C: CallingConvention + ?Sized> CallingConvention for &mut C {
-    type Loc = C::Loc;
+    fn combine_wide(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass>;
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
-    }
+    fn replace_return_with_pointer(
+        &self,
+        cl: &[Self::TypeClass],
+    ) -> Option<ReturnPointerBehaviour<Self::Register, Self::TypeClass>>;
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
-    }
+    fn replace_class_as_varargs(&self, cl: &Self::TypeClass) -> Option<Self::TypeClass>;
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
-    }
-}
+    fn register_disposition(&self, cl: &Self::TypeClass) -> RegisterDisposition;
 
-impl<C: CallingConvention + ?Sized> CallingConvention for Box<C> {
-    type Loc = C::Loc;
+    fn stacked_params_order(&self) -> StackedParamsOrder;
+}
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
-    }
+pub trait CallConvInfo {
+    type Tag: Tag<TypeClass = Self::TypeClass, Register = Self::Register>;
+    type TypeClass: Eq + Hash + Clone;
+    type Register: Eq + Clone;
+    fn get_tag(&self, tag: &str) -> Self::Tag;
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
-    }
+    fn no_class(&self) -> Self::TypeClass;
+    fn classify_scalar(&self, sty: ScalarType) -> Vec<Self::TypeClass>;
+    fn classify_pointer(&self) -> Self::TypeClass;
+    fn classify_aggregate_disposition(&self) -> ClassifyAggregateDisposition<Self::TypeClass>;
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
-    }
+    fn merge_class(&self, left: Self::TypeClass, right: Self::TypeClass) -> Self::TypeClass;
+    fn adjust_classes_after_combine(&self, classes: &mut [Self::TypeClass]);
 }
 
-impl<C: CallingConvention + ?Sized> CallingConvention for xlang::abi::boxed::Box<C> {
-    type Loc = C::Loc;
+pub struct CallConv<R, T> {
+    params: Vec<CallConvLocation<R>>,
+    stacked_params_count: u32,
+    ret_location: CallConvLocation<R>,
+    tag: T,
+    is_varargs: bool,
+}
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
+impl<R, T> CallConv<R, T> {
+    pub fn tag(&self) -> &T {
+        &self.tag
     }
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
+    pub fn params(&self) -> &[CallConvLocation<R>] {
+        &self.params
     }
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
+    pub fn ret_location(&self) -> &CallConvLocation<R> {
+        &self.ret_location
     }
-}
 
-impl<C: CallingConvention + ?Sized> CallingConvention for Rc<C> {
-    type Loc = C::Loc;
-
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
+    pub fn stacked_params_count(&self) -> u32 {
+        self.stacked_params_count
     }
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
+    pub fn is_varargs(&self) -> bool {
+        self.is_varargs
     }
+}
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
+pub fn classify_type<I: CallConvInfo>(
+    info: &I,
+    ty: &Type,
+    tys: &TypeInformation,
+) -> Vec<I::TypeClass> {
+    let mut classes = Vec::new();
+    match ty {
+        Type::Null | Type::Void => classes.push(info.no_class()),
+        Type::Scalar(sty) => classes.extend(info.classify_scalar(*sty)),
+        Type::FnType(_) => panic!("Cannot classify a non-value type (other than void)"),
+        Type::Pointer(_) => classes.push(info.classify_pointer()),
+        Type::Array(_) => todo!(),
+        Type::TaggedType(_, ty) => classes = classify_type(info, ty, tys),
+        Type::Product(_) => todo!(),
+        Type::Aligned(_, _) => todo!(),
+        Type::Aggregate(_) => todo!(),
+        Type::Named(_) => todo!(),
     }
-}
 
-impl<C: CallingConvention + ?Sized> CallingConvention for Arc<C> {
-    type Loc = C::Loc;
+    info.adjust_classes_after_combine(&mut classes);
 
-    fn pass_return_place(&self, ty: &Type) -> Option<Self::Loc> {
-        C::pass_return_place(self, ty)
-    }
+    classes
+}
 
-    fn find_param(&self, fnty: &FnType, real: &FnType, param: u32, infn: bool) -> Self::Loc {
-        C::find_param(self, fnty, real, param, infn)
+pub fn compute_call_conv<I: CallConvInfo>(
+    info: &I,
+    real_ty: &FnType,
+    call_ty: &FnType,
+    tys: &TypeInformation,
+) -> CallConv<I::Register, I::Tag> {
+    let tag = info.get_tag(&real_ty.tag);
+
+    let is_varargs = real_ty.variadic;
+    let fixed_arity_params_count = real_ty.params.len();
+
+    let mut param_register_by_class = HashMap::<_, _>::new();
+
+    let mut return_register_by_class = HashMap::<_, _>::new();
+
+    let return_classes = classify_type(info, &real_ty.ret, tys);
+
+    let mut return_loc = None;
+
+    let mut total_params_consumed = 0;
+
+    let mut param_locs = Vec::new();
+
+    let no_class = info.no_class();
+
+    if let Some(combined) = tag.combine_wide(&return_classes) {
+        if combined == no_class {
+            return_loc = Some(CallConvLocation::Null);
+        } else {
+            let regs = return_register_by_class
+                .get_or_insert_with_mut(combined, |cl| tag.return_regs_for_class(cl));
+
+            if let Some(val) = regs.first() {
+                return_loc = Some(CallConvLocation::Register(val.clone()));
+            } else {
+                panic!("Wide register return is non-existant")
+            }
+        }
+    } else if let Some(targ) = tag.replace_return_with_pointer(&return_classes) {
+        match targ {
+            ReturnPointerBehaviour::Dedicated(reg) => {
+                return_loc = Some(CallConvLocation::Register(reg))
+            }
+            ReturnPointerBehaviour::Param(ParamPosition::First, cl) => {
+                let regs = param_register_by_class
+                    .get_or_insert_with_mut(cl.clone(), |cl| tag.param_regs_for_class(cl));
+                let reg = match tag.register_disposition(&cl) {
+                    RegisterDisposition::Interleave => {
+                        if let Some((l, r)) = regs.split_first() {
+                            let l = l.clone();
+                            *regs = r;
+                            Some(l)
+                        } else {
+                            None
+                        }
+                    }
+                    RegisterDisposition::Consume => {
+                        if let Some(val) = regs.get(total_params_consumed) {
+                            total_params_consumed += 1;
+                            Some(val.clone())
+                        } else {
+                            None
+                        }
+                    }
+                };
+
+                if let Some(reg) = reg {
+                    return_loc = Some(CallConvLocation::Indirect(reg))
+                } else {
+                    todo!("return in memory on stack")
+                }
+            }
+            ReturnPointerBehaviour::Param(_, cl) => todo!("non-start return pointer"),
+        }
+    } else {
+        let mut split_locs = vec![];
+
+        for cl in return_classes {
+            if cl == no_class {
+                split_locs.push(CallConvLocation::Null);
+            } else {
+                let regs = return_register_by_class
+                    .get_or_insert_with_mut(cl, |cl| tag.return_regs_for_class(cl));
+
+                if let Some((reg, rest)) = regs.split_first() {
+                    split_locs.push(CallConvLocation::Register(reg.clone()));
+                    *regs = rest;
+                } else {
+                    panic!("Register return is non-existant")
+                }
+            }
+        }
+
+        if split_locs.is_empty() {
+            return_loc = Some(CallConvLocation::Null);
+        } else if split_locs.len() == 1 {
+            let val = split_locs.pop().unwrap();
+            return_loc = Some(val);
+        } else {
+            return_loc = Some(CallConvLocation::Split(split_locs));
+        }
     }
 
-    fn find_return_val(&self, fnty: &FnType) -> Self::Loc {
-        C::find_return_val(self, fnty)
+    for (pos, param) in call_ty.params.iter().enumerate() {
+        let class = classify_type(info, param, tys);
+        if let Some(combined) = tag.combine_wide(&class) {
+            let class = if pos >= fixed_arity_params_count {
+                if let Some(replace) = tag.replace_class_as_varargs(&combined) {
+                    replace
+                } else {
+                    combined
+                }
+            } else {
+                combined
+            };
+            let regs = param_register_by_class
+                .get_or_insert_with_mut(class.clone(), |cl| tag.param_regs_for_class(cl));
+            let reg = match tag.register_disposition(&class) {
+                RegisterDisposition::Interleave => {
+                    if let Some((l, r)) = regs.split_first() {
+                        let l = l.clone();
+                        *regs = r;
+                        Some(l)
+                    } else {
+                        None
+                    }
+                }
+                RegisterDisposition::Consume => {
+                    if let Some(val) = regs.get(total_params_consumed) {
+                        total_params_consumed += 1;
+                        Some(val.clone())
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            if let Some(reg) = reg {
+                param_locs.push(CallConvLocation::Register(reg))
+            } else {
+                todo!("stack")
+            }
+        } else if let Some(ptr) = tag.replace_param_with_pointer(&class) {
+            let class = if pos >= fixed_arity_params_count {
+                if let Some(replace) = tag.replace_class_as_varargs(&ptr) {
+                    replace
+                } else {
+                    ptr
+                }
+            } else {
+                ptr
+            };
+            let regs = param_register_by_class
+                .get_or_insert_with_mut(class.clone(), |cl| tag.param_regs_for_class(cl));
+            let reg = match tag.register_disposition(&class) {
+                RegisterDisposition::Interleave => {
+                    if let Some((l, r)) = regs.split_first() {
+                        let l = l.clone();
+                        *regs = r;
+                        Some(l)
+                    } else {
+                        None
+                    }
+                }
+                RegisterDisposition::Consume => {
+                    if let Some(val) = regs.get(total_params_consumed) {
+                        total_params_consumed += 1;
+                        Some(val.clone())
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            if let Some(reg) = reg {
+                param_locs.push(CallConvLocation::Indirect(reg))
+            } else {
+                todo!("stack")
+            }
+        } else {
+            let mut split_locs = Vec::new();
+            for class in class {
+                if class == no_class {
+                    split_locs.push(CallConvLocation::Null);
+                } else {
+                    let class = if pos >= fixed_arity_params_count {
+                        if let Some(replace) = tag.replace_class_as_varargs(&class) {
+                            replace
+                        } else {
+                            class
+                        }
+                    } else {
+                        class
+                    };
+                    let regs = param_register_by_class
+                        .get_or_insert_with_mut(class.clone(), |cl| tag.param_regs_for_class(cl));
+                    let reg = match tag.register_disposition(&class) {
+                        RegisterDisposition::Interleave => {
+                            if let Some((l, r)) = regs.split_first() {
+                                let l = l.clone();
+                                *regs = r;
+                                Some(l)
+                            } else {
+                                None
+                            }
+                        }
+                        RegisterDisposition::Consume => {
+                            if let Some(val) = regs.get(total_params_consumed) {
+                                total_params_consumed += 1;
+                                Some(val.clone())
+                            } else {
+                                None
+                            }
+                        }
+                    };
+
+                    if let Some(reg) = reg {
+                        param_locs.push(CallConvLocation::Register(reg))
+                    } else {
+                        todo!("stack")
+                    }
+                }
+            }
+
+            if split_locs.is_empty() {
+                param_locs.push(CallConvLocation::Null);
+            } else if split_locs.len() == 1 {
+                let val = split_locs.pop().unwrap();
+                param_locs.push(val);
+            } else {
+                param_locs.push(CallConvLocation::Split(split_locs));
+            }
+        }
+    }
+    let return_loc = return_loc.expect("We have a return type, right");
+    drop(return_register_by_class); // These are here for Borrowck: Now I'm missing the dropck_eyepatch on drop code for `HashMap`
+    drop(param_register_by_class);
+    CallConv {
+        params: param_locs,
+        stacked_params_count: 0,
+        ret_location: return_loc,
+        tag,
+        is_varargs,
     }
 }
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index 595ef704..bbdd7bc4 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -13,11 +13,11 @@ use xlang::{
     abi::{io::WriteAdapter, option::Some as XLangSome, pair::Pair, try_},
     ir::{self, Linkage},
     plugin::{XLangCodegen, XLangPlugin},
-    targets::properties::TargetProperties,
+    targets::properties::{StackAttributeControlStyle, TargetProperties},
 };
 
 use binfmt::{
-    fmt::{Section, SectionFlag},
+    fmt::{Section, SectionFlag, SectionType},
     sym::{Symbol, SymbolKind, SymbolType},
 };
 
@@ -275,7 +275,22 @@ impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
                     syms.push(Symbol::new_undef(sym_name, SymbolType::Function, sym_kind));
                 }
             }
-
+            match targ.link.stack_attribute_control {
+                StackAttributeControlStyle::NoExec => {}
+                StackAttributeControlStyle::CveFactory => {
+                    eprintln!("Warning: Codegen for target selected sets Stack as Writable")
+                }
+                StackAttributeControlStyle::GnuStack => {
+                    sections.push(Section {
+                        name: format!(".note.GNU-stack"),
+                        align: 1024,
+                        ty: SectionType::NoBits,
+                        flags: Some(SectionFlag::Writable.into()),
+                        ..Default::default()
+                    });
+                }
+                ctrl => eprintln!("Warning: Unknown stack attribute control style {:?}", ctrl),
+            }
             let mut section_map = vec![];
             for section in sections {
                 let new_off = output
diff --git a/xlang/xlang_backend/src/mach.rs b/xlang/xlang_backend/src/mach.rs
index e5b7f516..e858ab98 100644
--- a/xlang/xlang_backend/src/mach.rs
+++ b/xlang/xlang_backend/src/mach.rs
@@ -1,8 +1,12 @@
-use xlang::{abi::string::StringView, targets::properties::TargetProperties};
+use xlang::{
+    abi::collection::HashMap, abi::string::StringView, targets::properties::TargetProperties,
+    vec::Vec,
+};
 
 use crate::{
     mangle::mangle_itanium,
     ssa::{OpaqueLocation, SsaInstruction},
+    ty::TypeInformation,
 };
 
 use arch_ops::traits::InsnWrite;
@@ -21,6 +25,8 @@ pub trait Machine {
         insns: &[SsaInstruction],
         incoming: &[OpaqueLocation],
         which: u32,
+        incoming_set: &HashMap<u32, Vec<OpaqueLocation>>,
+        tys: &TypeInformation,
     ) -> Self::BlockClobbers;
     fn codegen_prologue<W: InsnWrite>(
         &self,
@@ -35,6 +41,7 @@ pub trait Machine {
         out: &mut W,
         label_sym: F,
         which: u32,
+        tys: &TypeInformation,
     ) -> std::io::Result<()>;
     fn mangle(&self, path: &[xlang::ir::PathComponent]) -> String {
         mangle_itanium(path)
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 820b1b75..03262bd4 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -94,6 +94,7 @@ impl core::fmt::Display for SsaInstruction {
 pub struct CallTarget {
     pub ptr: OpaquePtr,
     pub real_ty: ir::FnType,
+    pub call_ty: ir::FnType,
 }
 
 impl core::fmt::Display for CallTarget {
@@ -253,12 +254,15 @@ impl<M: Machine> FunctionBuilder<M> {
                 &bb.insns,
                 self.incoming_locations.get(&bb.id).unwrap(),
                 bb.id,
+                &self.incoming_locations,
+                &self.tys,
             ));
         }
 
         self.mach.codegen_prologue(&assigns, out)?;
         for (bb, block_clobbers) in self.basic_blocks.iter().zip(block_clobbers) {
             let symbol = format!("{}._B{}", self.sym_name, bb.id);
+            sym_accepter(symbol, out.offset() as u128);
             self.mach.codegen_block(
                 &assigns,
                 &bb.insns,
@@ -266,6 +270,7 @@ impl<M: Machine> FunctionBuilder<M> {
                 out,
                 |id| format!("{}._B{}", self.sym_name, id),
                 bb.id,
+                &self.tys,
             )?;
         }
         Ok(())
@@ -390,6 +395,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
         &mut self,
         targ: VStackValue<OpaqueLocation>,
         params: Vec<VStackValue<OpaqueLocation>>,
+        call_ty: ir::FnType,
         next: Option<ir::JumpTarget>,
     ) {
         match targ {
@@ -417,6 +423,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
                         CallTarget {
                             ptr: OpaquePtr::Symbol(sym),
                             real_ty,
+                            call_ty,
                         },
                         params,
                     ));
@@ -489,7 +496,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
 
                 let target = self.pop();
 
-                self.write_call(target, vals, None);
+                self.write_call(target, vals, (**call_fnty).clone(), None);
             }
             ir::Terminator::Exit(_) => todo!("exit"),
             ir::Terminator::Asm(_) => todo!("asm"),
diff --git a/xlang/xlang_backend/src/ty.rs b/xlang/xlang_backend/src/ty.rs
index 54402799..93dc417d 100644
--- a/xlang/xlang_backend/src/ty.rs
+++ b/xlang/xlang_backend/src/ty.rs
@@ -2,8 +2,9 @@ use std::convert::TryInto;
 
 use xlang::{
     ir::{
-        AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule, PointerKind,
-        ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type, ValidRangeType, Value,
+        self, AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule,
+        PointerKind, ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type,
+        ValidRangeType, Value,
     },
     prelude::v1::{HashMap, Pair, Some as XLangSome},
     targets::properties::TargetProperties,
@@ -11,6 +12,8 @@ use xlang::{
 
 use crate::expr::{LValue, NoOpaque, VStackValue};
 
+use core::cell::RefCell;
+
 pub(crate) fn scalar_align(size: u64, max_align: u16) -> u64 {
     if size <= (max_align as u64) {
         size.next_power_of_two()
@@ -40,13 +43,54 @@ pub struct AggregateLayout {
 
 ///
 /// A map of information about the types on the system
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct TypeInformation {
     aggregates: HashMap<Path, Option<AggregateDefinition>>,
     aliases: HashMap<Path, Type>,
+    aggregate_layout_cache: RefCell<HashMap<Type, Box<AggregateLayout>>>,
     properties: &'static TargetProperties<'static>,
 }
 
+pub struct FlattenFieldsOf<'a> {
+    fields_stack: Vec<std::vec::IntoIter<(u64, &'a Type)>>,
+
+    tys: &'a TypeInformation,
+}
+
+impl<'a> FlattenFieldsOf<'a> {
+    fn push_fields_of(&mut self, base_offset: u64, agl: &'a AggregateLayout) {
+        let mut fields = vec![];
+
+        for Pair(_, (offset, ty)) in &agl.fields {
+            fields.push((*offset + base_offset, ty));
+        }
+
+        fields.sort_by_key(|(off, _)| *off);
+
+        self.fields_stack.push(fields.into_iter());
+    }
+
+    fn push_fields_of_array(&mut self, base_off: u64, arr_ty: &'a ir::ArrayType) {
+        let mut fields = vec![];
+        let ty = &arr_ty.ty;
+        let size = self
+            .tys
+            .type_size(ty)
+            .expect("array type must have a complete value type as a field");
+
+        let len = match &arr_ty.len {
+            Value::Integer { val, .. } => (*val) as u64,
+            val => panic!("Cannot determine length of array from {}", val),
+        };
+
+        for i in 0..len {
+            fields.push((base_off + i * size, ty));
+        }
+
+        self.fields_stack.push(fields.into_iter());
+    }
+}
+
 impl TypeInformation {
     /// Constructs a new set of [`TypeInformation`] from the properties of a given target
     pub fn from_properties(properties: &'static TargetProperties) -> Self {
@@ -54,6 +98,7 @@ impl TypeInformation {
             properties,
             aliases: HashMap::new(),
             aggregates: HashMap::new(),
+            aggregate_layout_cache: RefCell::new(HashMap::new()),
         }
     }
 
@@ -190,7 +235,7 @@ impl TypeInformation {
     }
 
     /// Computes the layout of an aggregate type from it's definition
-    pub fn aggregate_layout_from_defn(&self, defn: &AggregateDefinition) -> AggregateLayout {
+    fn aggregate_layout_from_defn(&self, defn: &AggregateDefinition) -> AggregateLayout {
         let mut align = 1u64;
         let mut size = 0u64;
         let mut fields = HashMap::new();
@@ -262,44 +307,58 @@ impl TypeInformation {
     }
 
     /// Determines the total aggregate layout of a type
-    pub fn aggregate_layout(&self, ty: &Type) -> Option<AggregateLayout> {
-        match ty {
-            Type::TaggedType(_, ty) => self.aggregate_layout(ty),
-            Type::Aligned(_, ty) => self.aggregate_layout(ty),
-            Type::Product(elems) => {
-                let mut elems = elems.clone();
-                elems.sort_by_key(|ty| self.type_align(ty).unwrap());
-
-                let mut align = 1u64;
-                let mut size = 0u64;
-                let mut fields = HashMap::new();
-
-                for (i, field) in elems.into_iter().enumerate() {
-                    align = self.type_align(&field)?.max(align);
-                    let offset = size;
-                    size += self.type_size(&field)?;
-                    fields.insert(i.to_string(), (offset, field));
-                }
+    pub fn aggregate_layout(&self, ty: &Type) -> Option<&AggregateLayout> {
+        let cache = self.aggregate_layout_cache.borrow();
+        if let Some(layout) = cache.get(ty) {
+            unsafe { Some(&*((&**layout) as *const AggregateLayout)) }
+        } else {
+            drop(cache);
+            let layout = match ty {
+                Type::TaggedType(_, ty) => return self.aggregate_layout(ty),
+                Type::Aligned(_, ty) => return self.aggregate_layout(ty),
+                Type::Product(elems) => {
+                    let mut elems = elems.clone();
+                    elems.sort_by_key(|ty| self.type_align(ty).unwrap());
+
+                    let mut align = 1u64;
+                    let mut size = 0u64;
+                    let mut fields = HashMap::new();
+
+                    for (i, field) in elems.into_iter().enumerate() {
+                        align = self.type_align(&field)?.max(align);
+                        let offset = size;
+                        size += self.type_size(&field)?;
+                        fields.insert(i.to_string(), (offset, field));
+                    }
 
-                Some(AggregateLayout {
-                    total_size: size,
-                    total_align: align,
-                    fields,
-                    transparent_over: None,
-                    first_niche: None,
-                })
-            }
-            Type::Aggregate(defn) => Some(self.aggregate_layout_from_defn(defn)),
-            Type::Named(p) => {
-                if let Some(ty) = self.aliases.get(p) {
-                    self.aggregate_layout(ty)
-                } else if let Some(Some(defn)) = self.aggregates.get(p) {
-                    Some(self.aggregate_layout_from_defn(defn))
-                } else {
-                    None
+                    Some(AggregateLayout {
+                        total_size: size,
+                        total_align: align,
+                        fields,
+                        transparent_over: None,
+                        first_niche: None,
+                    })
+                }
+                Type::Aggregate(defn) => Some(self.aggregate_layout_from_defn(defn)),
+                Type::Named(p) => {
+                    if let Some(ty) = self.aliases.get(p) {
+                        return self.aggregate_layout(ty);
+                    } else if let Some(Some(defn)) = self.aggregates.get(p) {
+                        Some(self.aggregate_layout_from_defn(defn))
+                    } else {
+                        None
+                    }
                 }
+                _ => None,
+            };
+
+            if let Some(layout) = layout {
+                let mut cache = self.aggregate_layout_cache.borrow_mut();
+                cache.insert(ty.clone(), Box::new(layout));
+                unsafe { Some(&*((&*cache[ty]) as *const AggregateLayout)) }
+            } else {
+                None
             }
-            _ => None,
         }
     }
 
@@ -403,7 +462,7 @@ impl TypeInformation {
     /// Gets the type of the field of `ty` with a given name
     pub fn get_field_type(&self, ty: &Type, name: &str) -> Option<Type> {
         self.aggregate_layout(ty)
-            .map(|layout| layout.fields)
+            .map(|layout| &layout.fields)
             .map(|fields| fields.get(name).cloned().map(|(_, ty)| ty))
             .and_then(Into::into)
     }

From 26331d4be09e152d4c22e8eec6d6b3916451bf18 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 2 Feb 2024 12:48:02 -0500
Subject: [PATCH 11/74] chore: update lc-binutils

---
 lc-binutils | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lc-binutils b/lc-binutils
index 967ded32..39d2cf0a 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 967ded327dff8b16e8f04474b359fe565b3519f9
+Subproject commit 39d2cf0a5b1aba7dafb1fb5eada9e9ce4c4cc7e7

From b2d8ecdd2bb729e36e1d10cef04b39f511dbc424 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 2 Feb 2024 20:17:15 -0500
Subject: [PATCH 12/74] feat(rust-sema): Typecheck, lower, and visit character
 literals

---
 lccc/src/manifest.rs                       | 144 ++++++++++++++++++-
 lccc/src/manifest/parse.rs                 |   0
 rust/src/irgen/visitor.rs                  |  17 +++
 rust/src/irgen/xir_visitor.rs              |  54 ++++++-
 rust/src/sema/hir.rs                       |  86 ++++++++++-
 rust/src/sema/mir.rs                       |  29 +++-
 rust/src/sema/mir/transform/unreachable.rs |   1 +
 rust/src/sema/mir_defs.rs                  |   1 +
 rust/src/sema/ty.rs                        |   3 +-
 rust/src/sema/tyck.rs                      | 159 ++++++++++++++++-----
 10 files changed, 452 insertions(+), 42 deletions(-)
 create mode 100644 lccc/src/manifest/parse.rs

diff --git a/lccc/src/manifest.rs b/lccc/src/manifest.rs
index 3754ff84..cf42146a 100644
--- a/lccc/src/manifest.rs
+++ b/lccc/src/manifest.rs
@@ -1 +1,143 @@
-pub struct OptimizerManifest {}
+pub mod parse;
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum MatcherFragment<'a> {
+    String(&'a str),
+    Glob(&'a str, Box<MatcherFragment<'a>>),
+    GlobChar(&'a str, Box<MatcherFragment<'a>>),
+}
+
+impl<'a> MatcherFragment<'a> {
+    pub fn match_length(&self) -> (usize, Option<usize>) {
+        match self {
+            MatcherFragment::String(val) => (val.len(), Some(val.len())),
+            MatcherFragment::Glob(left, right) => {
+                let (right_min, _) = right.match_length();
+
+                (left.len() + right_min, None)
+            }
+            MatcherFragment::GlobChar(left, right) => {
+                let (right_min, right_max) = right.match_length();
+
+                (
+                    right_min + 1 + left.len(),
+                    right_max.map(|max| max + 1 + left.len()),
+                )
+            }
+        }
+    }
+    pub fn matches(&self, val: &'a str) -> bool {
+        match self {
+            MatcherFragment::String(x) => *x == val,
+            MatcherFragment::Glob(left, right) => {
+                if let Some(x) = val.strip_prefix(*left) {
+                    let (right_min, right_max) = right.match_length();
+
+                    let x_len = x.len();
+
+                    let possible_base = if let Some(right_max) = right_max {
+                        let mut off = x_len.saturating_sub(right_max);
+                        while !x.is_char_boundary(off) {
+                            off += 1;
+                        }
+                        &x[off..]
+                    } else {
+                        x
+                    };
+
+                    let mut iter = possible_base.chars();
+
+                    loop {
+                        if iter.as_str().len() < right_min {
+                            break false;
+                        } else if right.matches(iter.as_str()) {
+                            break true;
+                        } else {
+                            iter.next();
+                        }
+                    }
+                } else {
+                    false
+                }
+            }
+            MatcherFragment::GlobChar(left, right) => {
+                if let Some(x) = val.strip_prefix(*left) {
+                    if x.is_empty() {
+                        false
+                    } else {
+                        let mut iter = x.chars();
+                        iter.next();
+                        right.matches(iter.as_str())
+                    }
+                } else {
+                    false
+                }
+            }
+        }
+    }
+
+    pub fn parse(x: &'a str) -> Self {
+        if let Some(val) = x.find(['*', '?']) {
+            let (l, r) = x.split_at(val);
+            let (c, r) = r.split_at(1); // We've matched an ASCII Char, so it's exactly 1 byte long
+
+            let right = Box::new(Self::parse(r));
+
+            match c {
+                "*" => MatcherFragment::Glob(l, right),
+                "?" => MatcherFragment::GlobChar(l, right),
+                _ => unreachable!(),
+            }
+        } else {
+            Self::String(x)
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SelectorManifest<'a> {
+    pub lines: Vec<PluginSelector<'a>>,
+}
+
+impl<'a> SelectorManifest<'a> {
+    pub fn parse(x: &'a str) -> Self {
+        Self {
+            lines: x
+                .lines()
+                .map(|x| {
+                    if let Some((x, _comment)) = x.split_once(';') {
+                        x
+                    } else {
+                        x
+                    }
+                })
+                .map(str::trim)
+                .filter(|x| !x.is_empty())
+                .map(PluginSelector::parse)
+                .collect(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct PluginSelector<'a> {
+    pub matchers: Vec<MatcherFragment<'a>>,
+    pub plugin: &'a str,
+}
+
+impl<'a> PluginSelector<'a> {
+    pub fn parse(x: &'a str) -> Self {
+        if let Some((matchers, plugins)) = x.split_once(':') {
+            let matchers = matchers
+                .split(',')
+                .map(|x| x.trim())
+                .map(MatcherFragment::parse)
+                .collect();
+
+            let plugin = plugins.trim();
+            Self { matchers, plugin }
+        } else {
+            panic!("Invalid plugin")
+        }
+    }
+}
diff --git a/lccc/src/manifest/parse.rs b/lccc/src/manifest/parse.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/rust/src/irgen/visitor.rs b/rust/src/irgen/visitor.rs
index c1ac4550..02a4806b 100644
--- a/rust/src/irgen/visitor.rs
+++ b/rust/src/irgen/visitor.rs
@@ -2,6 +2,7 @@ use ty::Spanned;
 use xlang::abi::pair::Pair;
 
 use crate::{
+    ast::CharType,
     interning::Symbol,
     lex::StringType,
     sema::{
@@ -564,6 +565,16 @@ pub fn visit_expr<V: ExprVisitor>(mut visitor: V, expr: &mir::MirExpr, defs: &De
         mir::MirExpr::UnaryExpr(op, lhs) => {
             visit_unary_expr(visitor.visit_unary_expr(), op, lhs, defs)
         }
+        mir::MirExpr::ConstChar(ty, val) => {
+            let mut visitor = visitor.visit_const_char();
+
+            if visitor.is_none() {
+                return;
+            }
+            visitor.visit_charty(*ty);
+
+            visitor.visit_value(*val);
+        }
     }
 }
 
@@ -726,6 +737,7 @@ def_visitors! {
     pub trait ExprVisitor {
         fn visit_unreachable(&mut self);
         fn visit_const_int(&mut self) -> Option<Box<dyn ConstIntVisitor +'_>>;
+        fn visit_const_char(&mut self) -> Option<Box<dyn ConstCharVisitor + '_>>;
         fn visit_const(&mut self, defid: DefId);
         fn visit_cast(&mut self) -> Option<Box<dyn CastVisitor + '_>>;
         fn visit_const_string(&mut self) -> Option<Box<dyn ConstStringVisitor + '_>>;
@@ -747,6 +759,11 @@ def_visitors! {
         fn visit_value(&mut self, val: u128);
     }
 
+    pub trait ConstCharVisitor {
+        fn visit_charty(&mut self, ty: CharType);
+        fn visit_value(&mut self, val: u32);
+    }
+
     pub trait CastVisitor {
         fn visit_inner(&mut self) -> Option<Box<dyn ExprVisitor + '_>>;
         fn visit_cast_type(&mut self) -> Option<Box<dyn TypeVisitor + '_>>;
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 2ce664d4..802e0af1 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -16,6 +16,7 @@ use xlang::{
     ir::PathComponent,
 };
 
+use crate::lex::CharType;
 use crate::sema::mir;
 use crate::sema::{cx, hir::BinaryOp, mir::SsaVarId};
 use crate::sema::{generics, ty, UserTypeKind};
@@ -30,7 +31,7 @@ use crate::{lex::StringType, sema::Definitions};
 
 use super::visitor::{
     ArrayTyVisitor, AttrVisitor, BasicBlockVisitor, BinaryExprVisitor, BranchArmVisitor,
-    BranchVisitor, CallVisitor, CastVisitor, ConstIntVisitor, ConstStringVisitor,
+    BranchVisitor, CallVisitor, CastVisitor, ConstCharVisitor, ConstIntVisitor, ConstStringVisitor,
     ConstructorDefVisitor, ConstructorVisitor, ExprVisitor, FieldAccessVisitor, FieldInitVisitor,
     FieldVisitor, FunctionBodyVisitor, FunctionDefVisitor, FunctionTyVisitor, IntTyVisitor,
     JumpVisitor, LetStatementVisitor, ModVisitor, PointerTyVisitor, ReferenceTyVisitor,
@@ -646,6 +647,17 @@ const NEVER: ir::Type = ir::Type::Scalar(ir::ScalarType {
     },
 });
 
+const CHAR: ir::Type = ir::Type::Scalar(ir::ScalarType {
+    kind: ScalarTypeKind::Char {
+        flags: ir::CharFlags::UNICODE,
+    },
+    header: ir::ScalarTypeHeader {
+        bitsize: 32,
+        vectorsize: XLangNone,
+        validity: ir::ScalarValidity::empty(),
+    },
+});
+
 impl<'a> XirTypeVisitor<'a> {
     fn new(
         defs: &'a Definitions,
@@ -1635,6 +1647,21 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
         )))
     }
 
+    fn visit_const_char(&mut self) -> Option<Box<dyn ConstCharVisitor + '_>> {
+        let (intty, val) = match self.exprs.push_mut(ir::Expr::Const(ir::Value::Integer {
+            ty: ir::ScalarType::default(),
+            val: 0,
+        })) {
+            ir::Expr::Const(ir::Value::Integer { ty, val }) => (ty, val),
+            _ => unsafe { core::hint::unreachable_unchecked() },
+        };
+        Some(Box::new(XirConstIntVisitor::new(
+            self.properties,
+            val,
+            intty,
+        )))
+    }
+
     fn visit_const(&mut self, defid: DefId) {
         let name = self.names[&defid];
 
@@ -2443,3 +2470,28 @@ impl<'a> ConstIntVisitor for XirConstIntVisitor<'a> {
         *self.val = val;
     }
 }
+
+impl<'a> ConstCharVisitor for XirConstIntVisitor<'a> {
+    fn visit_charty(&mut self, ty: crate::lex::CharType) {
+        match ty {
+            CharType::Default => {
+                self.intty.kind = ir::ScalarTypeKind::Char {
+                    flags: ir::CharFlags::UNICODE,
+                };
+                self.intty.header.bitsize = 32;
+            }
+            CharType::Byte => {
+                self.intty.kind = ir::ScalarTypeKind::Integer {
+                    signed: false,
+                    min: XLangNone,
+                    max: XLangNone,
+                };
+                self.intty.header.bitsize = 8;
+            }
+        }
+    }
+
+    fn visit_value(&mut self, val: u32) {
+        *self.val = val as u128;
+    }
+}
diff --git a/rust/src/sema/hir.rs b/rust/src/sema/hir.rs
index 116460f6..8b58e303 100644
--- a/rust/src/sema/hir.rs
+++ b/rust/src/sema/hir.rs
@@ -85,7 +85,7 @@ pub enum HirExpr {
     Var(HirVarId),
     ConstInt(Option<Spanned<IntType>>, u128),
     ConstString(StringType, Spanned<Symbol>),
-    ConstChar(CharType, Spanned<Symbol>),
+    ConstChar(CharType, u32),
     Const(DefId, GenericArgs),
     #[allow(dead_code)]
     Unreachable,
@@ -128,9 +128,22 @@ impl core::fmt::Display for HirExpr {
                 s.escape_default().fmt(f)?;
                 f.write_str("\"")
             }
-            HirExpr::ConstChar(_, s) => {
+            HirExpr::ConstChar(CharType::Default, val) => {
                 f.write_str("'")?;
-                s.escape_default().fmt(f)?;
+                if let Some(c) = char::from_u32(*val) {
+                    c.escape_default().fmt(f)?;
+                } else {
+                    f.write_fmt(format_args!("\\u{{invalid char: {:04x}}}", val))?;
+                }
+
+                f.write_str("'")
+            }
+            HirExpr::ConstChar(CharType::Byte, val) => {
+                f.write_str("'")?;
+                match val {
+                    &val @ 0x20..=0x7F => (val as u8 as char).fmt(f)?,
+                    val => f.write_fmt(format_args!("\\x{:02x}", val))?,
+                }
                 f.write_str("'")
             }
             HirExpr::Tuple(v) => {
@@ -722,7 +735,72 @@ impl<'a> HirLowerer<'a> {
                 Literal {
                     lit_kind: LiteralKind::Char(cty),
                     val: sym,
-                } => Ok(expr.copy_span(|_| HirExpr::ConstChar(cty, sym))),
+                } => {
+                    dbg!(sym);
+                    let mut c = sym.chars().peekable();
+
+                    let val = match c.next().expect("We have at least one character") {
+                        '\\' => match c.next().expect("malformed escape sequence") {
+                            't' => '\t' as u32,
+                            'n' => '\n' as u32,
+                            'r' => '\r' as u32,
+                            '\'' => '\'' as u32,
+                            '"' => '"' as u32,
+                            '0' => 0,
+                            '\\' => '\\' as u32,
+                            'x' => {
+                                let mut val = 0;
+
+                                match c
+                                    .next()
+                                    .expect("Malformed escape sequence - error in lexer")
+                                {
+                                    c => val = c.to_digit(16).expect("Malformed escape sequence"),
+                                }
+
+                                match c
+                                    .peek()
+                                    .expect("Malformed character literal - error in lexer")
+                                {
+                                    '\'' => {}
+                                    &v => {
+                                        c.next();
+                                        val <<= 4;
+                                        val |= v
+                                            .to_digit(16)
+                                            .expect("Malformed character literal - error in lexer");
+                                    }
+                                }
+
+                                val
+                            }
+                            'u' => {
+                                assert_eq!(
+                                    c.next(),
+                                    Some('{'),
+                                    "Malformed escape sequence - error in lexer"
+                                );
+                                let mut val = 0;
+                                for c in &mut c {
+                                    match c {
+                                        '}' => break,
+                                        c => {
+                                            val <<= 4;
+                                            val |= c.to_digit(16).expect(
+                                                "Malformed character literal - error in lexer",
+                                            );
+                                        }
+                                    }
+                                }
+                                val
+                            }
+                            val => panic!("Expected an escape sequence, got {}", val),
+                        },
+                        val => val as u32,
+                    };
+
+                    Ok(expr.copy_span(|_| HirExpr::ConstChar(cty, val)))
+                }
                 _ => todo!("literal"),
             },
             ast::Expr::Break(_, _) => todo!("break"),
diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index 7741c539..35eea8de 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -4,7 +4,7 @@ use xlang::abi::{
 };
 
 use crate::{
-    ast::{Mutability, StringType},
+    ast::{CharType, Mutability, StringType},
     helpers::{FetchIncrement, TabPrinter},
     interning::Symbol,
     lex::Error,
@@ -119,6 +119,24 @@ impl core::fmt::Display for MirExpr {
             MirExpr::ConstString(_, val) => {
                 f.write_fmt(format_args!("\"{}\"", val.escape_default()))
             }
+            MirExpr::ConstChar(CharType::Default, val) => {
+                f.write_str("'")?;
+                if let Some(c) = char::from_u32(*val) {
+                    c.escape_default().fmt(f)?;
+                } else {
+                    f.write_fmt(format_args!("\\u{{invalid char: {:04x}}}", val))?;
+                }
+
+                f.write_str("'")
+            }
+            MirExpr::ConstChar(CharType::Byte, val) => {
+                f.write_str("'")?;
+                match val {
+                    &val @ 0x20..=0x7F => (val as u8 as char).fmt(f)?,
+                    val => f.write_fmt(format_args!("\\x{:02x}", val))?,
+                }
+                f.write_str("'")
+            }
             MirExpr::Const(defid, generics) => f.write_fmt(format_args!("{}{}", defid, generics)),
             MirExpr::Retag(rk, mt, inner) => {
                 f.write_str("&")?;
@@ -525,6 +543,7 @@ impl<'a> MirConverter<'a> {
             ThirExprInner::Const(_, _)
             | ThirExprInner::ConstInt(_, _)
             | ThirExprInner::ConstString(_, _)
+            | ThirExprInner::ConstChar(_, _)
             | ThirExprInner::Cast(_, _)
             | ThirExprInner::Tuple(_)
             | ThirExprInner::Read(_)
@@ -720,7 +739,8 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::BinaryExpr(_, _, _)
             | ThirExprInner::Array(_)
             | ThirExprInner::UnaryExpr(_, _)
-            | ThirExprInner::Index(_, _) => unreachable!("cannot access"),
+            | ThirExprInner::Index(_, _)
+            | ThirExprInner::ConstChar(_, _) => unreachable!("cannot access"),
         }
     }
 
@@ -807,6 +827,10 @@ impl<'a> MirConverter<'a> {
                 span,
                 body: MirExpr::ConstString(sty, *val),
             }),
+            super::tyck::ThirExprInner::ConstChar(cty, val) => Ok(Spanned {
+                span,
+                body: MirExpr::ConstChar(cty, val),
+            }),
             super::tyck::ThirExprInner::Cast(inner, ty) => {
                 let inner = self.lower_expr(*inner)?;
 
@@ -1016,6 +1040,7 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Const(_, _)
             | ThirExprInner::ConstInt(_, _)
             | ThirExprInner::ConstString(_, _)
+            | ThirExprInner::ConstChar(_, _)
             | ThirExprInner::Cast(_, _)
             | ThirExprInner::Tuple(_)
             | ThirExprInner::Ctor(_)
diff --git a/rust/src/sema/mir/transform/unreachable.rs b/rust/src/sema/mir/transform/unreachable.rs
index 0f085183..6f9034fc 100644
--- a/rust/src/sema/mir/transform/unreachable.rs
+++ b/rust/src/sema/mir/transform/unreachable.rs
@@ -33,6 +33,7 @@ impl PropagateUnreachable {
             }
             MirExpr::UnaryExpr(_, u) => Self::expr_contains_unreachable(u),
             MirExpr::GetSymbol(_) => false,
+            MirExpr::ConstChar(_, _) => false,
         }
     }
 }
diff --git a/rust/src/sema/mir_defs.rs b/rust/src/sema/mir_defs.rs
index 50777a11..c151bf97 100644
--- a/rust/src/sema/mir_defs.rs
+++ b/rust/src/sema/mir_defs.rs
@@ -65,6 +65,7 @@ pub enum MirExpr {
     AllocaDrop(Type, DropFlagState),
     ConstInt(IntType, u128),
     ConstString(StringType, Symbol),
+    ConstChar(CharType, u32),
     Const(DefId, GenericArgs),
     Retag(RefKind, Mutability, Box<Spanned<MirExpr>>),
     Cast(Box<Spanned<MirExpr>>, Type),
diff --git a/rust/src/sema/ty.rs b/rust/src/sema/ty.rs
index 667a301b..e5085ddb 100644
--- a/rust/src/sema/ty.rs
+++ b/rust/src/sema/ty.rs
@@ -92,7 +92,7 @@ pub enum Type {
     IncompleteAlias(DefId),
     Pointer(Spanned<Mutability>, Box<Spanned<Type>>),
     Array(Box<Spanned<Type>>, Spanned<ConstExpr>),
-    Inferable(InferId),
+    Inferable(Option<InferId>),
     InferableInt(InferId),
     Reference(
         Option<Box<Spanned<SemaLifetime>>>,
@@ -723,6 +723,7 @@ impl core::fmt::Display for Type {
 
 pub fn convert_builtin_type(name: &str) -> Option<Type> {
     match name {
+        "_" => Some(Type::Inferable(None)),
         "char" => Some(Type::Char),
         "str" => Some(Type::Str),
         x if x.starts_with('i') || x.starts_with('u') => {
diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
index 9d71c40a..21221634 100644
--- a/rust/src/sema/tyck.rs
+++ b/rust/src/sema/tyck.rs
@@ -1,7 +1,7 @@
 use xlang::abi::collection::{HashMap, HashSet};
 
 use crate::{
-    ast::{self, Mutability, Safety, StringType},
+    ast::{self, CharType, Mutability, Safety, StringType},
     helpers::{CyclicOperationStatus, FetchIncrement, TabPrinter},
     interning::Symbol,
     span::Span,
@@ -140,6 +140,7 @@ pub enum ThirExprInner {
     Const(DefId, GenericArgs),
     ConstInt(Option<Spanned<IntType>>, u128),
     ConstString(StringType, Spanned<Symbol>),
+    ConstChar(CharType, u32),
     Cast(Box<Spanned<ThirExpr>>, Spanned<Type>),
     Tuple(Vec<Spanned<ThirExpr>>),
     Ctor(Spanned<ThirConstructor>),
@@ -210,6 +211,24 @@ impl core::fmt::Display for ThirExprInner {
                 str.escape_default().fmt(f)?;
                 f.write_str("\"")
             }
+            ThirExprInner::ConstChar(CharType::Default, val) => {
+                f.write_str("'")?;
+                if let Some(c) = char::from_u32(*val) {
+                    c.escape_default().fmt(f)?;
+                } else {
+                    f.write_fmt(format_args!("\\u{{invalid char: {:04x}}}", val))?;
+                }
+
+                f.write_str("'")
+            }
+            ThirExprInner::ConstChar(CharType::Byte, val) => {
+                f.write_str("'")?;
+                match val {
+                    &val @ 0x20..=0x7F => (val as u8 as char).fmt(f)?,
+                    val => f.write_fmt(format_args!("\\x{:02x}", val))?,
+                }
+                f.write_str("'")
+            }
             ThirExprInner::Cast(e, ty) => {
                 f.write_str("(")?;
                 e.body.fmt(f)?;
@@ -610,6 +629,61 @@ impl<'a> ThirConverter<'a> {
         Ok(ret)
     }
 
+    pub fn convert_syntatic_type(&mut self, ty: Spanned<Type>) -> Spanned<Type> {
+        ty.map_span(|ty| match ty {
+            Type::Inferable(None) => {
+                Type::Inferable(Some(InferId(self.next_infer.fetch_increment())))
+            }
+
+            Type::IncompleteAlias(_) => todo!("incomplete alias"),
+
+            Type::Tuple(tys) => Type::Tuple(
+                tys.into_iter()
+                    .map(|ty| self.convert_syntatic_type(ty))
+                    .collect(),
+            ),
+            Type::FnPtr(mut fnty) => {
+                fnty.paramtys = fnty
+                    .paramtys
+                    .into_iter()
+                    .map(|ty| self.convert_syntatic_type(ty))
+                    .collect();
+                *fnty.retty = self.convert_syntatic_type(*fnty.retty);
+
+                Type::FnPtr(fnty)
+            }
+
+            Type::Pointer(mt, mut ty) => {
+                *ty = self.convert_syntatic_type(*ty);
+
+                Type::Pointer(mt, ty)
+            }
+            Type::Array(mut ty, cx) => {
+                *ty = self.convert_syntatic_type(*ty);
+
+                Type::Array(ty, cx)
+            }
+            Type::Reference(life, mt, mut ty) => {
+                *ty = self.convert_syntatic_type(*ty);
+
+                Type::Reference(life, mt, ty)
+            }
+            val @ (Type::Inferable(Some(_))
+            | Type::InferableInt(_)
+            | Type::Param(_)
+            | Type::TraitSelf(_)
+            | Type::DropFlags(_)
+            | Type::Bool
+            | Type::Int(_)
+            | Type::Float(_)
+            | Type::Char
+            | Type::Str
+            | Type::FnItem(_, _, _)
+            | Type::UserType(_, _)
+            | Type::Never) => val,
+        })
+    }
+
     pub fn convert_expr(
         &mut self,
         expr: &Spanned<hir::HirExpr>,
@@ -692,8 +766,19 @@ impl<'a> ThirConverter<'a> {
                     cat: ValueCategory::Rvalue,
                 })
             }
-            &hir::HirExpr::ConstChar(cty, val) => {
-                todo!("const char");
+            hir::HirExpr::ConstChar(cty, val) => {
+                let ty = match cty {
+                    CharType::Byte => Type::Int(IntType::u8),
+                    CharType::Default => Type::Char,
+                };
+
+                let inner = ThirExprInner::ConstChar(*cty, *val);
+
+                Ok(ThirExpr {
+                    ty,
+                    inner,
+                    cat: ValueCategory::Rvalue,
+                })
             }
             hir::HirExpr::Const(defid, generics) => {
                 let def = self.defs.definition(*defid);
@@ -718,7 +803,10 @@ impl<'a> ThirConverter<'a> {
             hir::HirExpr::Cast(expr, ty) => Ok(ThirExpr {
                 ty: ty.body.clone(),
                 cat: ValueCategory::Rvalue,
-                inner: ThirExprInner::Cast(Box::new(self.convert_rvalue(expr)?), ty.clone()),
+                inner: ThirExprInner::Cast(
+                    Box::new(self.convert_rvalue(expr)?),
+                    self.convert_syntatic_type(ty.clone()),
+                ),
             }),
             hir::HirExpr::Tuple(vals) => {
                 let vals = vals
@@ -826,7 +914,7 @@ impl<'a> ThirConverter<'a> {
                     .next()
                     .unwrap_or_else(|| {
                         let inferid = InferId(self.next_infer.fetch_increment());
-                        Type::Inferable(inferid)
+                        Type::Inferable(Some(inferid))
                     });
 
                 let inner = ThirExprInner::MemberAccess(Box::new(val), name.clone());
@@ -839,7 +927,7 @@ impl<'a> ThirConverter<'a> {
                     Type::Int(x) => Type::Int(*x),
                     Type::Float(x) => Type::Float(*x),
                     Type::InferableInt(x) => Type::InferableInt(*x),
-                    _ => Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                    _ => Type::Inferable(Some(InferId(self.next_infer.fetch_increment()))),
                 };
                 Ok(ThirExpr {
                     ty,
@@ -854,7 +942,7 @@ impl<'a> ThirConverter<'a> {
                     (Type::Int(x), y) if Type::Int(*x) == *y => Type::Int(*x),
                     (Type::Float(x), y) if Type::Float(*x) == *y => Type::Float(*x),
                     (Type::InferableInt(x), Type::InferableInt(_)) => Type::InferableInt(*x),
-                    _ => Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                    _ => Type::Inferable(Some(InferId(self.next_infer.fetch_increment()))),
                 };
                 Ok(ThirExpr {
                     ty,
@@ -869,7 +957,7 @@ impl<'a> ThirConverter<'a> {
                     .collect::<Result<Vec<_>>>()?;
                 if elements.len() == 0 {
                     Ok(ThirExpr {
-                        ty: Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                        ty: Type::Inferable(Some(InferId(self.next_infer.fetch_increment()))),
                         cat: ValueCategory::Rvalue,
                         inner: ThirExprInner::Array(elements),
                     })
@@ -886,7 +974,7 @@ impl<'a> ThirConverter<'a> {
                 Ok(ThirExpr {
                     ty: match &base.ty {
                         Type::Array(ty, _) => ty.body.clone(),
-                        _ => Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                        _ => Type::Inferable(Some(InferId(self.next_infer.fetch_increment()))),
                     },
                     cat: ValueCategory::Rvalue,
                     inner: ThirExprInner::Index(
@@ -907,7 +995,7 @@ impl<'a> ThirConverter<'a> {
         let matcher = match &matcher.body {
             hir::HirPatternMatcher::Hole => {
                 let infer = InferId(self.next_infer.fetch_increment());
-                let ty = Type::Inferable(infer);
+                let ty = Type::Inferable(Some(infer));
 
                 Spanned {
                     body: ThirPatternMatcher {
@@ -1008,14 +1096,18 @@ impl<'a> ThirConverter<'a> {
                 var,
                 ty,
             } => {
-                let ty = ty.as_ref().cloned().unwrap_or_else(|| {
-                    let infer = InferId(self.next_infer.fetch_increment());
+                let ty = ty
+                    .as_ref()
+                    .cloned()
+                    .map(|ty| self.convert_syntatic_type(ty))
+                    .unwrap_or_else(|| {
+                        let infer = InferId(self.next_infer.fetch_increment());
 
-                    Spanned {
-                        span: var.span,
-                        body: Type::Inferable(infer),
-                    }
-                });
+                        Spanned {
+                            span: var.span,
+                            body: Type::Inferable(Some(infer)),
+                        }
+                    });
 
                 let mutability = *mutability;
 
@@ -1204,13 +1296,13 @@ impl<'a> Inferer<'a> {
     ) -> super::Result<CyclicOperationStatus> {
         match (&mut *left, &mut *right) {
             (a, b) if a == b => Ok(CyclicOperationStatus::Complete),
-            (Type::Inferable(l), Type::Inferable(r)) => {
+            (Type::Inferable(Some(l)), Type::Inferable(Some(r))) => {
                 let l = *l;
                 let r = *r;
 
                 // Note: We do RTL Propagation here. The left type is typically the assignee and the right type is typically the assigned
                 // This *should* narrow the inference set quicker in general
-                *left = Type::Inferable(r);
+                *left = Type::Inferable(Some(r));
 
                 if let Some(ty) = self.inference_set.get_mut(&l) {
                     let mut ty = core::mem::replace(ty, Type::Never);
@@ -1225,12 +1317,12 @@ impl<'a> Inferer<'a> {
                         self.inference_set.insert(r, ty);
                     }
                 } else {
-                    self.inference_set.insert(l, Type::Inferable(r));
+                    self.inference_set.insert(l, Type::Inferable(Some(r)));
                 }
 
                 Ok(CyclicOperationStatus::Incomplete)
             }
-            (Type::InferableInt(l), Type::Inferable(r)) => {
+            (Type::InferableInt(l), Type::Inferable(Some(r))) => {
                 let l = *l;
                 let r = *r;
                 //Note: We're doing LTR propagation here because the left type is more specific.
@@ -1249,17 +1341,17 @@ impl<'a> Inferer<'a> {
                         self.inference_set.insert(r, ty);
                     }
                 } else {
-                    self.inference_set.insert(l, Type::Inferable(r));
+                    self.inference_set.insert(l, Type::Inferable(Some(r)));
                 }
 
                 Ok(CyclicOperationStatus::Incomplete)
             }
-            (Type::Inferable(l), Type::InferableInt(r)) => {
+            (Type::Inferable(Some(l)), Type::InferableInt(r)) => {
                 let l = *l;
                 let r = *r;
 
                 //Note: We do RTL Propagation here because the right type is more specific.
-                *left = Type::Inferable(r);
+                *left = Type::Inferable(Some(r));
 
                 if let Some(ty) = self.inference_set.get_mut(&l) {
                     let mut ty = core::mem::replace(ty, Type::Never);
@@ -1275,12 +1367,12 @@ impl<'a> Inferer<'a> {
                         self.inference_set.insert(r, ty);
                     }
                 } else {
-                    self.inference_set.insert(l, Type::Inferable(r));
+                    self.inference_set.insert(l, Type::Inferable(Some(r)));
                 }
 
                 Ok(CyclicOperationStatus::Incomplete)
             }
-            (Type::Inferable(l), ty) => {
+            (Type::Inferable(Some(l)), ty) => {
                 let l = *l;
 
                 if let Some(gty) = self.inference_set.get_mut(&l) {
@@ -1319,7 +1411,7 @@ impl<'a> Inferer<'a> {
                 }
                 Ok(CyclicOperationStatus::Incomplete)
             }
-            (ty, Type::Inferable(r)) => {
+            (ty, Type::Inferable(Some(r))) => {
                 let r = *r;
 
                 if let Some(gty) = self.inference_set.get_mut(&r) {
@@ -1356,11 +1448,12 @@ impl<'a> Inferer<'a> {
                 status &= self.unify_single_expr(inner)?;
                 status &= self.unify_types(&mut inner.ty, &mut left.ty)?;
             }
-            ThirExprInner::Unreachable => {}
-            ThirExprInner::Var(_) => {}
-            ThirExprInner::Const(_, _) => {}
-            ThirExprInner::ConstInt(_, _) => {}
-            ThirExprInner::ConstString(_, _) => {}
+            ThirExprInner::Unreachable
+            | ThirExprInner::Var(_)
+            | ThirExprInner::Const(_, _)
+            | ThirExprInner::ConstInt(_, _)
+            | ThirExprInner::ConstString(_, _)
+            | ThirExprInner::ConstChar(_, _) => {}
             ThirExprInner::Cast(inner, ty) => {
                 status &= self.unify_single_expr(inner)?;
 
@@ -1753,7 +1846,7 @@ impl<'a> Inferer<'a> {
             }
             Type::Pointer(_, pty) => self.propagate_type(pty),
             Type::Array(inner, _) => self.propagate_type(inner),
-            Type::Inferable(infer) | Type::InferableInt(infer) => {
+            Type::Inferable(Some(infer)) | Type::InferableInt(infer) => {
                 if let Some(subty) = self.inference_set.get(infer) {
                     *ty = subty.clone();
                     Ok(Incomplete)

From 07c92d5144429c7773c7d1355b44efb97663fb59 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Fri, 2 Feb 2024 20:32:01 -0600
Subject: [PATCH 13/74] fix(rust-parse): add prefix to parsed character

---
 lc-binutils          | 2 +-
 rust/src/lex.rs      | 8 ++++----
 rust/src/parse.rs    | 5 +++--
 rust/src/sema/hir.rs | 2 +-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/lc-binutils b/lc-binutils
index 39d2cf0a..967ded32 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 39d2cf0a5b1aba7dafb1fb5eada9e9ce4c4cc7e7
+Subproject commit 967ded327dff8b16e8f04474b359fe565b3519f9
diff --git a/rust/src/lex.rs b/rust/src/lex.rs
index 420eee99..7fe4e806 100644
--- a/rust/src/lex.rs
+++ b/rust/src/lex.rs
@@ -837,19 +837,19 @@ fn do_lexeme(file: &mut Speekable<impl Iterator<Item = char>>) -> Result<Lexeme>
                             } else if file.peek() == Some(&'\'') {
                                 file.next();
                                 let mut result = do_char(file, start)?;
+                                let span = result.span;
                                 match &mut result.body {
                                     LexemeBody::Token(Token {
-                                        ty: TokenType::Character(ref mut char_ty),
-                                        ..
+                                        ty: TokenType::Character(_),
+                                        body,
                                     }) => {
-                                        *char_ty = CharType::Byte;
+                                        break Ok(Token::new(TokenType::Character(CharType::Byte), id + &body).with_span(span));
                                     }
                                     LexemeBody::Token(_) => {
                                         todo!("validation error for \"byte lifetimes\"");
                                     }
                                     _ => unreachable!("do_char returns a Token always"),
                                 }
-                                break Ok(result);
                             }
                         }
                         break Ok(Token::new(ty, id).with_span(Span::new_simple(
diff --git a/rust/src/parse.rs b/rust/src/parse.rs
index 7acf0a14..d7cffa8c 100644
--- a/rust/src/parse.rs
+++ b/rust/src/parse.rs
@@ -3248,8 +3248,8 @@ pub fn do_char(
     };
     let str = full_str.text().unwrap();
     let str = match chr_ty {
-        CharType::Default => &str[1..str.len() - 1], // Skip    " and "
-        CharType::Byte => &str[2..str.len() - 1],    // Skip   b" and "
+        CharType::Default => &str[1..str.len() - 1], // Skip    ' and '
+        CharType::Byte => &str[2..str.len() - 1],    // Skip   b' and '
     };
     let mut parsed = String::new();
     let mut str_iter = str.chars();
@@ -3264,6 +3264,7 @@ pub fn do_char(
             x => parsed.push(x),
         }
     }
+    dbg!(&full_str);
     Ok((
         Spanned {
             body: parsed.into(),
diff --git a/rust/src/sema/hir.rs b/rust/src/sema/hir.rs
index 8b58e303..5b537b68 100644
--- a/rust/src/sema/hir.rs
+++ b/rust/src/sema/hir.rs
@@ -739,7 +739,7 @@ impl<'a> HirLowerer<'a> {
                     dbg!(sym);
                     let mut c = sym.chars().peekable();
 
-                    let val = match c.next().expect("We have at least one character") {
+                    let val = match c.next().expect("missing a character") {
                         '\\' => match c.next().expect("malformed escape sequence") {
                             't' => '\t' as u32,
                             'n' => '\n' as u32,

From a3d8d49cbb1ced6045918236c536a96ab862ccf6 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 3 Feb 2024 03:18:40 -0500
Subject: [PATCH 14/74] feat(rust-sema): Pass down the type checking for
 `HirExpr::Cast` properly

---
 lc-binutils           |  2 +-
 rust/src/sema/tyck.rs | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/lc-binutils b/lc-binutils
index 967ded32..39d2cf0a 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 967ded327dff8b16e8f04474b359fe565b3519f9
+Subproject commit 39d2cf0a5b1aba7dafb1fb5eada9e9ce4c4cc7e7
diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
index 21221634..4cdff619 100644
--- a/rust/src/sema/tyck.rs
+++ b/rust/src/sema/tyck.rs
@@ -800,14 +800,14 @@ impl<'a> ThirConverter<'a> {
                 cat: ValueCategory::Rvalue,
                 inner: ThirExprInner::Unreachable,
             }),
-            hir::HirExpr::Cast(expr, ty) => Ok(ThirExpr {
-                ty: ty.body.clone(),
-                cat: ValueCategory::Rvalue,
-                inner: ThirExprInner::Cast(
-                    Box::new(self.convert_rvalue(expr)?),
-                    self.convert_syntatic_type(ty.clone()),
-                ),
-            }),
+            hir::HirExpr::Cast(expr, ty) => {
+                let ty = self.convert_syntatic_type(ty.clone());
+                Ok(ThirExpr {
+                    ty: ty.body.clone(),
+                    cat: ValueCategory::Rvalue,
+                    inner: ThirExprInner::Cast(Box::new(self.convert_rvalue(expr)?), ty),
+                })
+            }
             hir::HirExpr::Tuple(vals) => {
                 let vals = vals
                     .iter()

From 66dddae22272f378baa677d77154afe2987eb0ed Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 4 Feb 2024 01:46:29 -0600
Subject: [PATCH 15/74] feat(xlang-backend-ssa): half-support calls

---
 xlang/xlang_backend/src/ssa.rs | 9 ++++++++-
 xlang/xlang_struct/src/lib.rs  | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 03262bd4..f855091a 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -489,7 +489,14 @@ impl<M: Machine> BasicBlockBuilder<M> {
             }
             ir::Terminator::Branch(_, _, _) => todo!("branch"),
             ir::Terminator::BranchIndirect => todo!("branch indirect"),
-            ir::Terminator::Call(_, _, _) => todo!("call"),
+            ir::Terminator::Call(_, call_fnty, next) => {
+                let params_count = call_fnty.params.len();
+                let vals = self.pop_values(params_count);
+
+                let target = self.pop();
+
+                self.write_call(target, vals, (**call_fnty).clone(), Some(*next));
+            }
             ir::Terminator::Tailcall(_, call_fnty) => {
                 let params_count = call_fnty.params.len();
                 let vals = self.pop_values(params_count);
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index c57c127b..92915fe1 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1916,7 +1916,7 @@ impl core::fmt::Display for JumpTargetFlags {
 /// jump-target := [*(<jump-target-flags>)] @<int-literal>
 /// ```
 #[repr(C)]
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub struct JumpTarget {
     /// The flags for the jump
     pub flags: JumpTargetFlags,

From 2de6914e2e55ba78c91283825ed4637fd369f9ef Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Fri, 9 Feb 2024 23:25:50 -0600
Subject: [PATCH 16/74] feat(xlang-backend-ssa): start implementing
 non-tailcall

---
 codegen-x86/src/lib.rs         |  2 ++
 xlang/xlang_backend/src/ssa.rs | 47 +++++++++++++++++++++++++---------
 2 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index b7dfd6e1..378a48d8 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -184,6 +184,7 @@ impl Machine for X86Machine {
         let mut clobbers = X86Clobbers {};
         for (num, insn) in insns.iter().enumerate() {
             match insn {
+                xlang_backend::ssa::SsaInstruction::Call(_, _) => todo!("call"),
                 xlang_backend::ssa::SsaInstruction::Jump(targ, old_locs)
                 | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
@@ -255,6 +256,7 @@ impl Machine for X86Machine {
             }
 
             match insn {
+                xlang_backend::ssa::SsaInstruction::Call(_, _) => todo!("call"),
                 xlang_backend::ssa::SsaInstruction::Jump(targ, _) => {
                     encoder.write_insn(X86Instruction::new(
                         X86CodegenOpcode::Jmp,
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index f855091a..2a8334cd 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -9,7 +9,7 @@ use crate::mach::Machine;
 use crate::ty::TypeInformation;
 
 use arch_ops::traits::InsnWrite;
-use xlang::targets::properties::TargetProperties;
+use xlang::{ir::JumpTarget, targets::properties::TargetProperties};
 
 use xlang::ir;
 
@@ -31,6 +31,7 @@ impl SharedCounter {
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum SsaInstruction {
+    Call(CallTarget, Vec<OpaqueLocation>),
     Jump(u32, Vec<OpaqueLocation>),
     Fallthrough(u32, Vec<OpaqueLocation>),
     Exit(Vec<OpaqueLocation>),
@@ -42,6 +43,16 @@ pub enum SsaInstruction {
 impl core::fmt::Display for SsaInstruction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            SsaInstruction::Call(targ, params) => {
+                f.write_fmt(format_args!("call {}(", targ))?;
+                let mut sep = "";
+                for item in params {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str(")")
+            }
             SsaInstruction::Jump(val, stack) => {
                 f.write_fmt(format_args!("jump @{} [", val))?;
                 let mut sep = "";
@@ -417,7 +428,15 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 };
 
                 if let Some(next) = next {
-                    todo!("Call with next")
+                    self.insns.push(SsaInstruction::Call(
+                        CallTarget {
+                            ptr: OpaquePtr::Symbol(sym),
+                            real_ty,
+                            call_ty,
+                        },
+                        params,
+                    ));
+                    self.write_jump(&next);
                 } else {
                     self.insns.push(SsaInstruction::Tailcall(
                         CallTarget {
@@ -441,6 +460,19 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
+    pub fn write_jump(&mut self, targ: &JumpTarget) {
+        let vals = self.incoming_count[&targ.target];
+
+        let vals = self.pop_opaque(vals);
+
+        if targ.flags.contains(ir::JumpTargetFlags::FALLTHROUGH) {
+            self.insns
+                .push(SsaInstruction::Fallthrough(targ.target, vals));
+        } else {
+            self.insns.push(SsaInstruction::Jump(targ.target, vals));
+        }
+    }
+
     pub fn write_expr(&mut self, expr: &ir::Expr) {
         match expr {
             ir::Expr::Sequence(_) => todo!("sequence"),
@@ -476,16 +508,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
     pub fn write_terminator(&mut self, term: &ir::Terminator) {
         match term {
             ir::Terminator::Jump(targ) => {
-                let vals = self.incoming_count[&targ.target];
-
-                let vals = self.pop_opaque(vals);
-
-                if targ.flags.contains(ir::JumpTargetFlags::FALLTHROUGH) {
-                    self.insns
-                        .push(SsaInstruction::Fallthrough(targ.target, vals));
-                } else {
-                    self.insns.push(SsaInstruction::Jump(targ.target, vals));
-                }
+                self.write_jump(targ);
             }
             ir::Terminator::Branch(_, _, _) => todo!("branch"),
             ir::Terminator::BranchIndirect => todo!("branch indirect"),

From cfcaf57a01377df1426e67bfdb0593cdea14f019 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Mon, 12 Feb 2024 19:08:11 -0500
Subject: [PATCH 17/74] doc(xlang-backend): Add documentation for xlang_backed
 rewrite feat(xlang-backend): Add support for head values for `make_jump`

---
 codegen-clever/src/lib.rs           |  10 ++
 codegen-w65/src/lib.rs              |  10 ++
 codegen-x86/src/callconv.rs         |   2 +-
 codegen-x86/src/lib.rs              |  22 ++++
 xlang/xlang_backend/src/callconv.rs | 133 ++++++++++++++++++++-
 xlang/xlang_backend/src/expr.rs     |   6 +-
 xlang/xlang_backend/src/lib.rs      |  22 +++-
 xlang/xlang_backend/src/mach.rs     |  30 ++++-
 xlang/xlang_backend/src/ssa.rs      | 174 ++++++++++++++++++++++++----
 xlang/xlang_backend/src/ty.rs       |  45 +------
 10 files changed, 372 insertions(+), 82 deletions(-)

diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index fde692bd..836f3bfa 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -58,6 +58,16 @@ impl Machine for CleverMachine {
     ) -> std::io::Result<()> {
         todo!()
     }
+
+    fn assign_call_conv(
+        &self,
+        assignments: &mut Self::Assignments,
+        incoming: &[OpaqueLocation],
+        fnty: &xlang_struct::FnType,
+        tys: &TypeInformation,
+    ) {
+        todo!()
+    }
 }
 
 xlang::host::rustcall! {
diff --git a/codegen-w65/src/lib.rs b/codegen-w65/src/lib.rs
index 5fee482a..e626c136 100644
--- a/codegen-w65/src/lib.rs
+++ b/codegen-w65/src/lib.rs
@@ -58,6 +58,16 @@ impl Machine for W65Machine {
     ) -> std::io::Result<()> {
         todo!()
     }
+
+    fn assign_call_conv(
+        &self,
+        assignments: &mut Self::Assignments,
+        incoming: &[OpaqueLocation],
+        fnty: &xlang_struct::FnType,
+        tys: &TypeInformation,
+    ) {
+        todo!()
+    }
 }
 
 xlang::host::rustcall! {
diff --git a/codegen-x86/src/callconv.rs b/codegen-x86/src/callconv.rs
index 5ecdce9f..2bae052c 100644
--- a/codegen-x86/src/callconv.rs
+++ b/codegen-x86/src/callconv.rs
@@ -251,7 +251,7 @@ impl CallConvInfo for X86CallConvInfo {
         }
     }
 
-    fn classify_pointer(&self) -> Self::TypeClass {
+    fn classify_pointer(&self, _: xlang::ir::PointerKind) -> Self::TypeClass {
         X86TypeClass::Integer
     }
 
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 378a48d8..a76b3c3d 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -332,6 +332,28 @@ impl Machine for X86Machine {
 
         Ok(())
     }
+
+    fn assign_call_conv(
+        &self,
+        assignments: &mut Self::Assignments,
+        incoming: &[xlang_backend::ssa::OpaqueLocation],
+        fnty: &xlang::ir::FnType,
+        tys: &TypeInformation,
+    ) {
+        let callconv = X86CallConvInfo {
+            mode: assignments.mode,
+        };
+        let callconv = compute_call_conv(&callconv, fnty, fnty, tys);
+
+        for (param, incoming) in callconv.params().iter().zip(incoming) {
+            todo!()
+        }
+
+        match callconv.ret_location() {
+            CallConvLocation::Null => {}
+            loc => todo!("Return in {:?}", loc),
+        }
+    }
 }
 
 xlang::host::rustcall! {
diff --git a/xlang/xlang_backend/src/callconv.rs b/xlang/xlang_backend/src/callconv.rs
index b92234e9..a432e364 100644
--- a/xlang/xlang_backend/src/callconv.rs
+++ b/xlang/xlang_backend/src/callconv.rs
@@ -2,92 +2,196 @@ use core::cmp::Eq;
 use core::hash::Hash;
 
 use xlang::{
-    abi::{collection::HashMap, pair::Pair},
-    ir::{ArrayType, FnType, ScalarType, Type},
+    abi::collection::HashMap,
+    ir::{FnType, PointerKind, ScalarType, Type},
 };
 
-use crate::ty::{AggregateLayout, FlattenFieldsOf, TypeInformation};
+use crate::ty::TypeInformation;
 
+/// The position in the parameters list to insert a location
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum ParamPosition {
+    /// Inserts the location in the first parameter location
     First,
+    /// Inserts the location in the last parameter location
     Last,
 }
 
+/// The location of a parameter or return value
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum CallConvLocation<R> {
+    /// Passed in a register (which may be a synthetic register)
     Register(R),
+    /// Passed indirectly, with a pointer present in the given register
     Indirect(R),
+    /// Passed on the stack, starting at the given displacement from the start of the parameter area.
     StackOffset(i32),
+    /// Passed in multiple [`CallConvLocation`]s, typically registers.
     Split(Vec<CallConvLocation<R>>),
+    /// An empty value passed in no location
     Null,
 }
 
+/// Describes the location of a return pointer passed to a function
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum ReturnPointerBehaviour<R, C> {
+    /// Specifies that a dedicated register is used. The [`Tag`] must ensure that this does not conflict with any register used by parameters
     Dedicated(R),
+    /// Specifies that the return pointer is passed as a parameter of the given class.
     Param(ParamPosition, C),
 }
 
+/// Describes the behaviour when passing multiple different classes of values
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum RegisterDisposition {
+    /// Interleaves parameters of a given class with parameters of other classes
+    ///
+    /// With different classes mixing [`RegisterDisposition`]s, classes with [`RegisterDisposition::Interleave`] neither affect, nor are affected by parameter classes with [`RegisterDisposition::Consume`]
     Interleave,
+    /// Consumes parameters positionally, jointly with other classes with [`RegisterDisposition::Consume`].
+    ///
+    /// With different classes mixing [`RegisterDisposition`]s, only paramaeter classes with [`RegisterDisposition::Consume`] affect the list of consumed registers shared by those classes.
     Consume,
 }
 
+/// Indicates the order that parameters passed on the stack are layed out (in the directionality of the stack)
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum StackedParamsOrder {
+    /// Indicates that the first slot for the parameter region is used by the rightmost parameter passed on the stack
     Rtl,
+    /// Indicates that the first slot for the parameter region is used by the leftmost parameter passed on the stack
     Ltr,
 }
 
+/// The disposition of a [`Tag`] for classifying aggregate types
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum ClassifyAggregateDisposition<C> {
+    /// Indicates that all aggregate types recieving the given class.
     Single(C),
+    /// Classifies aggregate types by field, recursively, merging all fields to tag the whole aggregate one single class
     Recursive,
+    /// Splits the aggregate type into chunks of the given size, and classifies each chunk according to contained scalar fields merging the classes in each chunk.
     SplitFlat(u64),
 }
 
+/// A trait for compiled calling convention [`Tag`]s.
+/// [`Tag`]s decide how different classified values are ultimately passed or returned from functions, specifying which registers are used for which class, and when certain classes are replaced.
+///
+/// The [`Tag`] is expected to uphold certain invariants about type classes and dispositions it indicates via
+///
 pub trait Tag {
+    /// The type of the registers used by the calling convention.
     type Register: Clone + Eq;
+    /// The type of the classification (or partial classification) of individual values that can be passed or returned
     type TypeClass;
+
+    /// The name of the tag, for display purposes
     fn tag_name(&self) -> &'static str;
 
+    /// Returns the list of registers used for passing values (or parts thereof) of the specified `cl`, if any.
+    ///
+    /// It is a logic error if any two different type classes share the same (non-empty) lists of registers unless both are [`RegisterDisposition::Consume`],
+    ///  or if any two different type classes use any of the same registers except as the same parameter position when both classes use [`RegisterDisposition::Consume`]
     fn param_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register];
 
+    /// Returns the list of registers used for returning values (or parts thereof) of the specified `cl`, if any.
     fn return_regs_for_class(&self, cl: &Self::TypeClass) -> &[Self::Register];
 
+    /// If the given list of classes should be passed indirectly, returns the type class of the pointer the parameter is replaced by.
+    /// Otherwise, returns [`None`].
+    ///
+    /// It is a logic error of the implementation if this function returns a type class which, if given as the single input to this function, would return [`Some`].
     fn replace_param_with_pointer(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass>;
 
+    /// If the given list of classes was generated by spliting a large value that can be passed as a single unit, returns the type class of the combined unit.
+    /// Otherwise, returns [`None`].
+    ///
+    /// It is a logic error of the implementation if this function returns a type class which, if given as the single input to [`Tag::replace_param_with_pointer`] or [`Tag::replace_return_with_pointer`],
+    ///  would return [`None`].
     fn combine_wide(&self, cl: &[Self::TypeClass]) -> Option<Self::TypeClass>;
 
+    /// If the given list of type classes should be returned indirectly, returns the disposition for passing the return pointer to the function.
+    /// Otherwise, returns [`None`].
+    ///
+    /// It is a logic error of the implementation if the function returns [`ReturnPointerBehaviour::Param`], and the class of the parameter specified,
+    ///   if given as the single input to [`Tag::return_regs_for_class`] would yield a slice without 1 or more registers or, if passed to this function, would return [`Some`].
+    ///
+    /// It is further a logic error of the implementation if the function returns [`ReturnPointerBehaviour::Dedicated`], and the specified register collides with any register used for a parameter of any class.
     fn replace_return_with_pointer(
         &self,
         cl: &[Self::TypeClass],
     ) -> Option<ReturnPointerBehaviour<Self::Register, Self::TypeClass>>;
 
+    /// If the given type class needs special handling when passed as a variadic parameter (parameter after the fixed airty parameter list),
+    ///  returns the type class of the replaced segment.
+    ///
+    /// For parameters with multiple classes, each class is replaced individually.
+    ///
+    /// It is a logic error of the implementation if the function returns a type class which, when combined with the other classes for the full value and passed to [`Tag::replace_param_with_pointer`] would return [`Some`],
+    ///  unless the function applied to the original set would return the same value.
+    /// Note that checks for [`Tag::replace_param_with_pointer`] are performed before calling this function, so a [`Some`] value becoming [`None`] after this function is not necessarily respected (but it considered well-defined).
     fn replace_class_as_varargs(&self, cl: &Self::TypeClass) -> Option<Self::TypeClass>;
 
+    /// Specifies how parameter parts of the given type class interact with other parameters passed in different type classes.
+    ///
+    /// Two options are provided:
+    /// * [`RegisterDisposition::Interleave`] causes all such type classes to be disjoint - only parameters passed in registers of the same type class will affect the registers used for other parameters
+    /// * [`RegisterDisposition::Consume`] causes a global (accross all parameters of the same call) list to be used, and parameters are assigned positionally.
+    ///
+    /// A [`Tag`] may specify a single register disposition for all type classes, or may specify mixed dispositions.
+    /// The behaviour of mixed dispositions is described by the variants of [`RegisterDisposition`]
     fn register_disposition(&self, cl: &Self::TypeClass) -> RegisterDisposition;
 
+    /// Specifies the order that parameters are placed on the stack after all registers are consumed
     fn stacked_params_order(&self) -> StackedParamsOrder;
 }
 
+/// A trait for information about calling conventions on a target.
+///
+/// As opposed to [`Tag`], [`CallConvInfo`] contains the information needed to perform initial classification of parameters/return values, as well as how to convert tag strings to [`Tag`] values.
 pub trait CallConvInfo {
+    /// The type of the [`Tag`] associated with the calling conventions.
     type Tag: Tag<TypeClass = Self::TypeClass, Register = Self::Register>;
+    /// The type of parameter/return value classes used by the [`CallConvInfo::Tag`] and by value classification
     type TypeClass: Eq + Hash + Clone;
+    /// The type of registers yielded by the [`CallConvInfo::Tag`]
     type Register: Eq + Clone;
+    /// Maps the specified `tag` to the associated [`Tag`] value.
+    ///
+    /// ## Panics
+    /// The implementation may panic (or otherwise return a nonsensical value) if the `tag` is invalid for the target.
     fn get_tag(&self, tag: &str) -> Self::Tag;
 
+    /// Returns the [`CallConvInfo::TypeClass`] that an empty value (such as a portion of an aggregate that entirely consists of padding bytes) recieves.
+    /// Anything classified as the return value will be ignored for parameter passing or return purposes (passed in [`CallConvLocation::Null`])
     fn no_class(&self) -> Self::TypeClass;
+
+    /// Classifies the given scalar type, splitting it into sufficient individual pieces to allow passing it in registers.
     fn classify_scalar(&self, sty: ScalarType) -> Vec<Self::TypeClass>;
-    fn classify_pointer(&self) -> Self::TypeClass;
+    /// Classifies pointer types of the given `width`.
+    /// It is generally assumed that a pointer can allways be passed as a single value
+    fn classify_pointer(&self, width: PointerKind) -> Self::TypeClass;
+    /// Indicates how the [`classify_type`] function should classify aggregates.
+    /// See documentation of [`ClassifyAggregateDisposition`] for details
     fn classify_aggregate_disposition(&self) -> ClassifyAggregateDisposition<Self::TypeClass>;
 
+    /// Merges two type classes into a single class.
+    ///
+    /// It is a logic error of the implementation if any of the following properties do not hold:
+    /// * Given the classes `a` and `b`, [`CallConvInfo::merge_class`]`(a,b)` is the same value as [`CallConvInfo::merge_class`]`(b,a)`
+    /// * Given the classes `a` and `b`, if either `a` or `b` does not equal [`CallConvInfo::no_class`] , then [`CallConvInfo::merge_class`]`(a,b)` does not equal [`CallConvInfo::no_class`]`()`
+    ///
     fn merge_class(&self, left: Self::TypeClass, right: Self::TypeClass) -> Self::TypeClass;
+
+    /// Performs a final merge step after all pieces of value have been classified
     fn adjust_classes_after_combine(&self, classes: &mut [Self::TypeClass]);
 }
 
+/// A type that stores the result of computing the full calling convention of a function type.
 pub struct CallConv<R, T> {
     params: Vec<CallConvLocation<R>>,
     stacked_params_count: u32,
@@ -97,27 +201,35 @@ pub struct CallConv<R, T> {
 }
 
 impl<R, T> CallConv<R, T> {
+    /// The computed [`Tag`] of the function type.
     pub fn tag(&self) -> &T {
         &self.tag
     }
 
+    /// The full list of locations to place (or find) the parameters of the function.
+    ///
+    /// Each parameter in the "call type" (at the call site) or function type (at the def site) has exactly one element in order.
     pub fn params(&self) -> &[CallConvLocation<R>] {
         &self.params
     }
 
+    /// Specifies the location to place (or find) the return value of the function.
     pub fn ret_location(&self) -> &CallConvLocation<R> {
         &self.ret_location
     }
 
+    /// Specifies the number of different parameter classes that were passed on the stack.
     pub fn stacked_params_count(&self) -> u32 {
         self.stacked_params_count
     }
 
+    /// Specifies whether or not the function was variadic.
     pub fn is_varargs(&self) -> bool {
         self.is_varargs
     }
 }
 
+/// Classifies the given [`Type`] according to `info`. Information about the types are derived from `tys`
 pub fn classify_type<I: CallConvInfo>(
     info: &I,
     ty: &Type,
@@ -128,7 +240,7 @@ pub fn classify_type<I: CallConvInfo>(
         Type::Null | Type::Void => classes.push(info.no_class()),
         Type::Scalar(sty) => classes.extend(info.classify_scalar(*sty)),
         Type::FnType(_) => panic!("Cannot classify a non-value type (other than void)"),
-        Type::Pointer(_) => classes.push(info.classify_pointer()),
+        Type::Pointer(ptr) => classes.push(info.classify_pointer(ptr.kind)),
         Type::Array(_) => todo!(),
         Type::TaggedType(_, ty) => classes = classify_type(info, ty, tys),
         Type::Product(_) => todo!(),
@@ -142,6 +254,14 @@ pub fn classify_type<I: CallConvInfo>(
     classes
 }
 
+/// Computes the [`CallConv`] of a function call site (or def site) with the given [`CallConvInfo`] using `real_ty` and `call_ty`.
+///
+/// This function primarily computes calling convention for the call site of a function, with `real_ty` set to the type of the function being called,
+///   and `call_ty` being the fn-type for the `call` or `tailcall` instruction when they differ (for example, for variadic parameters).
+/// When computing the calling convention of a function inside that function, `real_ty` and `call_ty` should be set to the same value.
+///
+///
+///
 pub fn compute_call_conv<I: CallConvInfo>(
     info: &I,
     real_ty: &FnType,
@@ -159,6 +279,7 @@ pub fn compute_call_conv<I: CallConvInfo>(
 
     let return_classes = classify_type(info, &real_ty.ret, tys);
 
+    #[allow(unused_assignments)] // ParamPosition::Last will be implemented later.
     let mut return_loc = None;
 
     let mut total_params_consumed = 0;
@@ -214,7 +335,7 @@ pub fn compute_call_conv<I: CallConvInfo>(
                     todo!("return in memory on stack")
                 }
             }
-            ReturnPointerBehaviour::Param(_, cl) => todo!("non-start return pointer"),
+            ReturnPointerBehaviour::Param(_, _cl) => todo!("non-start return pointer"),
         }
     } else {
         let mut split_locs = vec![];
diff --git a/xlang/xlang_backend/src/expr.rs b/xlang/xlang_backend/src/expr.rs
index 9a832d8a..2a626f09 100644
--- a/xlang/xlang_backend/src/expr.rs
+++ b/xlang/xlang_backend/src/expr.rs
@@ -6,8 +6,6 @@ use xlang::{
 use core::{fmt::Debug, hash::Hash};
 use std::num::NonZeroU128;
 
-use crate::str::Encoding;
-
 /// Represents the location of opaque values both as locals and on the value stack
 pub trait ValLocation: Eq + Debug + Clone {
     /// Checks if this location is addressable (is not a register)
@@ -160,8 +158,8 @@ impl<Loc: ValLocation> VStackValue<Loc> {
             VStackValue::Constant(val) => match val {
                 Value::Invalid(ty) | Value::Uninitialized(ty) => ty.clone(),
                 Value::GenericParameter(_) => panic!("Cannot handle generic params this late"),
-                Value::Integer { ty, val } => Type::Scalar(*ty),
-                Value::GlobalAddress { ty, item } => {
+                Value::Integer { ty, .. } => Type::Scalar(*ty),
+                Value::GlobalAddress { ty, .. } => {
                     let mut pty = PointerType::default();
                     *pty.inner = ty.clone();
                     Type::Pointer(pty)
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index bbdd7bc4..3ec9caf1 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -1,5 +1,4 @@
-// #![deny(missing_docs, warnings)] // No clippy::nursery
-#![allow(dead_code)] // I'm not deleting a bunch of randomly placed shit
+#![deny(missing_docs, warnings)] // No clippy::nursery
 //! A helper crate for implementing [`xlang::plugin::XLangCodegen`]s without duplicating code (also can be used to evaluate constant expressions)
 //! the `xlang_backend` crate provides a general interface for writing expressions to an output.
 
@@ -43,15 +42,29 @@ pub mod mangle;
 pub mod mach;
 
 /// Module for building SSA from XIR that can be readily lowered to machine code
-/// Does not use FunctionCodegen
 pub mod ssa;
 
+/// The section a symbol definition is placed in
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum SectionSpec {
+    /// The global section for the current type of definition, which (on ELF platforms), are generally:
+    /// * `.text` (RX) for functions
+    /// * `.data` (RW) for mutable statics
+    /// * `.rodata` (RO) for immutable statics
+    /// * `.bss` (RW - no data) for uninitialized statics
+    /// * `.tdata` (RW TLS) for thread-local statics
+    /// * `.tbss` (RW TLS - no data) for uninitialized thread-local statics
+    ///
+    /// Note that there is no guarantee as to the exact name of the sections, or which section a particular symbol is placed in if multiple sections are valid (For example, immutable statics may be placed in `.data` or `.bss`).
+    ///
+    /// However, the same set of sections will be used for all symbols defined in the [`SectionSpec::Global`].
+    ///
+    ///
     Global,
 }
 
 impl core::fmt::Display for SectionSpec {
+    #[allow(unused_variables)] // we'll have more sections than `Global` at some point
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             Self::Global => Ok(()),
@@ -59,6 +72,7 @@ impl core::fmt::Display for SectionSpec {
     }
 }
 
+/// A codegen definition of a [`ir::FunctionDeclaration`]
 pub struct FunctionDef<M> {
     section: SectionSpec,
     linkage: Linkage,
@@ -66,6 +80,7 @@ pub struct FunctionDef<M> {
     body: Option<FunctionBuilder<M>>,
 }
 
+/// an [`XLangCodegen`] implementation parameterized on a [`Machine`] that uses [`ssa::FunctionBuilder`] to generate machine code or assembly
 pub struct SsaCodegenPlugin<M> {
     mach: Rc<M>,
     targ: Option<&'static TargetProperties<'static>>,
@@ -73,6 +88,7 @@ pub struct SsaCodegenPlugin<M> {
 }
 
 impl<M> SsaCodegenPlugin<M> {
+    /// Constructs a new [`SsaCodegenPlugin`] based on `mach`.
     pub fn new(mach: M) -> Self {
         Self {
             mach: Rc::new(mach),
diff --git a/xlang/xlang_backend/src/mach.rs b/xlang/xlang_backend/src/mach.rs
index e858ab98..6a87585e 100644
--- a/xlang/xlang_backend/src/mach.rs
+++ b/xlang/xlang_backend/src/mach.rs
@@ -1,5 +1,5 @@
 use xlang::{
-    abi::collection::HashMap, abi::string::StringView, targets::properties::TargetProperties,
+    abi::collection::HashMap, abi::string::StringView, ir, targets::properties::TargetProperties,
     vec::Vec,
 };
 
@@ -11,14 +11,31 @@ use crate::{
 
 use arch_ops::traits::InsnWrite;
 
-use std::io::Result;
-
+/// A trait for representing the properties of a machine, and for generating code for the machine from [`SsaInstruction`]s
 pub trait Machine {
+    /// The type used per-function to track where each opaque location is placed.
     type Assignments;
+    /// The type used per-basic block to track where values need to be spilled or moved to a new assignment
     type BlockClobbers;
+    /// Determines whether the given named `targ` matches the current [`Machine`]
     fn matches_target(&self, targ: StringView) -> bool;
+    /// Initializes the machine from the properties specified in `targ`.
+    /// It may be assumed by the implementation that all functions, other than [`Machine::matches_target`], are called only after calling this function and that this function is called at most one.
     fn init_from_target(&mut self, targ: &TargetProperties);
+    /// Constructs a new (empty) state for [`Machine::Assignments`].
+    /// A single return value is used for only one XIR function, and is not reused by multiple functions.
     fn new_assignments(&self) -> Self::Assignments;
+
+    /// Assigns locations for incoming locations from the calling convention of the function
+    fn assign_call_conv(
+        &self,
+        assignments: &mut Self::Assignments,
+        incoming: &[OpaqueLocation],
+        fnty: &ir::FnType,
+        tys: &TypeInformation,
+    );
+
+    /// Assigns the locations for a basic block, specifying the instructions the make up the lowered basic block, and the list of locations incoming to the basic block.
     fn assign_locations(
         &self,
         assignments: &mut Self::Assignments,
@@ -28,11 +45,15 @@ pub trait Machine {
         incoming_set: &HashMap<u32, Vec<OpaqueLocation>>,
         tys: &TypeInformation,
     ) -> Self::BlockClobbers;
+    /// Writes the prologue instructions for a function to the given [`InsnWrite`]
     fn codegen_prologue<W: InsnWrite>(
         &self,
         assignments: &Self::Assignments,
         out: &mut W,
     ) -> std::io::Result<()>;
+    /// Writes the machine instructions corresponding to the [`SsaInstruction`]s that make up a basic block.
+    ///
+    /// The function may generate a label string from it's basic block id by using the `label_sym` callback.
     fn codegen_block<W: InsnWrite, F: Fn(u32) -> String>(
         &self,
         assignments: &Self::Assignments,
@@ -43,6 +64,9 @@ pub trait Machine {
         which: u32,
         tys: &TypeInformation,
     ) -> std::io::Result<()>;
+
+    /// Mangles the components of a complex XIR [`Path`][xlang::ir::Path]
+    /// (Does not solely consistent of an optional [`Root`][xlang::ir::PathComponent::Root] followed by a single bare [`Text`][xlang::ir::PathComponent::Text])
     fn mangle(&self, path: &[xlang::ir::PathComponent]) -> String {
         mangle_itanium(path)
     }
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 2a8334cd..8f09cf54 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -1,6 +1,5 @@
-#![allow(missing_docs)]
-use core::cell::{Cell, RefCell};
-use std::panic::Location;
+use core::cell::Cell;
+
 use std::rc::Rc;
 
 use crate::expr::ValLocation;
@@ -29,29 +28,49 @@ impl SharedCounter {
     }
 }
 
+/// An Aggregate type containing the parameter and return locations of an [`SsaInstruction::Call`]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct CallLocations {
+    /// The locations of the parameters
+    pub params: Vec<OpaqueLocation>,
+    /// The location of the return value
+    pub ret: OpaqueLocation,
+}
+
+/// An instruction for ssa codegen lowered from a [`Expr`][xlang::ir::Expr]
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum SsaInstruction {
-    Call(CallTarget, Vec<OpaqueLocation>),
+    /// Performs a call to the given [`CallTarget`] with the parameters in the specified [`OpaqueLocation`]s
+    Call(CallTarget, CallLocations),
+    /// Jumps to the destination basic block, mapping the given `OpaqueLocation`s to the incoming locations in the destination.
     Jump(u32, Vec<OpaqueLocation>),
+    /// Falls through to the destination basic block, mapping the given `OpaqueLocation`s to the incoming locations in the destination.
+    /// The Code generator may generate code that is invalid if the destination basic block does not immediately follow the current basic block
     Fallthrough(u32, Vec<OpaqueLocation>),
+    /// Exits from the function, with the values in the given location
     Exit(Vec<OpaqueLocation>),
+    /// Performs a tailcall to the given [`CallTarget`] with the parameters in the specified [`OpaqueLocation`]s
     Tailcall(CallTarget, Vec<OpaqueLocation>),
+    /// Executes the specified [`Trap`]
     Trap(Trap),
+    /// Loads a scalar immediate value into the given [`OpaqueLocation`]
     LoadImmediate(OpaqueLocation, u128),
 }
 
 impl core::fmt::Display for SsaInstruction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            SsaInstruction::Call(targ, params) => {
+            SsaInstruction::Call(targ, locs) => {
                 f.write_fmt(format_args!("call {}(", targ))?;
                 let mut sep = "";
-                for item in params {
+                for item in &locs.params {
                     f.write_str(sep)?;
                     sep = ", ";
                     item.fmt(f)?;
                 }
-                f.write_str(")")
+                f.write_str(") -> ")?;
+
+                locs.ret.fmt(f)
             }
             SsaInstruction::Jump(val, stack) => {
                 f.write_fmt(format_args!("jump @{} [", val))?;
@@ -101,10 +120,16 @@ impl core::fmt::Display for SsaInstruction {
     }
 }
 
+/// Specifies the target of a call site for either [`SsaInstruction::Call`] or [`SsaInstruction::Tailcall`]
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct CallTarget {
+    /// The pointer to call, which either may be inside an indirect location or a symbol name
     pub ptr: OpaquePtr,
+    /// The real (def) type of the pointer, used for computing the calling convention of the function.
+    ///
+    /// This may differ from the `call_ty` if the function is variadic
     pub real_ty: ir::FnType,
+    /// The callsite type of the pointer, used for computing the calling convention of the function.
     pub call_ty: ir::FnType,
 }
 
@@ -114,9 +139,12 @@ impl core::fmt::Display for CallTarget {
     }
 }
 
+/// A pointer which can be directly called or read from
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum OpaquePtr {
+    /// A symbol, such as a global variable, function, or label addres
     Symbol(String),
+    /// A pointer already stored in another location (where the value is unknown)
     Pointer(OpaqueLocation),
 }
 
@@ -129,10 +157,14 @@ impl core::fmt::Display for OpaquePtr {
     }
 }
 
+/// An opaque value location
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct OpaqueLocation {
+    /// The type of the stored value
     pub ty: Rc<ir::Type>,
+    /// The kind (lvalue or rvalue) of the stored value.
     pub kind: ir::StackValueKind,
+    /// The unique identifier of the value location
     pub num: u32,
     has_addr: bool,
 }
@@ -153,6 +185,7 @@ impl ValLocation for OpaqueLocation {
     }
 }
 
+/// A builder that can convert [`ir::FunctionBody`]s into Machine code, lowering through [`SsaInstruction`]s.
 pub struct FunctionBuilder<M> {
     tys: Rc<TypeInformation>,
     sym_name: String,
@@ -167,6 +200,9 @@ pub struct FunctionBuilder<M> {
 }
 
 impl<M> FunctionBuilder<M> {
+    /// Constructs a new [`FunctionBuilder`] for the function, that uses the given [`Machine`], [`TypeInformation`], and [`TargetProperties`].
+    ///
+    /// `sym_name` and `fnty` are the symbol (mangled) named and definition type of the function definition, respectively.
     pub fn new(
         sym_name: String,
         mach: Rc<M>,
@@ -187,9 +223,8 @@ impl<M> FunctionBuilder<M> {
             incoming_count: Rc::new(HashMap::new()),
         }
     }
-}
 
-impl<M: Machine> FunctionBuilder<M> {
+    /// Inserts a new local variable of type `ty`
     pub fn push_local(&mut self, ty: ir::Type) {
         Rc::get_mut(&mut self.locals)
             .expect("No basic blocks may have been pushed yet")
@@ -201,12 +236,14 @@ impl<M: Machine> FunctionBuilder<M> {
             })
     }
 
+    /// Allocates space for the incoming set of basic block `id`, according to `incoming`
     pub fn push_incoming(&mut self, id: u32, incoming: &Vec<ir::StackItem>) {
         let incoming_count = Rc::get_mut(&mut self.incoming_count)
             .expect("new_basic_block may not have been called yet");
         incoming_count.insert(id, incoming.len());
     }
 
+    /// Creates a new [`BasicBlockBuilder`] that refers to basic block `id`, with the given `incoming` stack values.
     pub fn new_basic_block(
         &mut self,
         id: u32,
@@ -251,7 +288,10 @@ impl<M: Machine> FunctionBuilder<M> {
 
         self.basic_blocks.push_mut(builder)
     }
+}
 
+impl<M: Machine> FunctionBuilder<M> {
+    /// Writes the function to the given [`InsnWrite`], with the given function to accept a new symbol
     pub fn write<W: InsnWrite, F: FnMut(String, u128)>(
         &mut self,
         out: &mut W,
@@ -259,6 +299,16 @@ impl<M: Machine> FunctionBuilder<M> {
     ) -> std::io::Result<()> {
         let mut assigns = self.mach.new_assignments();
         let mut block_clobbers = vec![];
+
+        if let Some(bb) = &self.basic_blocks.first() {
+            self.mach.assign_call_conv(
+                &mut assigns,
+                &self.incoming_locations[&bb.id],
+                &self.fnty,
+                &self.tys,
+            )
+        }
+
         for bb in &self.basic_blocks {
             block_clobbers.push(self.mach.assign_locations(
                 &mut assigns,
@@ -302,6 +352,8 @@ impl<M> core::fmt::Display for FunctionBuilder<M> {
     }
 }
 
+/// A builder for code generation of [`ir::Block`]s into [`SsaInstruction`]s
+#[allow(dead_code)] // ignore unused variables, they'll be used when there's less `todo!()`
 pub struct BasicBlockBuilder<M> {
     id: u32,
     tys: Rc<TypeInformation>,
@@ -315,6 +367,7 @@ pub struct BasicBlockBuilder<M> {
 }
 
 impl<M: Machine> BasicBlockBuilder<M> {
+    /// Moves the given [`VStackValue`] into the specified [`OpaqueLocation`], generating appropriate loads and move instructions to place both transparent and opaque values in the new location
     pub fn move_into(&mut self, val: VStackValue<OpaqueLocation>, loc: OpaqueLocation) {
         match val {
             VStackValue::Constant(val) => match val {
@@ -324,9 +377,9 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 ir::Value::Integer { val, .. } => {
                     self.insns.push(SsaInstruction::LoadImmediate(loc, val))
                 }
-                ir::Value::GlobalAddress { ty, item } => todo!(),
-                ir::Value::ByteString { content } => todo!(),
-                ir::Value::String { encoding, utf8, ty } => todo!(),
+                ir::Value::GlobalAddress { .. } => todo!(),
+                ir::Value::ByteString { .. } => todo!(),
+                ir::Value::String { .. } => todo!(),
                 ir::Value::LabelAddress(_) => todo!(),
                 ir::Value::Empty => panic!("Empty IR value"),
             },
@@ -341,16 +394,31 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
+    /// Pushes a single [`VStackValue`] to the basic block's eval stack
     pub fn push(&mut self, val: VStackValue<OpaqueLocation>) {
         self.vstack.push(val);
     }
 
+    /// Pushes all of the specified [`VStackValue`]s to the basic block's eval stack
+
+    pub fn push_values<I: IntoIterator<Item = VStackValue<OpaqueLocation>>>(&mut self, vals: I) {
+        self.vstack.extend(vals)
+    }
+
+    /// Pops a single [`VStackValue`] from the basic block's eval stack
+    ///
+    /// ## Panics
+    /// Panics if the eval stack is empty at the current location
     pub fn pop(&mut self) -> VStackValue<OpaqueLocation> {
         self.vstack
             .pop()
             .expect("BasicBlockBuilder::pop called with an empty stack")
     }
 
+    /// Pops `N` values from the basic block's eval stack as an array, to allow easier destructuring of several values
+    ///
+    /// ## Panics
+    /// Panics if the eval stack has fewer than `N` values at the current location
     pub fn pop_values_static<const N: usize>(&mut self) -> [VStackValue<OpaqueLocation>; N] {
         use core::mem::MaybeUninit;
         let mut val = MaybeUninit::<[_; N]>::uninit();
@@ -364,9 +432,18 @@ impl<M: Machine> BasicBlockBuilder<M> {
         unsafe { val.assume_init() }
     }
 
+    /// Pops `n` values from the basic block's eval stack and returns them as a vector.
+    ///
+    /// ## Panics
+    /// Panics if the eval stack has fewer than `n` values at the current location
     pub fn pop_values(&mut self, n: usize) -> Vec<VStackValue<OpaqueLocation>> {
         self.vstack.split_off_back(n)
     }
+
+    /// Pops `n` values as opaque locations from the basic block's eval stack and returns them as a vector, moving them into a new [`OpaqueLocation`] if necessary
+    ///
+    /// ## Panics
+    /// Panics if the eval stack has fewer than `n` values at the current location
     pub fn pop_opaque(&mut self, n: usize) -> Vec<OpaqueLocation> {
         let mut vstack = core::mem::take(&mut self.vstack);
 
@@ -378,6 +455,8 @@ impl<M: Machine> BasicBlockBuilder<M> {
         ret
     }
 
+    /// Returns the [`OpaqueLocation`] currently storing the specified [`VStackValue`], if any,
+    ///  or otherwise allocates a new [`OpaqueLocation`] and moves `val` into it as though by [`BasicBlockBuilder::move_into`]
     pub fn make_opaque(&mut self, val: VStackValue<OpaqueLocation>) -> OpaqueLocation {
         if let Some(loc) = val.opaque_location() {
             loc.clone()
@@ -402,6 +481,10 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
+    /// Writes a function call with the given parameters to the given target using the specified `call_ty`.
+    ///
+    /// If `next` is Some, treats this as a normal call, and ends by jumping to the `next`.
+    /// Otherwise, treats this as a tail call, with no following jump.
     pub fn write_call(
         &mut self,
         targ: VStackValue<OpaqueLocation>,
@@ -428,15 +511,24 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 };
 
                 if let Some(next) = next {
+                    let ret_loc = OpaqueLocation {
+                        ty: Rc::new(real_ty.ret.clone()),
+                        kind: ir::StackValueKind::RValue,
+                        num: self.loc_id_counter.next(),
+                        has_addr: false,
+                    };
                     self.insns.push(SsaInstruction::Call(
                         CallTarget {
                             ptr: OpaquePtr::Symbol(sym),
                             real_ty,
                             call_ty,
                         },
-                        params,
+                        CallLocations {
+                            params,
+                            ret: ret_loc.clone(),
+                        },
                     ));
-                    self.write_jump(&next);
+                    self.write_jump(&next, [ret_loc]);
                 } else {
                     self.insns.push(SsaInstruction::Tailcall(
                         CallTarget {
@@ -460,10 +552,23 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
-    pub fn write_jump(&mut self, targ: &JumpTarget) {
-        let vals = self.incoming_count[&targ.target];
+    /// Writes a (possibly [`FALLTHROUGH`][ir::JumpFlags::FALLTHROUGH]) jump to the specified target.
+    ///
+    /// `head_vals` contains value placed on the head of the incoming target stack, which much be at most the total number of incoming values
+    pub fn write_jump<H: IntoIterator<Item = OpaqueLocation>>(
+        &mut self,
+        targ: &JumpTarget,
+        head_vals: H,
+    ) where
+        H::IntoIter: ExactSizeIterator,
+    {
+        let head_vals = head_vals.into_iter();
+        let head_count = head_vals.len();
+        let vals = self.incoming_count[&targ.target] - head_count;
+
+        let mut vals = self.pop_opaque(vals);
 
-        let vals = self.pop_opaque(vals);
+        vals.extend(head_vals);
 
         if targ.flags.contains(ir::JumpTargetFlags::FALLTHROUGH) {
             self.insns
@@ -473,6 +578,11 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
+    /// Writes the given [`ir::Expr`] to the block, generating all necessary instructions, and modifying the basic block's eval stack according to the results of the expression
+    ///
+    /// ## Panics
+    /// The function may panic (or otherwise have incorrect behaviour) if the current state of the basic block's eval stack violates the input constraints in the "Typechecking" specification for `expr`,
+    ///  or if the basic block terminator has already been written.
     pub fn write_expr(&mut self, expr: &ir::Expr) {
         match expr {
             ir::Expr::Sequence(_) => todo!("sequence"),
@@ -484,9 +594,22 @@ impl<M: Machine> BasicBlockBuilder<M> {
             ir::Expr::Convert(_, _) => todo!("convert"),
             ir::Expr::Derive(_, _) => todo!("derive"),
             ir::Expr::Local(_) => todo!("local"),
-            ir::Expr::Pop(_) => todo!("pop"),
-            ir::Expr::Dup(_) => todo!("dup"),
-            ir::Expr::Pivot(_, _) => todo!("pivot"),
+            ir::Expr::Pop(n) => {
+                self.pop_values(*n as usize);
+            }
+            ir::Expr::Dup(n) => {
+                let vals = self.pop_values(*n as usize);
+
+                self.push_values(vals.clone());
+                self.push_values(vals);
+            }
+            ir::Expr::Pivot(m, n) => {
+                let first = self.pop_values(*n as usize);
+                let second = self.pop_values(*m as usize);
+
+                self.push_values(first);
+                self.push_values(second);
+            }
             ir::Expr::Aggregate(_) => todo!("aggregate"),
             ir::Expr::Member(_) => todo!("member"),
             ir::Expr::MemberIndirect(_) => todo!("member indirect"),
@@ -505,10 +628,17 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
+    /// Writes the given terminator to the basic block.
+    /// The eval stack is left in an unspecified state,
+    ///  and operations that place constraints on the stack of the eval stack may not be validly used (they may panic or produce incorrect results)
+    ///
+    /// ## Panics
+    /// The function may panic (or otherwise have incorrect behaviour) if the current state of the basic block's eval stack violates the input constraints in the "Typechecking" specification for `term`,
+    ///  or if the basic block terminator has already been written.
     pub fn write_terminator(&mut self, term: &ir::Terminator) {
         match term {
             ir::Terminator::Jump(targ) => {
-                self.write_jump(targ);
+                self.write_jump(targ, core::iter::empty());
             }
             ir::Terminator::Branch(_, _, _) => todo!("branch"),
             ir::Terminator::BranchIndirect => todo!("branch indirect"),
@@ -531,7 +661,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
             ir::Terminator::Exit(_) => todo!("exit"),
             ir::Terminator::Asm(_) => todo!("asm"),
             ir::Terminator::Switch(_) => todo!("switch"),
-            ir::Terminator::Unreachable => todo!("unreachable"),
+            ir::Terminator::Unreachable => self.insns.push(SsaInstruction::Trap(Trap::Unreachable)),
         }
     }
 }
diff --git a/xlang/xlang_backend/src/ty.rs b/xlang/xlang_backend/src/ty.rs
index 93dc417d..c2df07ec 100644
--- a/xlang/xlang_backend/src/ty.rs
+++ b/xlang/xlang_backend/src/ty.rs
@@ -2,9 +2,8 @@ use std::convert::TryInto;
 
 use xlang::{
     ir::{
-        self, AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule,
-        PointerKind, ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type,
-        ValidRangeType, Value,
+        AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule, PointerKind,
+        ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type, ValidRangeType, Value,
     },
     prelude::v1::{HashMap, Pair, Some as XLangSome},
     targets::properties::TargetProperties,
@@ -51,46 +50,6 @@ pub struct TypeInformation {
     properties: &'static TargetProperties<'static>,
 }
 
-pub struct FlattenFieldsOf<'a> {
-    fields_stack: Vec<std::vec::IntoIter<(u64, &'a Type)>>,
-
-    tys: &'a TypeInformation,
-}
-
-impl<'a> FlattenFieldsOf<'a> {
-    fn push_fields_of(&mut self, base_offset: u64, agl: &'a AggregateLayout) {
-        let mut fields = vec![];
-
-        for Pair(_, (offset, ty)) in &agl.fields {
-            fields.push((*offset + base_offset, ty));
-        }
-
-        fields.sort_by_key(|(off, _)| *off);
-
-        self.fields_stack.push(fields.into_iter());
-    }
-
-    fn push_fields_of_array(&mut self, base_off: u64, arr_ty: &'a ir::ArrayType) {
-        let mut fields = vec![];
-        let ty = &arr_ty.ty;
-        let size = self
-            .tys
-            .type_size(ty)
-            .expect("array type must have a complete value type as a field");
-
-        let len = match &arr_ty.len {
-            Value::Integer { val, .. } => (*val) as u64,
-            val => panic!("Cannot determine length of array from {}", val),
-        };
-
-        for i in 0..len {
-            fields.push((base_off + i * size, ty));
-        }
-
-        self.fields_stack.push(fields.into_iter());
-    }
-}
-
 impl TypeInformation {
     /// Constructs a new set of [`TypeInformation`] from the properties of a given target
     pub fn from_properties(properties: &'static TargetProperties) -> Self {

From d71b0fa901ad941d9070d3cf52103ab30f3bb0ef Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Mon, 12 Feb 2024 22:15:58 -0500
Subject: [PATCH 18/74] doc(xlang-ir): Document some variants of `Expr`

---
 xlang/xlang_struct/src/lib.rs | 373 +++++++++++++++++++++++++++++++++-
 1 file changed, 365 insertions(+), 8 deletions(-)

diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 92915fe1..91b1504b 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1767,33 +1767,388 @@ pub enum Expr {
     ///
     /// ## Semantics
     ///
-    /// 1. If `access-class` contains `volatile`, the instruction performs a observable side effect (`[intro.abstract]#6`).
-    /// 2. If `access-class` contains `nontemporal`, hints that subsequent expressions are unlikely to access memory accessed or modified by preceeding expressions.
-    /// 3. If `access-class` contains an atomic access class, the instruction functions the same a fence instruction with that atomic access class, except that the fence does not *synchronize-with* atomic operations or fence instructions performed by another thread of execution.
+    /// 1. If `access-class` contains `volatile`, the expression performs a observable side effect (`[intro.abstract]#6`).
+    /// 2. If `access-class` contains `nontemporal`, then all preceeding operations weekly-sequenced-before this expression *weekly-happens-before* this expression.
+    /// 3. If `access-class` contains an atomic access class, the expression functions the same a fence expression with that atomic access class, except that the fence does not *synchronize-with* atomic operations or fence instructions performed by another thread of execution.
     /// 4. [_Note: This is suitable for communicating with signal or interrupt handlers executed on the current thread._]
-    /// 5. [_Note: The `access-class` modifier `freeze` may appear, but is ignored by this expression. ]
+    /// 5. [_Note: The `access-class` modifier `freeze` may appear, but is ignored by this expression. _]
     /// 6. If `access-class` does not contain either `volatile`, `nontemporal`, or an atomic access class, the expression performs no operation.
     ///
+    /// ### Platform Notes
+    ///
+    /// Typically, a `sequence` expr corresponds to no generated machine code, regardless of access-class.
+    ///
     Sequence(AccessClass),
     /// Pushes a constant value.
     ///
-    /// # Stack
+    /// ## Stack
+    ///
+    /// Type checking: `[..]`=>`[..,T]``
+    ///
+    /// Operands: `[..]``=>`[..,Value]`
+    ///
+    /// ## Syntax
     ///
-    /// Type checking: [..]=>[..,T]
+    /// ```abnf
+    /// expr /= "const" <value
+    /// ```
     ///
-    /// Operands: [..]=>[..,Value]
+    /// ## Semantics
+    /// Pushes a constant value, with no side effects.
     Const(Value),
 
-    /// Computes
+    /// Computes the given binary Op
+    ///
+    /// ## Stack
+    /// In all of the following, `S` means a scalar type, `P` means a pointer type `I` an integer type.
+    /// Each occurance of `S`, `P`, or `I` in the same type checking specification refers to the same type.
+    ///
+    /// ### Form 1
+    ///
+    /// Type checking: `[..,S,S]`=>`[..,S]`
+    ///
+    /// Operands: `[..,a,b]`=>`[..,res]`
+    ///
+    /// (All except comparison ops or [`OverflowBehaviour::Checked`])
+    ///
+    /// ### Form 2
+    ///
+    /// Type checking: `[..,S, S]`=>`[..,S, uint(1)]`
+    ///
+    /// Operands: `[..,a,b]`=>`[..,res, v]`
+    ///
+    /// ([`OverflowBehaviour::Checked`], except for comarpison ops)
+    ///
+    /// `S` may not have a vectorsize
+    ///
+    /// ### Form 3
+    ///
+    /// Type checking: `[..,S,S]` => `[..,uint(1)]` or `[..,P,P]` => `[..,uint(1)]`
+    ///
+    /// Operands: `[..,a,b]`=>`[..,res]`
+    ///
+    /// (Comparison Op, other than [`BinaryOp::Cmp`])
+    ///
+    /// ### Form 4
+    ///
+    /// Type checking: `[..,S, S]`=>`[..,int(32)]` or `[..P,P]`=>`[..,int(32)]`
+    ///
+    /// Operands: `[..,a,b]`=>`[..,res]`
+    ///
+    /// ([`BinaryOp::Cmp`] except [`OverflowBehaviour::Checked`])
+    ///
+    /// ### Form 5
+    ///
+    /// Type checking: `[..,S, S]`=>`[..,int(32), uint(0)]`
+    ///
+    /// Operands: `[..,a,b]`=>`[..,res,unordered]`
+    /// ([`BinaryOp::Cmp`] with [`OverflowBehaviour::Checked`])
+    ///
+    /// ### Form 6
+    ///
+    /// Type checking: `[..,P,I]`=>`[..,P]` or `[..,I,P]`=>`[..,P]` ([`BinaryOp::Add`] only)
+    ///
+    /// Operands: `[.., ptr, idx]`=>`[..,res]` or `[.., idx, ptr]`=>`[..,res]` ([`BinaryOp::Add`] only)
+    ///
+    /// [`BinaryOp::Add`] or [`BinaryOp::Sub`] only (pointer+integer)
+    ///
+    /// ### Form 7
+    ///
+    /// Type checking: `[..,P, P]`=>`[..,DI]`
+    ///
+    /// (`DI` is the signed integer type with width equal to the `size_bits` target property)
+    ///
+    /// Operands: `[.., a, b]`=>`[..,res]`
+    ///
+    /// [`BinaryOp::Sub`] only (pointer+pointer)
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= <binary-op> [<overflow-behaviour>]
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// If any operand is `uninit`, all results are `uninit`.
+    ///
+    /// ### Form 1
+    ///
+    /// Computes the value of the specified binary-op with `a,b` according to `overflow-behaviour` (defaults to `wrap` if not specified)
+    ///
+    /// If an operation overflows (or an integer/fixed-point operation attempts to divide by zero), the result is the following, based on the specified `overflow-behaviour`:
+    /// * `wrap`: Wraps modulo `2^N`. Division by zero yields `uninit`
+    /// * `unchecked`: Yields `uninit`
+    /// * `trap`: Causes abnormal program termination
+    /// * `saturate`: Saturates to Minimum/Maxmimum value of the type. Division by zero yields a quotient of the maximum value, and a remainder of the minimum value of the type.
+    ///
+    /// Overflow in this section is not the same as floating-point overflow.
+    /// Operations on floating-point or posit types are not considered to overflow for the purposes of this section, even if they would return +/-infinity from finite inputs or cause the `FE_OVERFLOW` floating-point exception.
+    /// Operations on rationals or fixed-point values *can* cause overflow.
+    ///
+    /// If `overflow-behaviour` is `trap`, and any operand is uninit, the behaviour is undefined.
+    ///
+    /// ### Form 2
+    ///
+    /// Computes the value of the specified binary-op, checking for overflow or input errors.
+    /// If an operation overflow (or an integer/fixed-point operation attempts to divide by zero),
+    ///  the result is wrapped modulo 2^N (or saturated for `div`/`rem`) and the overflow flag (`v`) is `1` (else `0`).
+    ///
+    /// ### Form 3
+    ///
+    /// Compares two scalar or pointer values, and returns `0` if the comparison fails and `1` otherwise.
+    ///
+    /// `overflow-behaviour` is ignored, and may not be `checked`.
+    ///
+    /// ### Form 4
+    ///
+    /// Performs 3-way comparison on a scalar or pointer value, returning `-1` if `a<b`, `0` if `a==b`, or `1` if `a>b`.
+    ///
+    /// `overflow-behaviour` is ignored. If the comparison of `a,b` is unordered, the result is `uninit`.
+    ///
+    /// ### Form 5
+    ///
+    /// Performs 3-way comparison on a scalar value, returning `-1` if `a<b`, `0` if `a==b`, or `1` if `a>b`.
+    ///
+    /// If the comparison of `a,b` is unordered, the result is `uninit`. If the comparison is unordered, then `unord` is `1`, otherwise `unord` is `0`.
+    ///
+    /// ### Form 6
+    ///
+    /// Performs pointer addition/subtraction.
+    ///
+    /// Let `P` be a pointer to `T` where `T` is a complete value type.
+    ///
+    /// For `add`, the result is the pointer derived from `ptr` with address given by the offset from `ptr`
+    ///  determined by the offset between an element `a` and the `idx`th following element `b`.
+    ///
+    /// For `sub`, the result is the pointer derived from `ptr` with address given by the offset from `ptr`
+    ///  determined by the offset between an element `a` and the `idx`th previous element `b`.
+    ///
+    /// `overflow-behaviour` (default is `wrap`) must be either `wrap` or `unchecked`.
+    ///
+    /// If `overflow-behaviour` is `unchecked`, then the result is `uninit` if any of the following are true:
+    /// * The resulting pointer as above does not point into an object
+    /// * The resulting pointer as above points into a different complete object than `ptr`
+    /// * The offset between the elements of the array is the value `off`, such that `off` cannot be exactly represented as a value of type `DI`
+    /// * The resulting pointers address wraps the address space (for a far pointer) or segment (for a near pointer)
+    ///
+    /// (DI is the signed integer type with width equal to the `sizebits` target property)
+    ///
+    /// ### Form 7
+    ///
+    /// Performs pointer subtraction.
+    ///
+    /// Let `P` be a pointer to `T`, where `T` is a complete value type.
+    ///
+    /// Let the offset between the addresses of `b` and `a` be `off`.
+    ///
+    /// Returns `idx`, such that the offset between some element `A` and the `idx`th previous element `B`  is the value `off`.
+    ///
+    /// `overflow-behaviour` (default is `wrap`) must be either `wrap` or `unchecked`.
+    ///
+    /// If `overflow-behaviour` is `unchecked`, then the result is `uninit` if any of the following are true:
+    /// * Either `a` or `b` do not point into an object
+    /// * `a` and `b` do not point into the same complete object
+    /// * Either `off` or `idx` cannot be represented as a value of type `DI`
+    /// * The pointers are near pointers that refer to objects in different segments of the address space
+    ///
+    /// (DI is the signed integer type with width equal to the `sizebits` target property)
     BinaryOp(BinaryOp, OverflowBehaviour),
+    /// Performs the given unary operation
+    ///
+    /// ## Stack
+    /// In all of the following, `S` means a scalar type, `I` means an integer type.
+    /// Each occurance of `S` or `I` in the same type checking specification refers to the same type.
+    ///
+    /// ### Form 1
+    ///
+    /// Type checking: `[..,S]` => `[..,S]`
+    ///
+    /// Operands: `[..,val]`=>`[..,res]`
+    ///
+    /// (Except for [`OverflowBehaviour::Checked`] or [`UnaryOp::LogicNot`])
+    ///
+    /// ### Form 2
+    ///
+    /// Type checking: `[..,S]`=>`[..,S, uint(1)]`
+    ///
+    /// Operands: `[..,val]`=>[..,res,v]
+    ///
+    /// ([`OverflowBehaviour::Checked`] except for [`UnaryOp::LogicNot`]))
+    ///
+    /// ### Form 3
+    ///
+    /// Type checking: `[..I]`=>`[..,I]`
+    ///
+    /// Operands: `[..,val]`=>`[..,val]`
+    ///
+    /// ([`UnaryOp::LogicNot`] only)
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= <unary-op> [<overflow-behaviour>]
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// If `val` is `uninit`, all results are `uninit`.
+    /// `overflow-behaviour` defaults to `wrap`
+    ///
+    /// ### Form 1
+    ///
+    /// Computes the given unary op on `val`, returning the result.
+    ///
+    /// If overflow occurs, the result is according to the `overflow-behaviour`:
+    /// * `wrap`: The value is wrapped modulo 2^N
+    /// * `unchecked`: The result is `uninit`.
+    /// * `trap`: The program terminates abnormally
+    /// * `saturate`: The value is saturated to the minimum/maximum value of the type.
+    ///
+    /// ### Form 2
+    ///
+    /// Computes the given unary op on `val` checking for overflow.
+    ///
+    /// If overflow occurs, the result is wrapped modulo `2^N` and `v` is 1.
+    ///
+    /// ### Form 3
+    ///
+    /// Computes the logical negation of `val`.
+    /// If `val` is `0`, then the result is `1` if the integer type is unsigned, and `-1` if the integer type is signed.
+    /// If `val` is non-zero then the result is `0`.
+    ///
+    /// If `val` cannot be represented as `I` (only possible for width `0` integer types), the result is `0`.
+    ///
+    /// The overflow-behaviour is ignored (overflow-behaviour cannot be `checked`)
+    ///
     UnaryOp(UnaryOp, OverflowBehaviour),
     Convert(ConversionStrength, Type),
     Derive(PointerType, Box<Self>),
+    /// Obtains an lvalue that designates the specified local variable
+    ///
+    /// ## Stack
+    ///
+    /// Type checking: `[..]`=>`[..,lvalue T]`
+    /// Operands: `[..]`=>`[..,local]`
+    ///
+    /// ## Syntax
+    /// ```abnf
+    /// local-id = <IDENT>
+    ///
+    /// expr :/= "local" <local-id>
+    /// ```
+    ///
+    /// where `local-id` matches `"_"*<dec-digit>`
+    ///
+    /// ## Semantics
+    ///
+    /// Pushes an lvalue that designates the specified `<local-id>` defined in the current function.
+    ///
+    /// Ill-formed if `<local-id>` is not defined in the function
+    ///
     Local(u32),
+    /// The stack `pop n` operation
+    ///
+    /// ## Stack
+    ///
+    /// Type checking: `[..,T0,T1, ..., Tn]`=>`[..]`
+    ///
+    /// Operands: `[..,i0,i1, ..., in]`=>`[..]`
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= "pop" [<int-literal>]
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// For `pop n`, pops `n` values from the stack and discards them with no side effects.
+    ///
+    /// `pop` is an alias for `pop 1`.
+    ///
     Pop(u32),
+    /// The stack `dup n` operation
+    ///
+    /// ## Stack
+    ///
+    /// Type checking: `[.., T0, T1, ..., Tn]` => `[..,T0,T1, ..., Tn, T0, T1, ..., Tn]`
+    ///
+    /// Operands: `[..,v0,v1, ..., vn]`=>`[..,v0,v1, ..., vn,v0,v1, ..., vn]`
+    ///
+    /// ## Syntax
+    /// ```abnf
+    /// expr /= "dup" [<int-literal>]
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// For `dup n`, pops `n` values from the stack, then pushes those `n` values twice in order.
+    ///
+    /// `dup` is an alias for `dup 1`
     Dup(u32),
+    /// The stack `pivot m n` operation
+    ///
+    /// ## Stack
+    ///
+    /// Type checking: `[.., S0, S1,  ..., Sm, T0, T1, ..., Tn]`=> `[.., T0, T1, ..., Tn, S0, S1, ..., Sm]`
+    ///
+    /// Operands: `[.., s0, s1, ..., sm, t0, t1, ..., tn]`=>`[.., t0, t1, ..., tn, s0, s1, ..., sm]`
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= "pivot" [<int-literal> [<int-literal>]]
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// For `pivot m n`, pops `n` values from the stack, preserves them in an unspecified location, pops `m` additional values,
+    ///  then pushes the first set of values popped followed by the second set of values popped.
     Pivot(u32, u32),
     Aggregate(AggregateCtor),
+    /// Projects to a field of the type of an aggregate
+    ///
+    /// ## Stack
+    ///
+    /// In all of the following, `A` is an aggregate type or a product type. `F` is the type of the named field of `A`.
+    ///
+    /// The expression is invalid if `A` does not have the field named by `member-name`.
+    ///
+    /// ### Form 1
+    /// Type checking: `[.., A]`=>`[..,F]`
+    ///
+    /// Operands: `[..,a]`=>`[..,f]`
+    ///
+    /// ### Form 2
+    /// Type checking: `[.., lvalue A]`=>`[..,lvalue F]`
+    ///
+    /// Operands: `[..,a]`=>`[..,f]`
+    ///
+    /// ## Syntax
+    /// ```abnf
+    /// member-name := <ident> / <int-literal> / "(" <member-name> ")"
+    /// expr /= "member" <field-name>
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// Projects to a named member of an aggregate type or product type.
+    ///
+    /// ### Form 1
+    ///
+    /// The operand and the result are both rvalues.
+    /// Returns the value of the named member.
+    ///
+    /// ### Form 2
+    /// The operand and the result are both lvalues.
+    /// Returns an lvalue that designates the named member of `a`.
+    /// If the member is a bitfield, then the resulting lvalue is an lvalue that designates a bitfield.
+    ///
+    /// The program is ill-formed if an lvalue that designates a bitfield is used in any of the following ways:
+    /// * As an operand to a `compound_assign`, `fetch_assign`, `assign`, `as_rvalue`, lvalue op, or unary lvalue op with an atomic access class
+    /// * As the operand of a `member` or `addr_of` expression
+    /// * As a value used as an incoming value for a jump target
     Member(String),
     MemberIndirect(String),
     Assign(AccessClass),
@@ -1933,8 +2288,10 @@ impl core::fmt::Display for JumpTarget {
 }
 
 bitflags::bitflags! {
+    /// Flags for the call instruction
     #[repr(transparent)]
     pub struct CallFlags: u32{
+        /// Indicates the the call or tailcall will definitely return in finite time
         const WILLRETURN = 1;
     }
 }

From c9b3b039c24eff66894b524e43eefd3d08eee837 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Tue, 13 Feb 2024 15:35:57 -0600
Subject: [PATCH 19/74] feat(xlang-backend-ssa): implement convert for pointers

---
 xlang/xlang_backend/src/ssa.rs | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 8f09cf54..31fb016e 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -379,7 +379,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 }
                 ir::Value::GlobalAddress { .. } => todo!(),
                 ir::Value::ByteString { .. } => todo!(),
-                ir::Value::String { .. } => todo!(),
+                ir::Value::String { .. } => todo!("{}", loc),
                 ir::Value::LabelAddress(_) => todo!(),
                 ir::Value::Empty => panic!("Empty IR value"),
             },
@@ -591,7 +591,27 @@ impl<M: Machine> BasicBlockBuilder<M> {
             }
             ir::Expr::BinaryOp(_, _) => todo!("binary op"),
             ir::Expr::UnaryOp(_, _) => todo!("unary op"),
-            ir::Expr::Convert(_, _) => todo!("convert"),
+            ir::Expr::Convert(strength, new_ty) => match (self.pop(), strength, new_ty) {
+                (
+                    VStackValue::Pointer(_, val),
+                    ir::ConversionStrength::Reinterpret,
+                    ir::Type::Pointer(new_ty),
+                ) => {
+                    self.push(VStackValue::Pointer(new_ty.clone(), val));
+                }
+                (
+                    VStackValue::Constant(ir::Value::String { encoding, utf8, .. }),
+                    ir::ConversionStrength::Reinterpret,
+                    ir::Type::Pointer(new_ty),
+                ) => {
+                    self.push(VStackValue::Constant(ir::Value::String {
+                        encoding,
+                        utf8,
+                        ty: ir::Type::Pointer(new_ty.clone()),
+                    }));
+                }
+                x => todo!("{:?}", x),
+            },
             ir::Expr::Derive(_, _) => todo!("derive"),
             ir::Expr::Local(_) => todo!("local"),
             ir::Expr::Pop(n) => {

From 9ceac788dda4d69058a171472d146d978b3a4f78 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Tue, 13 Feb 2024 15:41:49 -0600
Subject: [PATCH 20/74] feat(xlang-backend-ssa): implement exit

---
 xlang/xlang_backend/src/ssa.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 31fb016e..e98c7242 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -678,7 +678,10 @@ impl<M: Machine> BasicBlockBuilder<M> {
 
                 self.write_call(target, vals, (**call_fnty).clone(), None);
             }
-            ir::Terminator::Exit(_) => todo!("exit"),
+            ir::Terminator::Exit(n) => {
+                let vals = self.pop_opaque(*n as usize);
+                self.insns.push(SsaInstruction::Exit(vals));
+            }
             ir::Terminator::Asm(_) => todo!("asm"),
             ir::Terminator::Switch(_) => todo!("switch"),
             ir::Terminator::Unreachable => self.insns.push(SsaInstruction::Trap(Trap::Unreachable)),

From 5aea21c5841ca0a7969f827e889730b18c4ab8f3 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 14 Feb 2024 21:35:27 -0500
Subject: [PATCH 21/74] chore: Move autobuild to a submodule

---
 .gitignore                      |   3 +-
 .gitmodules                     |   5 +-
 Cargo.lock                      |  19 +--
 autobuild                       |   1 +
 autobuild.toml                  |   3 +
 autobuild/Cargo.lock            | 154 --------------------
 autobuild/Cargo.toml            |  18 ---
 autobuild/build.rs              |   6 -
 autobuild/src/config.rs         | 239 -------------------------------
 autobuild/src/hash.rs           | 222 -----------------------------
 autobuild/src/hash/blake.rs     |   1 -
 autobuild/src/hash/sha.rs       | 242 --------------------------------
 autobuild/src/helpers.rs        |  26 ----
 autobuild/src/main.rs           |  40 ------
 autobuild/src/programs.rs       |   1 -
 autobuild/src/programs/rustc.rs |  24 ----
 autobuild/src/rand.rs           |  20 ---
 autobuild/src/tools.rs          |  58 --------
 autobuild/src/tools/config.rs   | 230 ------------------------------
 19 files changed, 15 insertions(+), 1297 deletions(-)
 create mode 160000 autobuild
 delete mode 100644 autobuild/Cargo.lock
 delete mode 100644 autobuild/Cargo.toml
 delete mode 100644 autobuild/build.rs
 delete mode 100644 autobuild/src/config.rs
 delete mode 100644 autobuild/src/hash.rs
 delete mode 100644 autobuild/src/hash/blake.rs
 delete mode 100644 autobuild/src/hash/sha.rs
 delete mode 100644 autobuild/src/helpers.rs
 delete mode 100644 autobuild/src/main.rs
 delete mode 100644 autobuild/src/programs.rs
 delete mode 100644 autobuild/src/programs/rustc.rs
 delete mode 100644 autobuild/src/rand.rs
 delete mode 100644 autobuild/src/tools.rs
 delete mode 100644 autobuild/src/tools/config.rs

diff --git a/.gitignore b/.gitignore
index 50ee3084..e6571968 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@ autom4te.cache/
 *.a
 a.out
 testfile
-test-output.txt
\ No newline at end of file
+test-output.txt
+/build*/
\ No newline at end of file
diff --git a/.gitmodules b/.gitmodules
index f0120532..3aa2b241 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -6,4 +6,7 @@
 	url = https://github.com/chorman0773/rust-target-tuples.git
 [submodule "rtlibs"]
 	path = rtlibs
-	url = https://github.com/lccc-project/rtlibs.git
\ No newline at end of file
+	url = https://github.com/lccc-project/rtlibs.git
+[submodule "autobuild"]
+	path = autobuild
+	url = https://github.com/lccc-project/autobuild.git
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 9713e6ce..8eae8725 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,6 +17,7 @@ dependencies = [
 name = "autobuild"
 version = "0.1.0"
 dependencies = [
+ "cfg-match",
  "install-dirs 0.3.2",
  "itertools",
  "lccc-siphash 0.1.0 (git+https://github.com/lccc-project/lccc-siphash)",
@@ -33,15 +34,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
-[[package]]
-name = "binary-io"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d48e3ca0c86b51d14834d49f91771531b31cce782f4d7774fd7908b044e44769"
-dependencies = [
- "fake-enum",
-]
-
 [[package]]
 name = "binfmt"
 version = "0.1.0"
@@ -207,11 +199,9 @@ dependencies = [
 name = "frontend-xir"
 version = "0.1.0"
 dependencies = [
- "binary-io",
- "peekmore",
- "target-tuples",
  "unicode-xid",
  "xlang",
+ "xlang_frontend",
  "xlang_struct",
 ]
 
@@ -264,9 +254,9 @@ version = "0.1.0"
 
 [[package]]
 name = "itertools"
-version = "0.11.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
 dependencies = [
  "either",
 ]
@@ -701,6 +691,7 @@ dependencies = [
 name = "xlang_frontend"
 version = "0.1.0"
 dependencies = [
+ "unicode-xid",
  "xlang",
 ]
 
diff --git a/autobuild b/autobuild
new file mode 160000
index 00000000..67d0bbc2
--- /dev/null
+++ b/autobuild
@@ -0,0 +1 @@
+Subproject commit 67d0bbc2c58160e8ccd5d20243eee49463d47d19
diff --git a/autobuild.toml b/autobuild.toml
index 8820142f..2429cc3a 100644
--- a/autobuild.toml
+++ b/autobuild.toml
@@ -1,7 +1,10 @@
+env = ["RUSTC", "RUSTC_FOR_BUILD"]
+
 [package]
 name = "lccc"
 version = "0.1"
 
+
 [dirs]
 lcccdir = "{libdir}/lccc"
 xlangdir = "{lcccdir}/xlang"
diff --git a/autobuild/Cargo.lock b/autobuild/Cargo.lock
deleted file mode 100644
index 046be4b9..00000000
--- a/autobuild/Cargo.lock
+++ /dev/null
@@ -1,154 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "autobuild"
-version = "0.1.0"
-dependencies = [
- "install-dirs",
- "serde",
- "serde_derive",
- "toml",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
-
-[[package]]
-name = "indexmap"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
-dependencies = [
- "equivalent",
- "hashbrown",
-]
-
-[[package]]
-name = "install-dirs"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bbf71970b5e249fb464339b5a835d35c03bac97a8fb99e8863d444297fa8bb9"
-
-[[package]]
-name = "memchr"
-version = "2.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5486aed0026218e61b8a01d5fbd5a0a134649abb71a0e53b7bc088529dced86e"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_spanned"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96426c9936fd7a0124915f9185ea1d20aa9445cc9821142f0a73bc9207a2e186"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "toml"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17e963a819c331dcacd7ab957d80bc2b9a9c1e71c804826d2f283dd65306542"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.19.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
-
-[[package]]
-name = "winnow"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
-dependencies = [
- "memchr",
-]
diff --git a/autobuild/Cargo.toml b/autobuild/Cargo.toml
deleted file mode 100644
index f76601c6..00000000
--- a/autobuild/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "autobuild"
-version = "0.1.0"
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-serde = "1"
-serde_derive = "1"
-toml = "0.8.8"
-install-dirs= {version="0.3.2", features=["serde"]}
-target-tuples = "0.5.12"
-itertools = "0.11.0"
-lccc-siphash = {git = "https://github.com/lccc-project/lccc-siphash"}
-
-[target.'cfg(unix)'.dependencies]
-libc = "0.2.152"
\ No newline at end of file
diff --git a/autobuild/build.rs b/autobuild/build.rs
deleted file mode 100644
index 504c2a02..00000000
--- a/autobuild/build.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn main() {
-    let env = std::env::var("TARGET").unwrap();
-
-    println!("cargo:rustc-env=TARGET={}", env);
-    println!("cargo:rerun-if-changed=build.rs");
-}
diff --git a/autobuild/src/config.rs b/autobuild/src/config.rs
deleted file mode 100644
index f7545344..00000000
--- a/autobuild/src/config.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-use std::{collections::HashMap, convert::TryFrom, ffi::OsString, path::PathBuf, str::FromStr};
-
-use install_dirs::dirs::InstallDirs;
-use serde_derive::{Deserialize, Serialize};
-
-use target_tuples::{Target, UnknownError};
-
-use crate::hash::{self, FileHash};
-use crate::programs::rustc::RustcVersion;
-use crate::rand::Rand;
-
-#[derive(Clone, Debug)]
-pub enum ConfigVarValue {
-    Set,
-    Unset,
-    Value(String),
-}
-
-impl serde::Serialize for ConfigVarValue {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            ConfigVarValue::Set => serializer.serialize_bool(true),
-            ConfigVarValue::Unset => serializer.serialize_bool(false),
-            ConfigVarValue::Value(v) => serializer.serialize_str(v),
-        }
-    }
-}
-
-impl<'de> serde::Deserialize<'de> for ConfigVarValue {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct ValueVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for ValueVisitor {
-            type Value = ConfigVarValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                formatter.write_str("a string or a boolean")
-            }
-
-            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                if v {
-                    Ok(ConfigVarValue::Set)
-                } else {
-                    Ok(ConfigVarValue::Unset)
-                }
-            }
-
-            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                Ok(ConfigVarValue::Value(v))
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                Ok(ConfigVarValue::Value(v.to_string()))
-            }
-        }
-
-        deserializer.deserialize_any(ValueVisitor)
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConfigInstallDirs {
-    #[serde(flatten)]
-    pub install_dirs: InstallDirs,
-    #[serde(flatten)]
-    pub rest: HashMap<String, PathBuf>,
-}
-
-mod serde_target {
-    use serde::{
-        de::{self, Expected},
-        Deserialize, Deserializer, Serializer,
-    };
-    use target_tuples::Target;
-
-    pub fn serialize<S>(targ: &Target, ser: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        ser.serialize_str(targ.get_name())
-    }
-
-    pub fn deserialize<'de, D>(de: D) -> Result<Target, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct ExpectedTarget;
-
-        impl de::Expected for ExpectedTarget {
-            fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                formatter.write_str("Expected a target in the form <arch>-<sys> or <arch>-<vendor>-<sys> with sys being one of <os>, <env>, <objfmt> or <os> followed by either <env> or <objfmt>")
-            }
-        }
-        let ty = <&str>::deserialize(de)?;
-
-        ty.parse().map_err(|e| {
-            <D::Error as de::Error>::invalid_value(de::Unexpected::Str(ty), &ExpectedTarget)
-        })
-    }
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
-pub struct ConfigTargets {
-    #[serde(with = "serde_target")]
-    pub build: Target,
-    #[serde(with = "serde_target")]
-    pub host: Target,
-    #[serde(with = "serde_target")]
-    pub target: Target,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConfigFoundProgram {
-    pub location: PathBuf,
-    #[serde(flatten)]
-    pub info: Option<ConfigProgramInfo>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub enum ConfigProgramInfo {
-    Rustc(RustcVersion),
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConfigData {
-    pub src_dir: PathBuf,
-    pub dirs: ConfigInstallDirs,
-    pub env: HashMap<String, String>,
-    pub programs: HashMap<String, ConfigFoundProgram>,
-    pub targets: ConfigTargets,
-    pub file_cache: HashMap<String, FileHash>,
-    pub config_vars: HashMap<String, ConfigVarValue>,
-    pub global_key: FileHash,
-}
-
-impl ConfigData {
-    pub fn new(src_dir: PathBuf, dirs: ConfigInstallDirs, targets: ConfigTargets) -> Self {
-        Self {
-            src_dir,
-            dirs,
-            env: HashMap::new(),
-            programs: HashMap::new(),
-            targets,
-            file_cache: HashMap::new(),
-            config_vars: HashMap::new(),
-            global_key: FileHash::ZERO,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ExtraConfigDirs {
-    #[serde(flatten)]
-    pub dirs: HashMap<String, ConfigDirSpec>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum ConfigDirSpec {
-    Plain(String),
-    Separator(Vec<String>),
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize, Default)]
-#[serde(default)]
-pub struct ProgramSpec {
-    #[serde(rename = "type")]
-    pub ty: Option<ProgramType>,
-    pub names: Vec<OsString>,
-    pub target: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum ProgramType {
-    Rustc,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct BuildTargets {
-    pub groups: HashMap<String, GroupSpec>,
-    #[serde(flatten)]
-    pub targets: HashMap<String, TargetSpec>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct GroupSpec {}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct TargetSpec {}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Manifest {
-    pub dirs: ExtraConfigDirs,
-    pub programs: HashMap<String, ProgramSpec>,
-    pub target: BuildTargets,
-}
-
-use std::io;
-
-#[derive(Clone, Debug)]
-pub struct Config {
-    data: Box<ConfigData>,
-    manifests: HashMap<String, Manifest>,
-    rand: Rand,
-}
-
-impl Config {
-    pub fn new(mut data: Box<ConfigData>) -> Self {
-        let mut rand = Rand::init();
-        Self {
-            data,
-            manifests: HashMap::new(),
-            rand,
-        }
-    }
-
-    pub fn check_up_to_date(&mut self, file: String) -> io::Result<bool> {
-        let mut buf = self.data.src_dir.clone();
-        buf.push(&file);
-
-        todo!()
-    }
-}
diff --git a/autobuild/src/hash.rs b/autobuild/src/hash.rs
deleted file mode 100644
index ba6984b8..00000000
--- a/autobuild/src/hash.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-use std::{
-    fs,
-    io::{self, Read as _},
-    path::Path,
-};
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct FileHash([u8; 32]);
-
-impl FileHash {
-    pub const ZERO: FileHash = FileHash([0; 32]);
-}
-
-pub trait FileHasher {
-    type Output: AsRef<[u8]> + 'static;
-
-    /// The size of blocks given to the hash function
-    /// It is a logic error if this is not a power of two (but the result is not undefined behaviour)
-    const BLOCK_SIZE: usize;
-
-    fn update(&mut self, buf: &[u8]);
-
-    fn do_final(self, buf: &[u8]) -> Self::Output;
-}
-
-pub struct HashingReader<R, S> {
-    buf: Vec<u8>,
-    state: S,
-    inner: R,
-}
-
-impl<R, S> HashingReader<R, S> {
-    pub const fn new(state: S, inner: R) -> Self {
-        Self {
-            state,
-            inner,
-            buf: Vec::new(),
-        }
-    }
-
-    pub fn into_inner(self) -> R {
-        self.inner
-    }
-}
-
-impl<R, S: FileHasher> HashingReader<R, S> {
-    pub fn init(&mut self, k: FileHash) {
-        self.buf.clear();
-        self.buf.reserve(S::BLOCK_SIZE);
-
-        if S::BLOCK_SIZE < 32 {
-            for v in k.0.chunks_exact(S::BLOCK_SIZE) {
-                self.state.update(v);
-            }
-        } else {
-            self.buf.extend_from_slice(&k.0);
-        }
-    }
-    pub fn finish(self) -> FileHash {
-        let mut output = [0; 32];
-
-        let val = self.state.do_final(&self.buf);
-
-        let val = val.as_ref();
-
-        let len = val.len().min(32);
-
-        output[..len].copy_from_slice(&val[..len]);
-
-        FileHash(output)
-    }
-}
-
-impl<R: io::Read, S: FileHasher> io::Read for HashingReader<R, S> {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let read = self.inner.read(buf)?;
-
-        let mut bytes = &buf[..read];
-
-        let buf_pos = self.buf.len();
-
-        if bytes.len() > (S::BLOCK_SIZE - buf_pos) {
-            if buf_pos != 0 {
-                let (l, r) = bytes.split_at(S::BLOCK_SIZE - buf_pos);
-                self.buf.extend_from_slice(l);
-                bytes = r;
-                self.state.update(&self.buf);
-                self.buf.clear();
-            }
-
-            let ce = bytes.chunks_exact(S::BLOCK_SIZE);
-            self.buf.extend_from_slice(ce.remainder());
-            for chunk in ce {
-                self.state.update(chunk);
-            }
-        } else {
-            self.buf.extend_from_slice(bytes);
-            self.buf.resize(S::BLOCK_SIZE, 0);
-            self.state.update(&self.buf);
-            self.buf.clear();
-        }
-
-        Ok(read)
-    }
-}
-
-pub mod sha;
-
-pub fn hash_file<S: FileHasher, P: AsRef<Path>>(
-    path: P,
-    hasher: S,
-    key: FileHash,
-) -> io::Result<FileHash> {
-    let mut buf = vec![0; S::BLOCK_SIZE];
-    let file = fs::File::open(path)?;
-
-    let mut reader = HashingReader::new(hasher, file);
-
-    reader.init(key);
-
-    loop {
-        if reader.read(&mut buf)? == 0 {
-            break;
-        }
-    }
-
-    Ok(reader.finish())
-}
-
-const ALPHA: [u8; 16] = [
-    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c', b'd', b'e', b'f',
-];
-
-impl Serialize for FileHash {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut string = Vec::<u8>::with_capacity(64);
-
-        for b in self.0.iter().rev() {
-            string.push(ALPHA[(b >> 4) as usize]);
-            string.push(ALPHA[(b & 0xf) as usize]);
-        }
-
-        // SAFETY: The Vec is entirely ASCII
-        let string = unsafe { String::from_utf8_unchecked(string) };
-
-        serializer.serialize_str(&string)
-    }
-}
-
-impl<'de> Deserialize<'de> for FileHash {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        pub struct HexStringVisitor;
-        impl<'de> serde::de::Visitor<'de> for HexStringVisitor {
-            type Value = [u8; 32];
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                formatter.write_str("a 32-byte value as a hex string")
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                if v.len() != 64 {
-                    return Err(E::invalid_value(serde::de::Unexpected::Str(v), &self));
-                }
-                let mut bytes = [0u8; 32];
-                let mut arrays = v
-                    .as_bytes()
-                    .chunks_exact(2)
-                    .map(|octet| {
-                        let hi = octet[0];
-                        let lo = octet[1];
-
-                        match (hi, lo) {
-                            (
-                                hi @ (b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f'),
-                                lo @ (b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f'),
-                            ) => {
-                                let mut mask = (hi << 1) & 0xF0 | (lo >> 3) & 0xF;
-
-                                mask |= mask >> 1;
-                                mask |= mask >> 2;
-
-                                let val = (hi << 4) & 0xF0 | lo & 0x0F;
-
-                                let val = val + (0xAA & mask);
-
-                                Ok(val)
-                            }
-                            _ => Err(E::invalid_value(serde::de::Unexpected::Str(v), &self)),
-                        }
-                    })
-                    .zip(bytes.iter_mut().rev())
-                    .map(|(b, r)| Ok(*r = b?))
-                    .collect::<Result<(), E>>()?;
-
-                Ok(bytes)
-            }
-
-            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                self.visit_str(&v)
-            }
-        }
-
-        let bytes = deserializer.deserialize_str(HexStringVisitor)?;
-
-        Ok(FileHash(bytes))
-    }
-}
diff --git a/autobuild/src/hash/blake.rs b/autobuild/src/hash/blake.rs
deleted file mode 100644
index 8b137891..00000000
--- a/autobuild/src/hash/blake.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/autobuild/src/hash/sha.rs b/autobuild/src/hash/sha.rs
deleted file mode 100644
index 189930ef..00000000
--- a/autobuild/src/hash/sha.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-use super::FileHasher;
-
-#[derive(Copy, Clone)]
-pub struct Sha64State {
-    state: [u64; 8],
-    processed_bytes: u128,
-}
-
-impl Sha64State {
-    pub const SHA512: Sha64State = Sha64State::with_init([
-        0x6a09e667f3bcc908,
-        0xbb67ae8584caa73b,
-        0x3c6ef372fe94f82b,
-        0xa54ff53a5f1d36f1,
-        0x510e527fade682d1,
-        0x9b05688c2b3e6c1f,
-        0x1f83d9abfb41bd6b,
-        0x5be0cd19137e2179,
-    ]);
-
-    pub const SHA384: Sha64State = Sha64State::with_init([
-        0xcbbb9d5dc1059ed8,
-        0x629a292a367cd507,
-        0x9159015a3070dd17,
-        0x152fecd8f70e5939,
-        0x67332667ffc00b31,
-        0x8eb44a8768581511,
-        0xdb0c2e0d64f98fa7,
-        0x47b5481dbefa4fa4,
-    ]);
-
-    pub const SHA512_256: Sha64State = Sha64State::with_init([
-        0x22312194FC2BF72C,
-        0x9F555FA3C84C64C2,
-        0x2393B86B6F53B151,
-        0x963877195940EABD,
-        0x96283EE2A88EFFE3,
-        0xBE5E1E2553863992,
-        0x2B0199FC2C85B8AA,
-        0x0EB72DDC81C52CA2,
-    ]);
-
-    pub const SHA512_224: Sha64State = Sha64State::with_init([
-        0x8C3D37C819544DA2,
-        0x73E1996689DCD4D6,
-        0x1DFAB7AE32FF9C82,
-        0x679DD514582F9FCF,
-        0x0F6D2B697BD44DA8,
-        0x77E36F7304C48942,
-        0x3F9D85A86A1D36C8,
-        0x1112E6AD91D692A1,
-    ]);
-
-    pub const fn with_init(state: [u64; 8]) -> Self {
-        Self {
-            state,
-            processed_bytes: 0,
-        }
-    }
-
-    #[inline]
-    fn compress(&mut self, w: &[u64; 80]) {
-        static K: [u64; 80] = [
-            0x428a2f98d728ae22,
-            0x7137449123ef65cd,
-            0xb5c0fbcfec4d3b2f,
-            0xe9b5dba58189dbbc,
-            0x3956c25bf348b538,
-            0x59f111f1b605d019,
-            0x923f82a4af194f9b,
-            0xab1c5ed5da6d8118,
-            0xd807aa98a3030242,
-            0x12835b0145706fbe,
-            0x243185be4ee4b28c,
-            0x550c7dc3d5ffb4e2,
-            0x72be5d74f27b896f,
-            0x80deb1fe3b1696b1,
-            0x9bdc06a725c71235,
-            0xc19bf174cf692694,
-            0xe49b69c19ef14ad2,
-            0xefbe4786384f25e3,
-            0x0fc19dc68b8cd5b5,
-            0x240ca1cc77ac9c65,
-            0x2de92c6f592b0275,
-            0x4a7484aa6ea6e483,
-            0x5cb0a9dcbd41fbd4,
-            0x76f988da831153b5,
-            0x983e5152ee66dfab,
-            0xa831c66d2db43210,
-            0xb00327c898fb213f,
-            0xbf597fc7beef0ee4,
-            0xc6e00bf33da88fc2,
-            0xd5a79147930aa725,
-            0x06ca6351e003826f,
-            0x142929670a0e6e70,
-            0x27b70a8546d22ffc,
-            0x2e1b21385c26c926,
-            0x4d2c6dfc5ac42aed,
-            0x53380d139d95b3df,
-            0x650a73548baf63de,
-            0x766a0abb3c77b2a8,
-            0x81c2c92e47edaee6,
-            0x92722c851482353b,
-            0xa2bfe8a14cf10364,
-            0xa81a664bbc423001,
-            0xc24b8b70d0f89791,
-            0xc76c51a30654be30,
-            0xd192e819d6ef5218,
-            0xd69906245565a910,
-            0xf40e35855771202a,
-            0x106aa07032bbd1b8,
-            0x19a4c116b8d2d0c8,
-            0x1e376c085141ab53,
-            0x2748774cdf8eeb99,
-            0x34b0bcb5e19b48a8,
-            0x391c0cb3c5c95a63,
-            0x4ed8aa4ae3418acb,
-            0x5b9cca4f7763e373,
-            0x682e6ff3d6b2b8a3,
-            0x748f82ee5defb2fc,
-            0x78a5636f43172f60,
-            0x84c87814a1f0ab72,
-            0x8cc702081a6439ec,
-            0x90befffa23631e28,
-            0xa4506cebde82bde9,
-            0xbef9a3f7b2c67915,
-            0xc67178f2e372532b,
-            0xca273eceea26619c,
-            0xd186b8c721c0c207,
-            0xeada7dd6cde0eb1e,
-            0xf57d4f7fee6ed178,
-            0x06f067aa72176fba,
-            0x0a637dc5a2c898a6,
-            0x113f9804bef90dae,
-            0x1b710b35131c471b,
-            0x28db77f523047d84,
-            0x32caab7b40c72493,
-            0x3c9ebe0a15c9bebc,
-            0x431d67c49c100d4c,
-            0x4cc5d4becb3e42b6,
-            0x597f299cfc657e2a,
-            0x5fcb6fab3ad6faec,
-            0x6c44198c4a475817,
-        ];
-        let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = self.state;
-
-        for i in 0..80 {
-            let S0 = (a.rotate_right(28)) ^ (a.rotate_right(34)) ^ (a.rotate_right(39));
-            let S1 = (e.rotate_right(14)) ^ (e.rotate_right(18)) ^ (e.rotate_right(41));
-            let ch = (e & f) ^ (!e & g);
-            let maj = (a & b) ^ (a & c) ^ (b & c);
-            let temp1 = h
-                .wrapping_add(S1)
-                .wrapping_add(ch)
-                .wrapping_add(K[i])
-                .wrapping_add(w[i]);
-            let temp2 = S0.wrapping_add(maj);
-
-            h = g;
-            g = f;
-            f = e;
-            e = d.wrapping_add(temp1);
-            d = c;
-            c = b;
-            b = a;
-            a = temp1.wrapping_add(temp2);
-        }
-
-        for (h, v) in self.state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
-            *h = (*h).wrapping_add(v);
-        }
-    }
-
-    #[inline]
-    fn update_with(&mut self, msg: &[u8]) {
-        let mut w = [0u64; 80];
-
-        for (i, v) in msg.chunks_exact(8).enumerate() {
-            // SAFETY: chunks_exact returns exactly 8 byte chunks
-            w[i] = u64::from_be_bytes(unsafe { *(v as *const [u8] as *const [u8; 8]) });
-        }
-
-        for i in 16..80 {
-            let s0 = (w[i - 15].rotate_right(1)) ^ (w[i - 15].rotate_right(8)) ^ (w[i - 15] >> 7);
-            let s1 = (w[i - 2].rotate_right(19)) ^ (w[i - 2].rotate_right(61)) ^ (w[i - 2] >> 6);
-
-            w[i] = w[i - 16]
-                .wrapping_add(s0)
-                .wrapping_add(w[i - 7])
-                .wrapping_add(s1);
-        }
-
-        self.compress(&w);
-    }
-}
-
-impl FileHasher for Sha64State {
-    type Output = [u8; 64];
-    const BLOCK_SIZE: usize = 128;
-
-    #[inline]
-    fn update(&mut self, msg: &[u8]) {
-        assert!(msg.len() == 128);
-
-        self.processed_bytes += 128;
-
-        self.update_with(msg);
-    }
-
-    #[inline]
-    fn do_final(mut self, msg_tail: &[u8]) -> [u8; 64] {
-        assert!(msg_tail.len() < 128);
-
-        let mut real_msg = [0u8; 128];
-        let tail_len = msg_tail.len();
-
-        let processed_bytes = self.processed_bytes + (tail_len as u128);
-
-        real_msg[..tail_len].copy_from_slice(msg_tail);
-
-        real_msg[tail_len] = 0x80;
-
-        if tail_len < 17 {
-            self.update_with(&real_msg);
-            real_msg.fill(0);
-        }
-
-        let processed_bits = processed_bytes << 3;
-
-        real_msg[112..].copy_from_slice(&processed_bits.to_be_bytes());
-
-        self.update_with(&real_msg);
-
-        let mut output = [0u8; 64];
-
-        for (output, val) in output.chunks_exact_mut(8).zip(self.state) {
-            output.copy_from_slice(&val.to_be_bytes())
-        }
-
-        output
-    }
-}
diff --git a/autobuild/src/helpers.rs b/autobuild/src/helpers.rs
deleted file mode 100644
index b64ae668..00000000
--- a/autobuild/src/helpers.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-pub trait SplitOnceOwned: Sized {
-    fn split_once_take(&mut self, pat: &str) -> Option<(Self, Self)>;
-    fn split_once_owned(mut self, pat: &str) -> Result<(Self, Self), Self> {
-        self.split_once_take(pat).ok_or(self)
-    }
-}
-
-impl SplitOnceOwned for String {
-    fn split_once_take(&mut self, pat: &str) -> Option<(Self, Self)> {
-        if let Some(pos) = self.find(pat) {
-            let mut new_str = Vec::new();
-
-            let off = pos + pat.len();
-
-            new_str.extend_from_slice(&self.as_bytes()[off..]);
-
-            self.truncate(pos);
-
-            Some((core::mem::take(self), unsafe {
-                String::from_utf8_unchecked(new_str)
-            }))
-        } else {
-            None
-        }
-    }
-}
diff --git a/autobuild/src/main.rs b/autobuild/src/main.rs
deleted file mode 100644
index fbd5adec..00000000
--- a/autobuild/src/main.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use std::env::Args;
-use std::io;
-
-mod config;
-mod hash;
-mod helpers;
-mod programs;
-mod rand;
-mod tools;
-
-fn main() {
-    let mut args = std::env::args();
-
-    let mut prg_name = args.next().unwrap();
-
-    if prg_name == "cargo" {
-        prg_name.push(' ');
-        prg_name += &args.next().unwrap();
-    }
-
-    match real_main(&prg_name, args) {
-        Ok(()) => {}
-        Err(e) => {
-            eprintln!("{}: {}", prg_name, e);
-
-            std::process::exit(1);
-        }
-    }
-}
-
-fn real_main(prg_name: &str, mut args: Args) -> io::Result<()> {
-    let subcommand = args
-        .next()
-        .ok_or_else(|| ())
-        .or_else(|_| tools::help_subcommands())?;
-
-    let subcommand_entry = tools::find_tool(&subcommand)?;
-
-    subcommand_entry(prg_name, args)
-}
diff --git a/autobuild/src/programs.rs b/autobuild/src/programs.rs
deleted file mode 100644
index 3d8b2d42..00000000
--- a/autobuild/src/programs.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod rustc;
diff --git a/autobuild/src/programs/rustc.rs b/autobuild/src/programs/rustc.rs
deleted file mode 100644
index f4377481..00000000
--- a/autobuild/src/programs/rustc.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use std::collections::HashSet;
-
-use serde_derive::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct RustcVersion {
-    pub supported_editions: HashSet<RustEdition>,
-    pub features_available: HashSet<RustcFeature>,
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum RustEdition {
-    Rust2015,
-    Rust2018,
-    Rust2021,
-    Rust2024,
-}
-
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum RustcFeature {
-    AllowNightly,
-}
diff --git a/autobuild/src/rand.rs b/autobuild/src/rand.rs
deleted file mode 100644
index 92b33ca0..00000000
--- a/autobuild/src/rand.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use lccc_siphash::siphash::sys::SipHashState;
-
-#[derive(Clone, Debug)]
-pub struct Rand(SipHashState);
-
-impl Rand {
-    pub fn init() -> Self {
-        let mut keys;
-
-        #[cfg(unix)]
-        unsafe {
-            keys = [0, 0];
-            libc::getrandom(keys.as_mut_ptr().cast(), 16, libc::GRND_RANDOM);
-        }
-
-        let [k0, k1] = keys;
-
-        Self(SipHashState::from_keys(k0, k1))
-    }
-}
diff --git a/autobuild/src/tools.rs b/autobuild/src/tools.rs
deleted file mode 100644
index 3b5bb8b6..00000000
--- a/autobuild/src/tools.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use std::env::Args;
-use std::io;
-
-macro_rules! def_tools{
-    {
-        $(tool $tool:ident;)*
-    } => {
-        $(pub mod $tool;)*
-
-        pub fn find_tool(x: &str) -> io::Result<fn(&str, Args)->io::Result<()>>{
-            match x{
-                $(::core::stringify!($tool) => Ok($tool::main),)*
-                x => Err(io::Error::new(io::ErrorKind::InvalidInput, format!("No such subcommand {}", x)))
-            }
-        }
-
-        pub fn print_help(prg_name: &str, tool_name: &str, help_cb: fn()){
-            println!("Usage: {} <subcommand>",prg_name);
-            println!("Available Subcommands:");
-            $(println!("\t{}", ::core::stringify!($tool));)*
-
-            println!("{} {} Usage:", prg_name, tool_name);
-            help_cb()
-        }
-
-        pub fn help_subcommands<T>() -> io::Result<T>{
-            Err(io::Error::new(io::ErrorKind::InvalidInput, {
-                use core::fmt::Write;
-                let mut st = String::new();
-
-                let _ = writeln!(st, "Subcommands:");
-                $(let _ = writeln!(st, "\t{}", ::core::stringify!($tool));)*
-
-                st
-            }))
-        }
-    }
-}
-
-def_tools! {
-    tool config;
-}
-
-pub fn print_version() {
-    println!("cargo-autobuild v{}", env!("CARGO_PKG_VERSION"));
-    println!("Copyright (C) 2024 LCCC Maintainers");
-    println!("This Package is released under the terms of the 2BSD License + Patent Grant");
-    println!("See LICENSE for details");
-}
-
-pub fn require_arg<I: Iterator<Item = String>>(flag: &str, args: &mut I) -> io::Result<String> {
-    args.next().ok_or_else(|| {
-        io::Error::new(
-            io::ErrorKind::InvalidInput,
-            format!("{} requires an argument", flag),
-        )
-    })
-}
diff --git a/autobuild/src/tools/config.rs b/autobuild/src/tools/config.rs
deleted file mode 100644
index d4961ca1..00000000
--- a/autobuild/src/tools/config.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-use std::collections::HashMap;
-use std::env::Args;
-use std::fs::File;
-use std::io::{self, Read};
-
-use std::path::{Path, PathBuf};
-
-use install_dirs::dirs::InstallDirs;
-use target_tuples::Target;
-
-use crate::config::{ConfigData, ConfigInstallDirs, ConfigTargets, ConfigVarValue};
-use crate::helpers::SplitOnceOwned;
-
-fn help() {
-    println!()
-}
-
-pub fn main(prg_name: &str, mut args: Args) -> io::Result<()> {
-    let mut base_dir = None;
-    let mut src_dir = None;
-    let mut cfg_dir = None;
-    let mut config_vars = HashMap::new();
-    let mut extra_install_dirs = HashMap::new();
-
-    let mut prefix_set = false;
-
-    let mut install_dirs = InstallDirs::defaults();
-
-    let mut build_alias = None;
-    let mut host_alias = None;
-    let mut target_alias = None;
-
-    install_dirs.read_env();
-
-    while let Some(arg) = args.next() {
-        match &*arg {
-            "--help" => {
-                super::print_help(prg_name, "config", help);
-                return Ok(());
-            }
-            "--version" => {
-                super::print_version();
-                return Ok(());
-            }
-            "--set" => {
-                let mut val = super::require_arg("--set", &mut args)?;
-
-                if let Some((k, v)) = val.split_once_take("=") {
-                    config_vars.insert(k, ConfigVarValue::Value(v));
-                } else {
-                    config_vars.insert(val, ConfigVarValue::Set);
-                }
-            }
-            "--unset" => {
-                let val = super::require_arg("--unset", &mut args)?;
-
-                config_vars.insert(val, ConfigVarValue::Unset);
-            }
-            "--install" => {
-                let mut val = super::require_arg("--install", &mut args)?;
-
-                let (k,v) = val.split_once_owned("=")
-                    .map_err(|val| io::Error::new(io::ErrorKind::InvalidInput, format!("--install requires an argument of the form dir=path, but got `{}` instead", val)))?;
-
-                extra_install_dirs.insert(k, PathBuf::from(v));
-            }
-            "--src-dir" => {
-                let val = super::require_arg("--src-dir", &mut args)?;
-
-                src_dir = Some(PathBuf::from(val));
-            }
-
-            "--config-dir" => {
-                let val = super::require_arg("--config-dir", &mut args)?;
-
-                cfg_dir = Some(PathBuf::from(val));
-            }
-
-            "--prefix" => {
-                let val = super::require_arg("--prefix", &mut args)?;
-
-                install_dirs.prefix = PathBuf::from(val);
-
-                prefix_set = true
-            }
-            "--build" => {
-                let val = super::require_arg("--build", &mut args)?;
-
-                build_alias = Some(val);
-            }
-
-            "--host" => {
-                let val = super::require_arg("--host", &mut args)?;
-
-                host_alias = Some(val);
-            }
-
-            "--target" => {
-                let val = super::require_arg("--target", &mut args)?;
-
-                target_alias = Some(val);
-            }
-
-            "--" => {
-                base_dir = args.next().map(PathBuf::from);
-                break;
-            }
-            x if x.starts_with("--") => {
-                let val = super::require_arg(x, &mut args)?;
-
-                install_dirs.set_from_arg(x, val).map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Unrecognized option {}", x),
-                    )
-                })?;
-            }
-
-            _ => {
-                base_dir = Some(PathBuf::from(arg));
-                break;
-            }
-        }
-    }
-
-    let base_dir = base_dir.ok_or(()).or_else(|_| std::env::current_dir())?;
-
-    let base_dir = base_dir.canonicalize()?;
-
-    let cfg_dir = match cfg_dir {
-        Some(cfg_dir) => cfg_dir.canonicalize()?,
-        None => {
-            let mut base_dir_config = base_dir.clone();
-            base_dir_config.push(".config.toml");
-
-            if std::fs::metadata(base_dir_config).is_ok() {
-                base_dir.clone()
-            } else {
-                std::env::current_dir()?
-            }
-        }
-    };
-
-    let cfg_file = {
-        let mut buf = cfg_dir.clone();
-        buf.push(".config.toml");
-        buf
-    };
-
-    let mut cfg_data = match File::open(&cfg_file) {
-        Ok(mut file) => {
-            let mut st = String::new();
-            file.read_to_string(&mut st)?;
-            Box::new(
-                toml::from_str::<ConfigData>(&st)
-                    .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
-            )
-        }
-        Err(_) => {
-            let src_dir = match src_dir {
-                Some(src_dir) => src_dir.canonicalize()?,
-                None => {
-                    let mut src_dir = base_dir;
-
-                    loop {
-                        let mut autobuild_file = src_dir.clone();
-                        autobuild_file.push("autobuild.toml");
-
-                        if std::fs::metadata(autobuild_file).is_ok() {
-                            break;
-                        } else if &src_dir == Path::new("/") {
-                            return Err(io::Error::new(
-                                io::ErrorKind::InvalidInput,
-                                "Could not find source manifest (autobuild.toml)",
-                            ));
-                        } else {
-                            src_dir.pop();
-                        }
-                    }
-
-                    src_dir
-                }
-            };
-
-            let build = match build_alias.as_ref() {
-                Some(alias) => alias.parse().map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Target `{}` is not recognized or cannot be parsed", alias),
-                    )
-                })?,
-                None => target_tuples::from_env!("TARGET"),
-            };
-
-            let host = match host_alias.as_ref() {
-                Some(alias) => alias.parse().map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Target `{}` is not recognized or cannot be parsed", alias),
-                    )
-                })?,
-                None => build.clone(),
-            };
-
-            let target = match target_alias.as_ref() {
-                Some(alias) => alias.parse().map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Target `{}` is not recognized or cannot be parsed", alias),
-                    )
-                })?,
-                None => host.clone(),
-            };
-
-            let dirs = ConfigInstallDirs {
-                install_dirs,
-                rest: extra_install_dirs,
-            };
-
-            let targets = ConfigTargets {
-                build,
-                host,
-                target,
-            };
-            Box::new(ConfigData::new(src_dir, dirs, targets))
-        }
-    };
-
-    Ok(())
-}

From f6853ceefbaaa5656c79c23add74799cfba7cac1 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 25 Feb 2024 21:14:22 -0500
Subject: [PATCH 22/74] feat: Add `RUSTFLAGS` to autobuild.toml

---
 Cargo.lock     | 37 ++++++++++++++-----------------------
 Cargo.toml     |  1 +
 autobuild      |  2 +-
 autobuild.toml |  3 +--
 4 files changed, 17 insertions(+), 26 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8eae8725..75371f8c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,13 +19,13 @@ version = "0.1.0"
 dependencies = [
  "cfg-match",
  "install-dirs 0.3.2",
- "itertools",
  "lccc-siphash 0.1.0 (git+https://github.com/lccc-project/lccc-siphash)",
  "libc",
  "serde",
  "serde_derive",
  "target-tuples",
- "toml 0.8.8",
+ "toml 0.8.10",
+ "with_builtin_macros",
 ]
 
 [[package]]
@@ -216,15 +216,15 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 
 [[package]]
 name = "indexmap"
-version = "2.0.0"
+version = "2.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "233cf39063f058ea2caae4091bf4a3ef70a653afbc026f5c4a4135d114e3c177"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -252,15 +252,6 @@ dependencies = [
 name = "interning-static-syms"
 version = "0.1.0"
 
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -320,9 +311,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.6.2"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5486aed0026218e61b8a01d5fbd5a0a134649abb71a0e53b7bc088529dced86e"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "once_cell"
@@ -500,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.8"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35"
+checksum = "9a9aad4a3066010876e8dcf5a8a06e70a558751117a145c6ce2b82c2e2054290"
 dependencies = [
  "serde",
  "serde_spanned",
@@ -521,9 +512,9 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.21.0"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03"
+checksum = "2c1b5fd4128cc8d3e0cb74d4ed9a9cc7c7284becd4df68f5f940e1ad123606f6"
 dependencies = [
  "indexmap",
  "serde",
@@ -621,9 +612,9 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "winnow"
-version = "0.5.15"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
+checksum = "7a4191c47f15cc3ec71fcb4913cb83d58def65dd3787610213c649283b5ce178"
 dependencies = [
  "memchr",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index a2e2e1cf..13bb7a81 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,3 +14,4 @@ members = [
     "rust/interning-static-syms",
     "rust/rust_mir_macro",
 ]
+exclude = []
diff --git a/autobuild b/autobuild
index 67d0bbc2..fb101710 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit 67d0bbc2c58160e8ccd5d20243eee49463d47d19
+Subproject commit fb101710b7e09b79a2cd1ca62494204b4342b181
diff --git a/autobuild.toml b/autobuild.toml
index 2429cc3a..1b0a7049 100644
--- a/autobuild.toml
+++ b/autobuild.toml
@@ -1,10 +1,9 @@
-env = ["RUSTC", "RUSTC_FOR_BUILD"]
+env = ["RUSTC", "RUSTC_FOR_BUILD", "RUSTFLAGS", "RUSTFLAGS_FOR_BUILDS"]
 
 [package]
 name = "lccc"
 version = "0.1"
 
-
 [dirs]
 lcccdir = "{libdir}/lccc"
 xlangdir = "{lcccdir}/xlang"

From b41bcd859e3c6ab26945adc8d2182ef47d430504 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Tue, 27 Feb 2024 21:42:57 -0500
Subject: [PATCH 23/74] chore: Remove vendor directory from git

---
 vendor/bitflags/.cargo-checksum.json          |    1 -
 vendor/bitflags/CHANGELOG.md                  |  206 -
 vendor/bitflags/CODE_OF_CONDUCT.md            |   73 -
 vendor/bitflags/Cargo.toml                    |   58 -
 vendor/bitflags/LICENSE-APACHE                |  201 -
 vendor/bitflags/LICENSE-MIT                   |   25 -
 vendor/bitflags/README.md                     |   32 -
 vendor/bitflags/src/example_generated.rs      |   14 -
 vendor/bitflags/src/lib.rs                    | 1729 -----
 vendor/bitflags/tests/basic.rs                |   20 -
 .../bitflags/tests/compile-fail/impls/copy.rs |   10 -
 .../tests/compile-fail/impls/copy.stderr.beta |   27 -
 .../bitflags/tests/compile-fail/impls/eq.rs   |   10 -
 .../tests/compile-fail/impls/eq.stderr.beta   |   55 -
 .../non_integer_base/all_defined.rs           |  123 -
 .../non_integer_base/all_defined.stderr.beta  |   27 -
 .../non_integer_base/all_missing.rs           |   13 -
 .../non_integer_base/all_missing.stderr.beta  |   13 -
 .../compile-fail/visibility/private_field.rs  |   13 -
 .../visibility/private_field.stderr.beta      |   10 -
 .../compile-fail/visibility/private_flags.rs  |   18 -
 .../visibility/private_flags.stderr.beta      |   18 -
 .../compile-fail/visibility/pub_const.rs      |    9 -
 .../visibility/pub_const.stderr.beta          |    5 -
 .../tests/compile-pass/impls/convert.rs       |   17 -
 .../tests/compile-pass/impls/default.rs       |   10 -
 .../compile-pass/impls/inherent_methods.rs    |   15 -
 .../tests/compile-pass/redefinition/core.rs   |   14 -
 .../compile-pass/redefinition/stringify.rs    |   19 -
 vendor/bitflags/tests/compile-pass/repr/c.rs  |   10 -
 .../tests/compile-pass/repr/transparent.rs    |   10 -
 .../compile-pass/visibility/bits_field.rs     |   11 -
 .../tests/compile-pass/visibility/pub_in.rs   |   19 -
 vendor/bitflags/tests/compile.rs              |   63 -
 vendor/bytemuck/.cargo-checksum.json          |    1 -
 vendor/bytemuck/Cargo.toml                    |   41 -
 vendor/bytemuck/LICENSE-APACHE                |   61 -
 vendor/bytemuck/LICENSE-MIT                   |    9 -
 vendor/bytemuck/LICENSE-ZLIB                  |   11 -
 vendor/bytemuck/README.md                     |   19 -
 vendor/bytemuck/changelog.md                  |  161 -
 vendor/bytemuck/rustfmt.toml                  |   16 -
 vendor/bytemuck/src/allocation.rs             |  215 -
 vendor/bytemuck/src/contiguous.rs             |  202 -
 vendor/bytemuck/src/lib.rs                    |  471 --
 vendor/bytemuck/src/offset_of.rs              |  135 -
 vendor/bytemuck/src/pod.rs                    |  119 -
 vendor/bytemuck/src/transparent.rs            |  249 -
 vendor/bytemuck/src/zeroable.rs               |  158 -
 vendor/bytemuck/tests/array_tests.rs          |   12 -
 vendor/bytemuck/tests/cast_slice_tests.rs     |  194 -
 vendor/bytemuck/tests/derive.rs               |   25 -
 vendor/bytemuck/tests/doc_tests.rs            |  121 -
 vendor/bytemuck/tests/offset_of_tests.rs      |   59 -
 vendor/bytemuck/tests/std_tests.rs            |   45 -
 vendor/bytemuck/tests/transparent.rs          |   64 -
 vendor/bytemuck/tests/wrapper_forgets.rs      |   13 -
 vendor/bytemuck_derive/.cargo-checksum.json   |    1 -
 vendor/bytemuck_derive/Cargo.toml             |   37 -
 vendor/bytemuck_derive/LICENSE-APACHE         |   61 -
 vendor/bytemuck_derive/LICENSE-MIT            |    9 -
 vendor/bytemuck_derive/LICENSE-ZLIB           |   11 -
 vendor/bytemuck_derive/README.md              |    4 -
 vendor/bytemuck_derive/changelog.md           |   11 -
 vendor/bytemuck_derive/src/lib.rs             |  179 -
 vendor/bytemuck_derive/src/traits.rs          |  328 -
 vendor/bytemuck_derive/tests/basic.rs         |   50 -
 vendor/fake-enum/.cargo-checksum.json         |    1 -
 vendor/fake-enum/Cargo.toml                   |   22 -
 vendor/fake-enum/LICENSE-APACHE               |  201 -
 vendor/fake-enum/LICENSE-MIT                  |    8 -
 vendor/fake-enum/Makefile.in                  |  179 -
 vendor/fake-enum/README.md                    |   13 -
 vendor/fake-enum/aclocal.m4                   |   16 -
 vendor/fake-enum/build-dirs.sh                |    4 -
 vendor/fake-enum/config.guess                 | 1700 -----
 vendor/fake-enum/config.sub                   | 1879 ------
 vendor/fake-enum/configure                    | 4207 ------------
 vendor/fake-enum/configure.ac                 |   23 -
 vendor/fake-enum/install-sh                   |  541 --
 vendor/fake-enum/m4/ax_prog_cc_for_build.m4   |  139 -
 vendor/fake-enum/m4/bindgen.m4                |    5 -
 vendor/fake-enum/m4/build_std.m4              |   38 -
 vendor/fake-enum/m4/lcrust_checks.m4          |   48 -
 vendor/fake-enum/m4/lcrust_prog_rustc.m4      |  585 --
 vendor/fake-enum/run-tests.sh                 |    4 -
 vendor/fake-enum/src/lib.rs                   |  182 -
 vendor/install-dirs/.cargo-checksum.json      |    1 -
 vendor/install-dirs/Cargo.toml                |   24 -
 vendor/install-dirs/README.md                 |    3 -
 vendor/install-dirs/src/dirs.rs               |  632 --
 vendor/install-dirs/src/lib.rs                |    1 -
 vendor/lazy_static/.cargo-checksum.json       |    1 -
 vendor/lazy_static/Cargo.toml                 |   46 -
 vendor/lazy_static/LICENSE-APACHE             |  201 -
 vendor/lazy_static/LICENSE-MIT                |   25 -
 vendor/lazy_static/README.md                  |   79 -
 vendor/lazy_static/src/core_lazy.rs           |   31 -
 vendor/lazy_static/src/inline_lazy.rs         |   57 -
 vendor/lazy_static/src/lib.rs                 |  215 -
 vendor/lazy_static/tests/no_std.rs            |   20 -
 vendor/lazy_static/tests/test.rs              |  164 -
 vendor/proc-macro2/.cargo-checksum.json       |    1 -
 vendor/proc-macro2/Cargo.toml                 |   41 -
 vendor/proc-macro2/LICENSE-APACHE             |  201 -
 vendor/proc-macro2/LICENSE-MIT                |   25 -
 vendor/proc-macro2/README.md                  |   93 -
 vendor/proc-macro2/build.rs                   |  172 -
 vendor/proc-macro2/src/detection.rs           |   67 -
 vendor/proc-macro2/src/fallback.rs            |  923 ---
 vendor/proc-macro2/src/lib.rs                 | 1272 ----
 vendor/proc-macro2/src/marker.rs              |   18 -
 vendor/proc-macro2/src/parse.rs               |  866 ---
 vendor/proc-macro2/src/wrapper.rs             |  966 ---
 vendor/proc-macro2/tests/comments.rs          |  103 -
 vendor/proc-macro2/tests/features.rs          |    8 -
 vendor/proc-macro2/tests/marker.rs            |   92 -
 vendor/proc-macro2/tests/test.rs              |  562 --
 vendor/proc-macro2/tests/test_fmt.rs          |   26 -
 vendor/quote/.cargo-checksum.json             |    1 -
 vendor/quote/Cargo.toml                       |   40 -
 vendor/quote/LICENSE-APACHE                   |  201 -
 vendor/quote/LICENSE-MIT                      |   25 -
 vendor/quote/README.md                        |  261 -
 vendor/quote/src/ext.rs                       |  112 -
 vendor/quote/src/format.rs                    |  164 -
 vendor/quote/src/ident_fragment.rs            |   86 -
 vendor/quote/src/lib.rs                       | 1267 ----
 vendor/quote/src/runtime.rs                   |  402 --
 vendor/quote/src/spanned.rs                   |   42 -
 vendor/quote/src/to_tokens.rs                 |  209 -
 vendor/quote/tests/compiletest.rs             |    6 -
 vendor/quote/tests/test.rs                    |  459 --
 .../ui/does-not-have-iter-interpolated-dup.rs |    9 -
 .../ui/does-not-have-iter-interpolated.rs     |    9 -
 .../tests/ui/does-not-have-iter-separated.rs  |    5 -
 vendor/quote/tests/ui/does-not-have-iter.rs   |    5 -
 vendor/quote/tests/ui/not-quotable.rs         |    7 -
 vendor/quote/tests/ui/not-repeatable.rs       |    8 -
 vendor/quote/tests/ui/wrong-type-span.rs      |    7 -
 vendor/serde/.cargo-checksum.json             |    1 -
 vendor/serde/Cargo.toml                       |   44 -
 vendor/serde/LICENSE-APACHE                   |  201 -
 vendor/serde/LICENSE-MIT                      |   23 -
 vendor/serde/README.md                        |  111 -
 vendor/serde/build.rs                         |  139 -
 vendor/serde/crates-io.md                     |   62 -
 vendor/serde/src/de/ignored_any.rs            |  243 -
 vendor/serde/src/de/impls.rs                  | 2664 --------
 vendor/serde/src/de/mod.rs                    | 2275 -------
 vendor/serde/src/de/seed.rs                   |   19 -
 vendor/serde/src/de/utf8.rs                   |   46 -
 vendor/serde/src/de/value.rs                  | 1635 -----
 vendor/serde/src/integer128.rs                |   82 -
 vendor/serde/src/lib.rs                       |  297 -
 vendor/serde/src/macros.rs                    |  236 -
 vendor/serde/src/private/de.rs                | 2959 ---------
 vendor/serde/src/private/doc.rs               |  159 -
 vendor/serde/src/private/mod.rs               |   50 -
 vendor/serde/src/private/ser.rs               | 1310 ----
 vendor/serde/src/private/size_hint.rs         |   21 -
 vendor/serde/src/ser/fmt.rs                   |  174 -
 vendor/serde/src/ser/impls.rs                 |  935 ---
 vendor/serde/src/ser/impossible.rs            |  216 -
 vendor/serde/src/ser/mod.rs                   | 1986 ------
 vendor/serde/src/std_error.rs                 |   48 -
 vendor/serde_derive/.cargo-checksum.json      |    1 -
 vendor/serde_derive/Cargo.toml                |   44 -
 vendor/serde_derive/LICENSE-APACHE            |  201 -
 vendor/serde_derive/LICENSE-MIT               |   23 -
 vendor/serde_derive/README.md                 |  111 -
 vendor/serde_derive/build.rs                  |   36 -
 vendor/serde_derive/crates-io.md              |   62 -
 vendor/serde_derive/src/bound.rs              |  408 --
 vendor/serde_derive/src/de.rs                 | 3132 ---------
 vendor/serde_derive/src/dummy.rs              |   48 -
 vendor/serde_derive/src/fragment.rs           |   74 -
 vendor/serde_derive/src/internals/ast.rs      |  202 -
 vendor/serde_derive/src/internals/attr.rs     | 1954 ------
 vendor/serde_derive/src/internals/case.rs     |  197 -
 vendor/serde_derive/src/internals/check.rs    |  420 --
 vendor/serde_derive/src/internals/ctxt.rs     |   62 -
 vendor/serde_derive/src/internals/mod.rs      |   28 -
 vendor/serde_derive/src/internals/receiver.rs |  287 -
 vendor/serde_derive/src/internals/respan.rs   |   16 -
 vendor/serde_derive/src/internals/symbol.rs   |   68 -
 vendor/serde_derive/src/lib.rs                |  107 -
 vendor/serde_derive/src/pretend.rs            |  201 -
 vendor/serde_derive/src/ser.rs                | 1338 ----
 vendor/serde_derive/src/try.rs                |   24 -
 vendor/static_assertions/.cargo-checksum.json |    1 -
 vendor/static_assertions/CHANGELOG.md         |  181 -
 vendor/static_assertions/Cargo.toml           |   39 -
 vendor/static_assertions/LICENSE-APACHE       |  202 -
 vendor/static_assertions/LICENSE-MIT          |   21 -
 vendor/static_assertions/README.md            |  188 -
 vendor/static_assertions/src/assert_cfg.rs    |   49 -
 .../static_assertions/src/assert_eq_align.rs  |   45 -
 .../static_assertions/src/assert_eq_size.rs   |  123 -
 vendor/static_assertions/src/assert_fields.rs |   72 -
 vendor/static_assertions/src/assert_impl.rs   |  356 --
 .../static_assertions/src/assert_obj_safe.rs  |   76 -
 vendor/static_assertions/src/assert_trait.rs  |  105 -
 vendor/static_assertions/src/assert_type.rs   |  101 -
 vendor/static_assertions/src/const_assert.rs  |  109 -
 vendor/static_assertions/src/lib.rs           |   97 -
 vendor/syn/.cargo-checksum.json               |    1 -
 vendor/syn/Cargo.toml                         |   97 -
 vendor/syn/LICENSE-APACHE                     |  201 -
 vendor/syn/LICENSE-MIT                        |   23 -
 vendor/syn/README.md                          |  285 -
 vendor/syn/benches/file.rs                    |   30 -
 vendor/syn/benches/rust.rs                    |  158 -
 vendor/syn/build.rs                           |   43 -
 vendor/syn/src/attr.rs                        |  664 --
 vendor/syn/src/await.rs                       |    2 -
 vendor/syn/src/bigint.rs                      |   66 -
 vendor/syn/src/buffer.rs                      |  399 --
 vendor/syn/src/custom_keyword.rs              |  253 -
 vendor/syn/src/custom_punctuation.rs          |  300 -
 vendor/syn/src/data.rs                        |  501 --
 vendor/syn/src/derive.rs                      |  280 -
 vendor/syn/src/discouraged.rs                 |  194 -
 vendor/syn/src/error.rs                       |  412 --
 vendor/syn/src/export.rs                      |   37 -
 vendor/syn/src/expr.rs                        | 3497 ----------
 vendor/syn/src/ext.rs                         |  139 -
 vendor/syn/src/file.rs                        |  125 -
 vendor/syn/src/gen/clone.rs                   | 2234 -------
 vendor/syn/src/gen/debug.rs                   | 3035 ---------
 vendor/syn/src/gen/eq.rs                      | 2288 -------
 vendor/syn/src/gen/fold.rs                    | 3209 ----------
 vendor/syn/src/gen/hash.rs                    | 2867 ---------
 vendor/syn/src/gen/visit.rs                   | 3775 -----------
 vendor/syn/src/gen/visit_mut.rs               | 3781 -----------
 vendor/syn/src/gen_helper.rs                  |  154 -
 vendor/syn/src/generics.rs                    | 1290 ----
 vendor/syn/src/group.rs                       |  282 -
 vendor/syn/src/ident.rs                       |  102 -
 vendor/syn/src/item.rs                        | 3360 ----------
 vendor/syn/src/lib.rs                         | 1004 ---
 vendor/syn/src/lifetime.rs                    |  154 -
 vendor/syn/src/lit.rs                         | 1574 -----
 vendor/syn/src/lookahead.rs                   |  166 -
 vendor/syn/src/mac.rs                         |  219 -
 vendor/syn/src/macros.rs                      |  168 -
 vendor/syn/src/op.rs                          |  234 -
 vendor/syn/src/parse.rs                       | 1287 ----
 vendor/syn/src/parse_macro_input.rs           |  179 -
 vendor/syn/src/parse_quote.rs                 |  143 -
 vendor/syn/src/pat.rs                         |  932 ---
 vendor/syn/src/path.rs                        |  842 ---
 vendor/syn/src/print.rs                       |   16 -
 vendor/syn/src/punctuated.rs                  | 1040 ---
 vendor/syn/src/reserved.rs                    |   44 -
 vendor/syn/src/sealed.rs                      |    4 -
 vendor/syn/src/span.rs                        |   67 -
 vendor/syn/src/spanned.rs                     |  114 -
 vendor/syn/src/stmt.rs                        |  322 -
 vendor/syn/src/thread.rs                      |   41 -
 vendor/syn/src/token.rs                       | 1013 ---
 vendor/syn/src/tt.rs                          |  107 -
 vendor/syn/src/ty.rs                          | 1238 ----
 vendor/syn/src/verbatim.rs                    |   15 -
 vendor/syn/src/whitespace.rs                  |   65 -
 vendor/syn/tests/.gitignore                   |    1 -
 vendor/syn/tests/common/eq.rs                 |  630 --
 vendor/syn/tests/common/mod.rs                |   27 -
 vendor/syn/tests/common/parse.rs              |   48 -
 vendor/syn/tests/debug/gen.rs                 | 5645 -----------------
 vendor/syn/tests/debug/mod.rs                 |  118 -
 vendor/syn/tests/macros/mod.rs                |   75 -
 vendor/syn/tests/repo/mod.rs                  |  137 -
 vendor/syn/tests/repo/progress.rs             |   37 -
 vendor/syn/tests/test_asyncness.rs            |   37 -
 vendor/syn/tests/test_attribute.rs            |  336 -
 vendor/syn/tests/test_derive_input.rs         |  892 ---
 vendor/syn/tests/test_expr.rs                 |  320 -
 vendor/syn/tests/test_generics.rs             |  283 -
 vendor/syn/tests/test_grouping.rs             |   52 -
 vendor/syn/tests/test_ident.rs                |   85 -
 vendor/syn/tests/test_item.rs                 |  301 -
 vendor/syn/tests/test_iterators.rs            |   49 -
 vendor/syn/tests/test_lit.rs                  |  271 -
 vendor/syn/tests/test_meta.rs                 |  376 --
 vendor/syn/tests/test_parse_buffer.rs         |   90 -
 vendor/syn/tests/test_parse_stream.rs         |   12 -
 vendor/syn/tests/test_pat.rs                  |   67 -
 vendor/syn/tests/test_path.rs                 |  104 -
 vendor/syn/tests/test_precedence.rs           |  416 --
 vendor/syn/tests/test_receiver.rs             |  127 -
 vendor/syn/tests/test_round_trip.rs           |  200 -
 vendor/syn/tests/test_shebang.rs              |   59 -
 vendor/syn/tests/test_should_parse.rs         |   45 -
 vendor/syn/tests/test_size.rs                 |   29 -
 vendor/syn/tests/test_stmt.rs                 |   74 -
 vendor/syn/tests/test_token_trees.rs          |   30 -
 vendor/syn/tests/test_ty.rs                   |  287 -
 vendor/syn/tests/test_visibility.rs           |  148 -
 vendor/syn/tests/zzz_stable.rs                |   33 -
 .../target-tuples-0.4.1/.cargo-checksum.json  |    1 -
 vendor/target-tuples-0.4.1/Cargo.lock         |    6 -
 vendor/target-tuples-0.4.1/Cargo.toml         |   33 -
 vendor/target-tuples-0.4.1/LICENSE-APACHE     |    0
 vendor/target-tuples-0.4.1/LICENSE-MIT        |    6 -
 vendor/target-tuples-0.4.1/Makefile.in        |  133 -
 vendor/target-tuples-0.4.1/README.md          |   30 -
 vendor/target-tuples-0.4.1/aclocal.m4         |   15 -
 vendor/target-tuples-0.4.1/config.guess       | 1480 -----
 vendor/target-tuples-0.4.1/config.sub         | 1801 ------
 vendor/target-tuples-0.4.1/config.sub.1       |   17 -
 vendor/target-tuples-0.4.1/configure          | 4128 ------------
 vendor/target-tuples-0.4.1/configure.ac       |   17 -
 vendor/target-tuples-0.4.1/install-sh         |  541 --
 .../m4/lcrust_prog_rustc.m4                   |  220 -
 vendor/target-tuples-0.4.1/run-tests.sh       |    4 -
 vendor/target-tuples-0.4.1/src/config-sub.rs  |   32 -
 vendor/target-tuples-0.4.1/src/lib.rs         |  356 --
 vendor/target-tuples-0.4.1/src/pieces.rs      | 1011 ---
 .../target-tuples-0.4.1/tests/config-sub.data |    7 -
 vendor/target-tuples-0.4.1/tests/sub_tests.rs |   46 -
 vendor/target-tuples/.cargo-checksum.json     |    1 -
 vendor/target-tuples/Cargo.lock               |    7 -
 vendor/target-tuples/Cargo.toml               |   33 -
 vendor/target-tuples/LICENSE-APACHE           |    0
 vendor/target-tuples/LICENSE-MIT              |    6 -
 vendor/target-tuples/Makefile.in              |  133 -
 vendor/target-tuples/README.md                |   30 -
 vendor/target-tuples/aclocal.m4               |   15 -
 vendor/target-tuples/config.guess             | 1480 -----
 vendor/target-tuples/config.sub               | 1801 ------
 vendor/target-tuples/config.sub.1             |   17 -
 vendor/target-tuples/configure                | 4128 ------------
 vendor/target-tuples/configure.ac             |   17 -
 vendor/target-tuples/install-sh               |  541 --
 vendor/target-tuples/m4/lcrust_prog_rustc.m4  |  220 -
 vendor/target-tuples/run-tests.sh             |    4 -
 vendor/target-tuples/src/config-sub.rs        |   32 -
 vendor/target-tuples/src/lib.rs               |  364 --
 vendor/target-tuples/src/pieces.rs            | 1044 ---
 vendor/target-tuples/tests/config-sub.data    |    7 -
 vendor/target-tuples/tests/rustc-targets.data |  169 -
 vendor/target-tuples/tests/sub_tests.rs       |   63 -
 vendor/temp-file/.cargo-checksum.json         |    1 -
 vendor/temp-file/Cargo.toml                   |   27 -
 vendor/temp-file/LICENSE                      |   13 -
 vendor/temp-file/Readme.md                    |   98 -
 vendor/temp-file/src/lib.rs                   |  255 -
 vendor/temp-file/src/test.rs                  |  273 -
 vendor/toml/.cargo-checksum.json              |    1 -
 vendor/toml/Cargo.lock                        |  101 -
 vendor/toml/Cargo.toml                        |   40 -
 vendor/toml/LICENSE-APACHE                    |  201 -
 vendor/toml/LICENSE-MIT                       |   25 -
 vendor/toml/README.md                         |   38 -
 vendor/toml/examples/decode.rs                |   53 -
 vendor/toml/examples/enum_external.rs         |   44 -
 vendor/toml/examples/toml2json.rs             |   47 -
 vendor/toml/src/datetime.rs                   |  425 --
 vendor/toml/src/de.rs                         | 2263 -------
 vendor/toml/src/lib.rs                        |  180 -
 vendor/toml/src/macros.rs                     |  462 --
 vendor/toml/src/map.rs                        |  595 --
 vendor/toml/src/ser.rs                        | 1854 ------
 vendor/toml/src/spanned.rs                    |  168 -
 vendor/toml/src/tokens.rs                     |  744 ---
 vendor/toml/src/value.rs                      | 1080 ----
 .../toml/tests/enum_external_deserialize.rs   |  258 -
 vendor/unicode-xid/.cargo-checksum.json       |    1 -
 vendor/unicode-xid/COPYRIGHT                  |    7 -
 vendor/unicode-xid/Cargo.toml                 |   37 -
 vendor/unicode-xid/LICENSE-APACHE             |  201 -
 vendor/unicode-xid/LICENSE-MIT                |   25 -
 vendor/unicode-xid/README.md                  |   44 -
 vendor/unicode-xid/benches/xid.rs             |   60 -
 vendor/unicode-xid/src/lib.rs                 |   92 -
 vendor/unicode-xid/src/tables.rs              | 1419 -----
 vendor/unicode-xid/src/tests.rs               |   95 -
 vendor/unicode-xid/tests/exhaustive_tests.rs  |   25 -
 379 files changed, 140552 deletions(-)
 delete mode 100644 vendor/bitflags/.cargo-checksum.json
 delete mode 100644 vendor/bitflags/CHANGELOG.md
 delete mode 100644 vendor/bitflags/CODE_OF_CONDUCT.md
 delete mode 100644 vendor/bitflags/Cargo.toml
 delete mode 100644 vendor/bitflags/LICENSE-APACHE
 delete mode 100644 vendor/bitflags/LICENSE-MIT
 delete mode 100644 vendor/bitflags/README.md
 delete mode 100644 vendor/bitflags/src/example_generated.rs
 delete mode 100644 vendor/bitflags/src/lib.rs
 delete mode 100644 vendor/bitflags/tests/basic.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/impls/copy.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/impls/eq.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/private_field.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/private_flags.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/pub_const.rs
 delete mode 100644 vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta
 delete mode 100644 vendor/bitflags/tests/compile-pass/impls/convert.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/impls/default.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/redefinition/core.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/redefinition/stringify.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/repr/c.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/repr/transparent.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/visibility/bits_field.rs
 delete mode 100644 vendor/bitflags/tests/compile-pass/visibility/pub_in.rs
 delete mode 100644 vendor/bitflags/tests/compile.rs
 delete mode 100644 vendor/bytemuck/.cargo-checksum.json
 delete mode 100644 vendor/bytemuck/Cargo.toml
 delete mode 100644 vendor/bytemuck/LICENSE-APACHE
 delete mode 100644 vendor/bytemuck/LICENSE-MIT
 delete mode 100644 vendor/bytemuck/LICENSE-ZLIB
 delete mode 100644 vendor/bytemuck/README.md
 delete mode 100644 vendor/bytemuck/changelog.md
 delete mode 100644 vendor/bytemuck/rustfmt.toml
 delete mode 100644 vendor/bytemuck/src/allocation.rs
 delete mode 100644 vendor/bytemuck/src/contiguous.rs
 delete mode 100644 vendor/bytemuck/src/lib.rs
 delete mode 100644 vendor/bytemuck/src/offset_of.rs
 delete mode 100644 vendor/bytemuck/src/pod.rs
 delete mode 100644 vendor/bytemuck/src/transparent.rs
 delete mode 100644 vendor/bytemuck/src/zeroable.rs
 delete mode 100644 vendor/bytemuck/tests/array_tests.rs
 delete mode 100644 vendor/bytemuck/tests/cast_slice_tests.rs
 delete mode 100644 vendor/bytemuck/tests/derive.rs
 delete mode 100644 vendor/bytemuck/tests/doc_tests.rs
 delete mode 100644 vendor/bytemuck/tests/offset_of_tests.rs
 delete mode 100644 vendor/bytemuck/tests/std_tests.rs
 delete mode 100644 vendor/bytemuck/tests/transparent.rs
 delete mode 100644 vendor/bytemuck/tests/wrapper_forgets.rs
 delete mode 100644 vendor/bytemuck_derive/.cargo-checksum.json
 delete mode 100644 vendor/bytemuck_derive/Cargo.toml
 delete mode 100644 vendor/bytemuck_derive/LICENSE-APACHE
 delete mode 100644 vendor/bytemuck_derive/LICENSE-MIT
 delete mode 100644 vendor/bytemuck_derive/LICENSE-ZLIB
 delete mode 100644 vendor/bytemuck_derive/README.md
 delete mode 100644 vendor/bytemuck_derive/changelog.md
 delete mode 100644 vendor/bytemuck_derive/src/lib.rs
 delete mode 100644 vendor/bytemuck_derive/src/traits.rs
 delete mode 100644 vendor/bytemuck_derive/tests/basic.rs
 delete mode 100644 vendor/fake-enum/.cargo-checksum.json
 delete mode 100644 vendor/fake-enum/Cargo.toml
 delete mode 100644 vendor/fake-enum/LICENSE-APACHE
 delete mode 100644 vendor/fake-enum/LICENSE-MIT
 delete mode 100644 vendor/fake-enum/Makefile.in
 delete mode 100644 vendor/fake-enum/README.md
 delete mode 100644 vendor/fake-enum/aclocal.m4
 delete mode 100755 vendor/fake-enum/build-dirs.sh
 delete mode 100755 vendor/fake-enum/config.guess
 delete mode 100755 vendor/fake-enum/config.sub
 delete mode 100755 vendor/fake-enum/configure
 delete mode 100644 vendor/fake-enum/configure.ac
 delete mode 100755 vendor/fake-enum/install-sh
 delete mode 100644 vendor/fake-enum/m4/ax_prog_cc_for_build.m4
 delete mode 100644 vendor/fake-enum/m4/bindgen.m4
 delete mode 100644 vendor/fake-enum/m4/build_std.m4
 delete mode 100644 vendor/fake-enum/m4/lcrust_checks.m4
 delete mode 100644 vendor/fake-enum/m4/lcrust_prog_rustc.m4
 delete mode 100755 vendor/fake-enum/run-tests.sh
 delete mode 100644 vendor/fake-enum/src/lib.rs
 delete mode 100644 vendor/install-dirs/.cargo-checksum.json
 delete mode 100644 vendor/install-dirs/Cargo.toml
 delete mode 100644 vendor/install-dirs/README.md
 delete mode 100644 vendor/install-dirs/src/dirs.rs
 delete mode 100644 vendor/install-dirs/src/lib.rs
 delete mode 100644 vendor/lazy_static/.cargo-checksum.json
 delete mode 100644 vendor/lazy_static/Cargo.toml
 delete mode 100644 vendor/lazy_static/LICENSE-APACHE
 delete mode 100644 vendor/lazy_static/LICENSE-MIT
 delete mode 100644 vendor/lazy_static/README.md
 delete mode 100644 vendor/lazy_static/src/core_lazy.rs
 delete mode 100644 vendor/lazy_static/src/inline_lazy.rs
 delete mode 100644 vendor/lazy_static/src/lib.rs
 delete mode 100644 vendor/lazy_static/tests/no_std.rs
 delete mode 100644 vendor/lazy_static/tests/test.rs
 delete mode 100644 vendor/proc-macro2/.cargo-checksum.json
 delete mode 100644 vendor/proc-macro2/Cargo.toml
 delete mode 100644 vendor/proc-macro2/LICENSE-APACHE
 delete mode 100644 vendor/proc-macro2/LICENSE-MIT
 delete mode 100644 vendor/proc-macro2/README.md
 delete mode 100644 vendor/proc-macro2/build.rs
 delete mode 100644 vendor/proc-macro2/src/detection.rs
 delete mode 100644 vendor/proc-macro2/src/fallback.rs
 delete mode 100644 vendor/proc-macro2/src/lib.rs
 delete mode 100644 vendor/proc-macro2/src/marker.rs
 delete mode 100644 vendor/proc-macro2/src/parse.rs
 delete mode 100644 vendor/proc-macro2/src/wrapper.rs
 delete mode 100644 vendor/proc-macro2/tests/comments.rs
 delete mode 100644 vendor/proc-macro2/tests/features.rs
 delete mode 100644 vendor/proc-macro2/tests/marker.rs
 delete mode 100644 vendor/proc-macro2/tests/test.rs
 delete mode 100644 vendor/proc-macro2/tests/test_fmt.rs
 delete mode 100644 vendor/quote/.cargo-checksum.json
 delete mode 100644 vendor/quote/Cargo.toml
 delete mode 100644 vendor/quote/LICENSE-APACHE
 delete mode 100644 vendor/quote/LICENSE-MIT
 delete mode 100644 vendor/quote/README.md
 delete mode 100644 vendor/quote/src/ext.rs
 delete mode 100644 vendor/quote/src/format.rs
 delete mode 100644 vendor/quote/src/ident_fragment.rs
 delete mode 100644 vendor/quote/src/lib.rs
 delete mode 100644 vendor/quote/src/runtime.rs
 delete mode 100644 vendor/quote/src/spanned.rs
 delete mode 100644 vendor/quote/src/to_tokens.rs
 delete mode 100644 vendor/quote/tests/compiletest.rs
 delete mode 100644 vendor/quote/tests/test.rs
 delete mode 100644 vendor/quote/tests/ui/does-not-have-iter-interpolated-dup.rs
 delete mode 100644 vendor/quote/tests/ui/does-not-have-iter-interpolated.rs
 delete mode 100644 vendor/quote/tests/ui/does-not-have-iter-separated.rs
 delete mode 100644 vendor/quote/tests/ui/does-not-have-iter.rs
 delete mode 100644 vendor/quote/tests/ui/not-quotable.rs
 delete mode 100644 vendor/quote/tests/ui/not-repeatable.rs
 delete mode 100644 vendor/quote/tests/ui/wrong-type-span.rs
 delete mode 100644 vendor/serde/.cargo-checksum.json
 delete mode 100644 vendor/serde/Cargo.toml
 delete mode 100644 vendor/serde/LICENSE-APACHE
 delete mode 100644 vendor/serde/LICENSE-MIT
 delete mode 100644 vendor/serde/README.md
 delete mode 100644 vendor/serde/build.rs
 delete mode 100644 vendor/serde/crates-io.md
 delete mode 100644 vendor/serde/src/de/ignored_any.rs
 delete mode 100644 vendor/serde/src/de/impls.rs
 delete mode 100644 vendor/serde/src/de/mod.rs
 delete mode 100644 vendor/serde/src/de/seed.rs
 delete mode 100644 vendor/serde/src/de/utf8.rs
 delete mode 100644 vendor/serde/src/de/value.rs
 delete mode 100644 vendor/serde/src/integer128.rs
 delete mode 100644 vendor/serde/src/lib.rs
 delete mode 100644 vendor/serde/src/macros.rs
 delete mode 100644 vendor/serde/src/private/de.rs
 delete mode 100644 vendor/serde/src/private/doc.rs
 delete mode 100644 vendor/serde/src/private/mod.rs
 delete mode 100644 vendor/serde/src/private/ser.rs
 delete mode 100644 vendor/serde/src/private/size_hint.rs
 delete mode 100644 vendor/serde/src/ser/fmt.rs
 delete mode 100644 vendor/serde/src/ser/impls.rs
 delete mode 100644 vendor/serde/src/ser/impossible.rs
 delete mode 100644 vendor/serde/src/ser/mod.rs
 delete mode 100644 vendor/serde/src/std_error.rs
 delete mode 100644 vendor/serde_derive/.cargo-checksum.json
 delete mode 100644 vendor/serde_derive/Cargo.toml
 delete mode 100644 vendor/serde_derive/LICENSE-APACHE
 delete mode 100644 vendor/serde_derive/LICENSE-MIT
 delete mode 100644 vendor/serde_derive/README.md
 delete mode 100644 vendor/serde_derive/build.rs
 delete mode 100644 vendor/serde_derive/crates-io.md
 delete mode 100644 vendor/serde_derive/src/bound.rs
 delete mode 100644 vendor/serde_derive/src/de.rs
 delete mode 100644 vendor/serde_derive/src/dummy.rs
 delete mode 100644 vendor/serde_derive/src/fragment.rs
 delete mode 100644 vendor/serde_derive/src/internals/ast.rs
 delete mode 100644 vendor/serde_derive/src/internals/attr.rs
 delete mode 100644 vendor/serde_derive/src/internals/case.rs
 delete mode 100644 vendor/serde_derive/src/internals/check.rs
 delete mode 100644 vendor/serde_derive/src/internals/ctxt.rs
 delete mode 100644 vendor/serde_derive/src/internals/mod.rs
 delete mode 100644 vendor/serde_derive/src/internals/receiver.rs
 delete mode 100644 vendor/serde_derive/src/internals/respan.rs
 delete mode 100644 vendor/serde_derive/src/internals/symbol.rs
 delete mode 100644 vendor/serde_derive/src/lib.rs
 delete mode 100644 vendor/serde_derive/src/pretend.rs
 delete mode 100644 vendor/serde_derive/src/ser.rs
 delete mode 100644 vendor/serde_derive/src/try.rs
 delete mode 100644 vendor/static_assertions/.cargo-checksum.json
 delete mode 100644 vendor/static_assertions/CHANGELOG.md
 delete mode 100644 vendor/static_assertions/Cargo.toml
 delete mode 100644 vendor/static_assertions/LICENSE-APACHE
 delete mode 100644 vendor/static_assertions/LICENSE-MIT
 delete mode 100644 vendor/static_assertions/README.md
 delete mode 100644 vendor/static_assertions/src/assert_cfg.rs
 delete mode 100644 vendor/static_assertions/src/assert_eq_align.rs
 delete mode 100644 vendor/static_assertions/src/assert_eq_size.rs
 delete mode 100644 vendor/static_assertions/src/assert_fields.rs
 delete mode 100644 vendor/static_assertions/src/assert_impl.rs
 delete mode 100644 vendor/static_assertions/src/assert_obj_safe.rs
 delete mode 100644 vendor/static_assertions/src/assert_trait.rs
 delete mode 100644 vendor/static_assertions/src/assert_type.rs
 delete mode 100644 vendor/static_assertions/src/const_assert.rs
 delete mode 100644 vendor/static_assertions/src/lib.rs
 delete mode 100644 vendor/syn/.cargo-checksum.json
 delete mode 100644 vendor/syn/Cargo.toml
 delete mode 100644 vendor/syn/LICENSE-APACHE
 delete mode 100644 vendor/syn/LICENSE-MIT
 delete mode 100644 vendor/syn/README.md
 delete mode 100644 vendor/syn/benches/file.rs
 delete mode 100644 vendor/syn/benches/rust.rs
 delete mode 100644 vendor/syn/build.rs
 delete mode 100644 vendor/syn/src/attr.rs
 delete mode 100644 vendor/syn/src/await.rs
 delete mode 100644 vendor/syn/src/bigint.rs
 delete mode 100644 vendor/syn/src/buffer.rs
 delete mode 100644 vendor/syn/src/custom_keyword.rs
 delete mode 100644 vendor/syn/src/custom_punctuation.rs
 delete mode 100644 vendor/syn/src/data.rs
 delete mode 100644 vendor/syn/src/derive.rs
 delete mode 100644 vendor/syn/src/discouraged.rs
 delete mode 100644 vendor/syn/src/error.rs
 delete mode 100644 vendor/syn/src/export.rs
 delete mode 100644 vendor/syn/src/expr.rs
 delete mode 100644 vendor/syn/src/ext.rs
 delete mode 100644 vendor/syn/src/file.rs
 delete mode 100644 vendor/syn/src/gen/clone.rs
 delete mode 100644 vendor/syn/src/gen/debug.rs
 delete mode 100644 vendor/syn/src/gen/eq.rs
 delete mode 100644 vendor/syn/src/gen/fold.rs
 delete mode 100644 vendor/syn/src/gen/hash.rs
 delete mode 100644 vendor/syn/src/gen/visit.rs
 delete mode 100644 vendor/syn/src/gen/visit_mut.rs
 delete mode 100644 vendor/syn/src/gen_helper.rs
 delete mode 100644 vendor/syn/src/generics.rs
 delete mode 100644 vendor/syn/src/group.rs
 delete mode 100644 vendor/syn/src/ident.rs
 delete mode 100644 vendor/syn/src/item.rs
 delete mode 100644 vendor/syn/src/lib.rs
 delete mode 100644 vendor/syn/src/lifetime.rs
 delete mode 100644 vendor/syn/src/lit.rs
 delete mode 100644 vendor/syn/src/lookahead.rs
 delete mode 100644 vendor/syn/src/mac.rs
 delete mode 100644 vendor/syn/src/macros.rs
 delete mode 100644 vendor/syn/src/op.rs
 delete mode 100644 vendor/syn/src/parse.rs
 delete mode 100644 vendor/syn/src/parse_macro_input.rs
 delete mode 100644 vendor/syn/src/parse_quote.rs
 delete mode 100644 vendor/syn/src/pat.rs
 delete mode 100644 vendor/syn/src/path.rs
 delete mode 100644 vendor/syn/src/print.rs
 delete mode 100644 vendor/syn/src/punctuated.rs
 delete mode 100644 vendor/syn/src/reserved.rs
 delete mode 100644 vendor/syn/src/sealed.rs
 delete mode 100644 vendor/syn/src/span.rs
 delete mode 100644 vendor/syn/src/spanned.rs
 delete mode 100644 vendor/syn/src/stmt.rs
 delete mode 100644 vendor/syn/src/thread.rs
 delete mode 100644 vendor/syn/src/token.rs
 delete mode 100644 vendor/syn/src/tt.rs
 delete mode 100644 vendor/syn/src/ty.rs
 delete mode 100644 vendor/syn/src/verbatim.rs
 delete mode 100644 vendor/syn/src/whitespace.rs
 delete mode 100644 vendor/syn/tests/.gitignore
 delete mode 100644 vendor/syn/tests/common/eq.rs
 delete mode 100644 vendor/syn/tests/common/mod.rs
 delete mode 100644 vendor/syn/tests/common/parse.rs
 delete mode 100644 vendor/syn/tests/debug/gen.rs
 delete mode 100644 vendor/syn/tests/debug/mod.rs
 delete mode 100644 vendor/syn/tests/macros/mod.rs
 delete mode 100644 vendor/syn/tests/repo/mod.rs
 delete mode 100644 vendor/syn/tests/repo/progress.rs
 delete mode 100644 vendor/syn/tests/test_asyncness.rs
 delete mode 100644 vendor/syn/tests/test_attribute.rs
 delete mode 100644 vendor/syn/tests/test_derive_input.rs
 delete mode 100644 vendor/syn/tests/test_expr.rs
 delete mode 100644 vendor/syn/tests/test_generics.rs
 delete mode 100644 vendor/syn/tests/test_grouping.rs
 delete mode 100644 vendor/syn/tests/test_ident.rs
 delete mode 100644 vendor/syn/tests/test_item.rs
 delete mode 100644 vendor/syn/tests/test_iterators.rs
 delete mode 100644 vendor/syn/tests/test_lit.rs
 delete mode 100644 vendor/syn/tests/test_meta.rs
 delete mode 100644 vendor/syn/tests/test_parse_buffer.rs
 delete mode 100644 vendor/syn/tests/test_parse_stream.rs
 delete mode 100644 vendor/syn/tests/test_pat.rs
 delete mode 100644 vendor/syn/tests/test_path.rs
 delete mode 100644 vendor/syn/tests/test_precedence.rs
 delete mode 100644 vendor/syn/tests/test_receiver.rs
 delete mode 100644 vendor/syn/tests/test_round_trip.rs
 delete mode 100644 vendor/syn/tests/test_shebang.rs
 delete mode 100644 vendor/syn/tests/test_should_parse.rs
 delete mode 100644 vendor/syn/tests/test_size.rs
 delete mode 100644 vendor/syn/tests/test_stmt.rs
 delete mode 100644 vendor/syn/tests/test_token_trees.rs
 delete mode 100644 vendor/syn/tests/test_ty.rs
 delete mode 100644 vendor/syn/tests/test_visibility.rs
 delete mode 100644 vendor/syn/tests/zzz_stable.rs
 delete mode 100644 vendor/target-tuples-0.4.1/.cargo-checksum.json
 delete mode 100644 vendor/target-tuples-0.4.1/Cargo.lock
 delete mode 100644 vendor/target-tuples-0.4.1/Cargo.toml
 delete mode 100644 vendor/target-tuples-0.4.1/LICENSE-APACHE
 delete mode 100644 vendor/target-tuples-0.4.1/LICENSE-MIT
 delete mode 100644 vendor/target-tuples-0.4.1/Makefile.in
 delete mode 100644 vendor/target-tuples-0.4.1/README.md
 delete mode 100644 vendor/target-tuples-0.4.1/aclocal.m4
 delete mode 100755 vendor/target-tuples-0.4.1/config.guess
 delete mode 100755 vendor/target-tuples-0.4.1/config.sub
 delete mode 100644 vendor/target-tuples-0.4.1/config.sub.1
 delete mode 100755 vendor/target-tuples-0.4.1/configure
 delete mode 100644 vendor/target-tuples-0.4.1/configure.ac
 delete mode 100755 vendor/target-tuples-0.4.1/install-sh
 delete mode 100644 vendor/target-tuples-0.4.1/m4/lcrust_prog_rustc.m4
 delete mode 100755 vendor/target-tuples-0.4.1/run-tests.sh
 delete mode 100644 vendor/target-tuples-0.4.1/src/config-sub.rs
 delete mode 100644 vendor/target-tuples-0.4.1/src/lib.rs
 delete mode 100644 vendor/target-tuples-0.4.1/src/pieces.rs
 delete mode 100644 vendor/target-tuples-0.4.1/tests/config-sub.data
 delete mode 100644 vendor/target-tuples-0.4.1/tests/sub_tests.rs
 delete mode 100644 vendor/target-tuples/.cargo-checksum.json
 delete mode 100644 vendor/target-tuples/Cargo.lock
 delete mode 100644 vendor/target-tuples/Cargo.toml
 delete mode 100644 vendor/target-tuples/LICENSE-APACHE
 delete mode 100644 vendor/target-tuples/LICENSE-MIT
 delete mode 100644 vendor/target-tuples/Makefile.in
 delete mode 100644 vendor/target-tuples/README.md
 delete mode 100644 vendor/target-tuples/aclocal.m4
 delete mode 100755 vendor/target-tuples/config.guess
 delete mode 100755 vendor/target-tuples/config.sub
 delete mode 100644 vendor/target-tuples/config.sub.1
 delete mode 100755 vendor/target-tuples/configure
 delete mode 100644 vendor/target-tuples/configure.ac
 delete mode 100755 vendor/target-tuples/install-sh
 delete mode 100644 vendor/target-tuples/m4/lcrust_prog_rustc.m4
 delete mode 100755 vendor/target-tuples/run-tests.sh
 delete mode 100644 vendor/target-tuples/src/config-sub.rs
 delete mode 100644 vendor/target-tuples/src/lib.rs
 delete mode 100644 vendor/target-tuples/src/pieces.rs
 delete mode 100644 vendor/target-tuples/tests/config-sub.data
 delete mode 100644 vendor/target-tuples/tests/rustc-targets.data
 delete mode 100644 vendor/target-tuples/tests/sub_tests.rs
 delete mode 100644 vendor/temp-file/.cargo-checksum.json
 delete mode 100644 vendor/temp-file/Cargo.toml
 delete mode 100644 vendor/temp-file/LICENSE
 delete mode 100644 vendor/temp-file/Readme.md
 delete mode 100644 vendor/temp-file/src/lib.rs
 delete mode 100644 vendor/temp-file/src/test.rs
 delete mode 100644 vendor/toml/.cargo-checksum.json
 delete mode 100644 vendor/toml/Cargo.lock
 delete mode 100644 vendor/toml/Cargo.toml
 delete mode 100644 vendor/toml/LICENSE-APACHE
 delete mode 100644 vendor/toml/LICENSE-MIT
 delete mode 100644 vendor/toml/README.md
 delete mode 100644 vendor/toml/examples/decode.rs
 delete mode 100644 vendor/toml/examples/enum_external.rs
 delete mode 100644 vendor/toml/examples/toml2json.rs
 delete mode 100644 vendor/toml/src/datetime.rs
 delete mode 100644 vendor/toml/src/de.rs
 delete mode 100644 vendor/toml/src/lib.rs
 delete mode 100644 vendor/toml/src/macros.rs
 delete mode 100644 vendor/toml/src/map.rs
 delete mode 100644 vendor/toml/src/ser.rs
 delete mode 100644 vendor/toml/src/spanned.rs
 delete mode 100644 vendor/toml/src/tokens.rs
 delete mode 100644 vendor/toml/src/value.rs
 delete mode 100644 vendor/toml/tests/enum_external_deserialize.rs
 delete mode 100644 vendor/unicode-xid/.cargo-checksum.json
 delete mode 100644 vendor/unicode-xid/COPYRIGHT
 delete mode 100644 vendor/unicode-xid/Cargo.toml
 delete mode 100644 vendor/unicode-xid/LICENSE-APACHE
 delete mode 100644 vendor/unicode-xid/LICENSE-MIT
 delete mode 100644 vendor/unicode-xid/README.md
 delete mode 100644 vendor/unicode-xid/benches/xid.rs
 delete mode 100644 vendor/unicode-xid/src/lib.rs
 delete mode 100644 vendor/unicode-xid/src/tables.rs
 delete mode 100644 vendor/unicode-xid/src/tests.rs
 delete mode 100644 vendor/unicode-xid/tests/exhaustive_tests.rs

diff --git a/vendor/bitflags/.cargo-checksum.json b/vendor/bitflags/.cargo-checksum.json
deleted file mode 100644
index 7e8d470b..00000000
--- a/vendor/bitflags/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"CHANGELOG.md":"d362fc1fccaaf4d421bcf0fe8b80ddb4f625dade0c1ee52d08bd0b95509a49d1","CODE_OF_CONDUCT.md":"42634d0f6d922f49857175af991802822f7f920487aefa2ee250a50d12251a66","Cargo.toml":"87aced7532a7974eb37ab5fe6037f0abafc36d6b2d74891ecd2bf2f14f50d11e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"baa8604f8afb34fd93b9c79729daafb884dedcaf34023e4af8ad037d916061fd","src/example_generated.rs":"e43eb59e90f317f38d436670a6067d2fd9eb35fb319fe716184e4a04e24ed1b2","src/lib.rs":"e6477688535ee326d27238aeedc9cb4320ac35b9d17a4deda09e0587b0ccdbd4","tests/basic.rs":"146f1cbf6279bc609242cd3349f29cb21b41294f5e4921875f5ec95bd83529a2","tests/compile-fail/impls/copy.rs":"b791371237ddc75a7c04d2130e03b462c9c00a80dca08bd45aa97433d9c0d13a","tests/compile-fail/impls/copy.stderr.beta":"77d83484ce221d4b6ff2f7de843929a452d779fcfff428122710dd8218c298e3","tests/compile-fail/impls/eq.rs":"0cee8b9e07d537890e0189710293b53972d0fab63c09366f33c391065afafa99","tests/compile-fail/impls/eq.stderr.beta":"381fc6143d45ce76d7cecc47aa59cb69fe5e79c0b60a4a85d5c6163b400b3cc7","tests/compile-fail/non_integer_base/all_defined.rs":"95e14cad9e94560262f2862c3c01865ac30369b69da1001b0e7285cb55e6cb75","tests/compile-fail/non_integer_base/all_defined.stderr.beta":"1760739a276690903bb03844025587d37939f5dfcbfab309db3c86f32bdbf748","tests/compile-fail/non_integer_base/all_missing.rs":"b3d9da619d23213731ba2581aa7999c796c3c79aaf4f0ee6b11ceec08a11537f","tests/compile-fail/non_integer_base/all_missing.stderr.beta":"37e102290d3867e175b21976be798939f294efb17580d5b51e7b17b590d55132","tests/compile-fail/visibility/private_field.rs":"38e4d3fe6471829360d12c8d09b097f6a21aa93fb51eac3b215d96bdae23316b","tests/compile-fail/visibility/private_field.stderr.beta":"5aa24a3ebb39326f31927721c5017b8beb66c3e501fb865a3fa814c9763bfa0f","tests/compile-fail/visibility/private_flags.rs":"2ce4235802aa4e9c96c4e77d9e31d8401ef58dcda4741325184f0764ab1fe393","tests/compile-fail/visibility/private_flags.stderr.beta":"f3eb9f7baf2689258f3519ff7ee5c6ec3c237264ebcfe63f40c40f2023e5022f","tests/compile-fail/visibility/pub_const.rs":"8f813a97ac518c5ea8ac65b184101912452384afaf7b8d6c5e62f8370eca3c0a","tests/compile-fail/visibility/pub_const.stderr.beta":"823976ae1794d7f5372e2ec9aabba497e7bb88004722904c38da342ed98e8962","tests/compile-pass/impls/convert.rs":"88fe80bfb9cd5779f0e1d92c9ec02a8b6bb67e334c07f2309e9c0ba5ef776eb0","tests/compile-pass/impls/default.rs":"c508f9a461691f44b45142fa5ad599f02326e1de4c0cbca6c0593f4652eba109","tests/compile-pass/impls/inherent_methods.rs":"ecc26388e9a394bfa7a5bb69a5d621ab3d4d1e53f28f657bb8e78fe79f437913","tests/compile-pass/redefinition/core.rs":"ff5b6e72f87acc6ebb12405d3c0f6e3fa62e669933656a454bb63b30ea44179c","tests/compile-pass/redefinition/stringify.rs":"1edbce42b900c14425d7ffa14e83e165ebe452d7dccd8c0a8a821bdec64f5c93","tests/compile-pass/repr/c.rs":"6fda17f7c2edfcd155314579e83d0fc8a16209e400f1f9a5ca77bd9a799041f2","tests/compile-pass/repr/transparent.rs":"6cdc87a2137d8a4e0c8ce9b6cba83c82255f8ea125951bf614418685600489ce","tests/compile-pass/visibility/bits_field.rs":"1f3e5ba5a047440066a9f6bf7b7af33f5b06f6b1da3dd9af6886168199a7ea0a","tests/compile-pass/visibility/pub_in.rs":"e95312ff60966d42ec4bc00225507895a9b8ec24056ce6a9edd9145be35d730f","tests/compile.rs":"f27c67a7dd183ca30efea1b6e0880e3469a6dd63b92b1fd711c082df182c9eec"},"package":"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"}
\ No newline at end of file
diff --git a/vendor/bitflags/CHANGELOG.md b/vendor/bitflags/CHANGELOG.md
deleted file mode 100644
index 12fea167..00000000
--- a/vendor/bitflags/CHANGELOG.md
+++ /dev/null
@@ -1,206 +0,0 @@
-# 1.3.2
-
-- Allow `non_snake_case` in generated flags types ([#256])
-
-[#252]: https://github.com/bitflags/bitflags/pull/256
-
-# 1.3.1
-
-- Revert unconditional `#[repr(transparent)]` ([#252])
-
-[#252]: https://github.com/bitflags/bitflags/pull/252
-
-# 1.3.0 (yanked)
-
-- Add `#[repr(transparent)]` ([#187])
-
-- End `empty` doc comment with full stop ([#202])
-
-- Fix typo in crate root docs ([#206])
-
-- Document from_bits_unchecked unsafety ([#207])
-
-- Let `is_all` ignore extra bits ([#211])
-
-- Allows empty flag definition ([#225])
-
-- Making crate accessible from std ([#227])
-
-- Make `from_bits` a const fn ([#229])
-
-- Allow multiple bitflags structs in one macro invocation ([#235])
-
-- Add named functions to perform set operations ([#244])
-
-- Fix typos in method docs ([#245])
-
-- Modernization of the `bitflags` macro to take advantage of newer features and 2018 idioms ([#246])
-
-- Fix regression (in an unreleased feature) and simplify tests ([#247])
-
-- Use `Self` and fix bug when overriding `stringify!` ([#249])
-
-[#187]: https://github.com/bitflags/bitflags/pull/187
-[#202]: https://github.com/bitflags/bitflags/pull/202
-[#206]: https://github.com/bitflags/bitflags/pull/206
-[#207]: https://github.com/bitflags/bitflags/pull/207
-[#211]: https://github.com/bitflags/bitflags/pull/211
-[#225]: https://github.com/bitflags/bitflags/pull/225
-[#227]: https://github.com/bitflags/bitflags/pull/227
-[#229]: https://github.com/bitflags/bitflags/pull/229
-[#235]: https://github.com/bitflags/bitflags/pull/235
-[#244]: https://github.com/bitflags/bitflags/pull/244
-[#245]: https://github.com/bitflags/bitflags/pull/245
-[#246]: https://github.com/bitflags/bitflags/pull/246
-[#247]: https://github.com/bitflags/bitflags/pull/247
-[#249]: https://github.com/bitflags/bitflags/pull/249
-
-# 1.2.1
-
-- Remove extraneous `#[inline]` attributes ([#194])
-
-[#194]: https://github.com/bitflags/bitflags/pull/194
-
-# 1.2.0
-
-- Fix typo: {Lower, Upper}Exp - {Lower, Upper}Hex ([#183])
-
-- Add support for "unknown" bits ([#188])
-
-[#183]: https://github.com/rust-lang-nursery/bitflags/pull/183
-[#188]: https://github.com/rust-lang-nursery/bitflags/pull/188
-
-# 1.1.0
-
-This is a re-release of `1.0.5`, which was yanked due to a bug in the RLS.
-
-# 1.0.5
-
-- Use compiletest_rs flags supported by stable toolchain ([#171])
-
-- Put the user provided attributes first ([#173])
-
-- Make bitflags methods `const` on newer compilers ([#175])
-
-[#171]: https://github.com/rust-lang-nursery/bitflags/pull/171
-[#173]: https://github.com/rust-lang-nursery/bitflags/pull/173
-[#175]: https://github.com/rust-lang-nursery/bitflags/pull/175
-
-# 1.0.4
-
-- Support Rust 2018 style macro imports ([#165])
-
-  ```rust
-  use bitflags::bitflags;
-  ```
-
-[#165]: https://github.com/rust-lang-nursery/bitflags/pull/165
-
-# 1.0.3
-
-- Improve zero value flag handling and documentation ([#157])
-
-[#157]: https://github.com/rust-lang-nursery/bitflags/pull/157
-
-# 1.0.2
-
-- 30% improvement in compile time of bitflags crate ([#156])
-
-- Documentation improvements ([#153])
-
-- Implementation cleanup ([#149])
-
-[#156]: https://github.com/rust-lang-nursery/bitflags/pull/156
-[#153]: https://github.com/rust-lang-nursery/bitflags/pull/153
-[#149]: https://github.com/rust-lang-nursery/bitflags/pull/149
-
-# 1.0.1
-- Add support for `pub(restricted)` specifier on the bitflags struct ([#135])
-- Optimize performance of `all()` when called from a separate crate ([#136])
-
-[#135]: https://github.com/rust-lang-nursery/bitflags/pull/135
-[#136]: https://github.com/rust-lang-nursery/bitflags/pull/136
-
-# 1.0.0
-- **[breaking change]** Macro now generates [associated constants](https://doc.rust-lang.org/reference/items.html#associated-constants) ([#24])
-
-- **[breaking change]** Minimum supported version is Rust **1.20**, due to usage of associated constants
-
-- After being broken in 0.9, the `#[deprecated]` attribute is now supported again ([#112])
-
-- Other improvements to unit tests and documentation ([#106] and [#115])
-
-[#24]: https://github.com/rust-lang-nursery/bitflags/pull/24
-[#106]: https://github.com/rust-lang-nursery/bitflags/pull/106
-[#112]: https://github.com/rust-lang-nursery/bitflags/pull/112
-[#115]: https://github.com/rust-lang-nursery/bitflags/pull/115
-
-## How to update your code to use associated constants
-Assuming the following structure definition:
-```rust
-bitflags! {
-  struct Something: u8 {
-     const FOO = 0b01,
-     const BAR = 0b10
-  }
-}
-```
-In 0.9 and older you could do:
-```rust
-let x = FOO.bits | BAR.bits;
-```
-Now you must use:
-```rust
-let x = Something::FOO.bits | Something::BAR.bits;
-```
-
-# 0.9.1
-- Fix the implementation of `Formatting` traits when other formatting traits were present in scope ([#105])
-
-[#105]: https://github.com/rust-lang-nursery/bitflags/pull/105
-
-# 0.9.0
-- **[breaking change]** Use struct keyword instead of flags to define bitflag types ([#84])
-
-- **[breaking change]** Terminate const items with semicolons instead of commas ([#87])
-
-- Implement the `Hex`, `Octal`, and `Binary` formatting traits ([#86])
-
-- Printing an empty flag value with the `Debug` trait now prints "(empty)" instead of nothing ([#85])
-
-- The `bitflags!` macro can now be used inside of a fn body, to define a type local to that function ([#74])
-
-[#74]: https://github.com/rust-lang-nursery/bitflags/pull/74
-[#84]: https://github.com/rust-lang-nursery/bitflags/pull/84
-[#85]: https://github.com/rust-lang-nursery/bitflags/pull/85
-[#86]: https://github.com/rust-lang-nursery/bitflags/pull/86
-[#87]: https://github.com/rust-lang-nursery/bitflags/pull/87
-
-# 0.8.2
-- Update feature flag used when building bitflags as a dependency of the Rust toolchain
-
-# 0.8.1
-- Allow bitflags to be used as a dependency of the Rust toolchain
-
-# 0.8.0
-- Add support for the experimental `i128` and `u128` integer types ([#57])
-- Add set method: `flags.set(SOME_FLAG, true)` or `flags.set(SOME_FLAG, false)` ([#55])
-  This may break code that defines its own set method
-
-[#55]: https://github.com/rust-lang-nursery/bitflags/pull/55
-[#57]: https://github.com/rust-lang-nursery/bitflags/pull/57
-
-# 0.7.1
-*(yanked)*
-
-# 0.7.0
-- Implement the Extend trait ([#49])
-- Allow definitions inside the `bitflags!` macro to refer to items imported from other modules ([#51])
-
-[#49]: https://github.com/rust-lang-nursery/bitflags/pull/49
-[#51]: https://github.com/rust-lang-nursery/bitflags/pull/51
-
-# 0.6.0
-- The `no_std` feature was removed as it is now the default
-- The `assignment_operators` feature was remove as it is now enabled by default
-- Some clippy suggestions have been applied
diff --git a/vendor/bitflags/CODE_OF_CONDUCT.md b/vendor/bitflags/CODE_OF_CONDUCT.md
deleted file mode 100644
index f7add90a..00000000
--- a/vendor/bitflags/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-education, socio-economic status, nationality, personal appearance, race,
-religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at coc@senaite.org. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
\ No newline at end of file
diff --git a/vendor/bitflags/Cargo.toml b/vendor/bitflags/Cargo.toml
deleted file mode 100644
index 9d54c725..00000000
--- a/vendor/bitflags/Cargo.toml
+++ /dev/null
@@ -1,58 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "bitflags"
-version = "1.3.2"
-authors = ["The Rust Project Developers"]
-exclude = ["bors.toml"]
-description = "A macro to generate structures which behave like bitflags.\n"
-homepage = "https://github.com/bitflags/bitflags"
-documentation = "https://docs.rs/bitflags"
-readme = "README.md"
-keywords = ["bit", "bitmask", "bitflags", "flags"]
-categories = ["no-std"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/bitflags/bitflags"
-[package.metadata.docs.rs]
-features = ["example_generated"]
-[dependencies.compiler_builtins]
-version = "0.1.2"
-optional = true
-
-[dependencies.core]
-version = "1.0.0"
-optional = true
-package = "rustc-std-workspace-core"
-[dev-dependencies.rustversion]
-version = "1.0"
-
-[dev-dependencies.serde]
-version = "1.0"
-
-[dev-dependencies.serde_derive]
-version = "1.0"
-
-[dev-dependencies.serde_json]
-version = "1.0"
-
-[dev-dependencies.trybuild]
-version = "1.0"
-
-[dev-dependencies.walkdir]
-version = "2.3"
-
-[features]
-default = []
-example_generated = []
-rustc-dep-of-std = ["core", "compiler_builtins"]
diff --git a/vendor/bitflags/LICENSE-APACHE b/vendor/bitflags/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/bitflags/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/bitflags/LICENSE-MIT b/vendor/bitflags/LICENSE-MIT
deleted file mode 100644
index 39d4bdb5..00000000
--- a/vendor/bitflags/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/bitflags/README.md b/vendor/bitflags/README.md
deleted file mode 100644
index 0da0f853..00000000
--- a/vendor/bitflags/README.md
+++ /dev/null
@@ -1,32 +0,0 @@
-bitflags
-========
-
-[![Rust](https://github.com/bitflags/bitflags/workflows/Rust/badge.svg)](https://github.com/bitflags/bitflags/actions)
-[![Join the chat at https://gitter.im/bitflags/Lobby](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/bitflags/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)
-[![Latest version](https://img.shields.io/crates/v/bitflags.svg)](https://crates.io/crates/bitflags)
-[![Documentation](https://docs.rs/bitflags/badge.svg)](https://docs.rs/bitflags)
-![License](https://img.shields.io/crates/l/bitflags.svg)
-
-A Rust macro to generate structures which behave like a set of bitflags
-
-- [Documentation](https://docs.rs/bitflags)
-- [Release notes](https://github.com/bitflags/bitflags/releases)
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-bitflags = "1.3"
-```
-
-and this to your source code:
-
-```rust
-use bitflags::bitflags;
-```
-
-## Rust Version Support
-
-The minimum supported Rust version is 1.46 due to use of associated constants and const functions.
diff --git a/vendor/bitflags/src/example_generated.rs b/vendor/bitflags/src/example_generated.rs
deleted file mode 100644
index cf188d99..00000000
--- a/vendor/bitflags/src/example_generated.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! This module shows an example of code generated by the macro. **IT MUST NOT BE USED OUTSIDE THIS
-//! CRATE**.
-
-bitflags! {
-    /// This is the same `Flags` struct defined in the [crate level example](../index.html#example).
-    /// Note that this struct is just for documentation purposes only, it must not be used outside
-    /// this crate.
-    pub struct Flags: u32 {
-        const A = 0b00000001;
-        const B = 0b00000010;
-        const C = 0b00000100;
-        const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-    }
-}
diff --git a/vendor/bitflags/src/lib.rs b/vendor/bitflags/src/lib.rs
deleted file mode 100644
index 935e432f..00000000
--- a/vendor/bitflags/src/lib.rs
+++ /dev/null
@@ -1,1729 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A typesafe bitmask flag generator useful for sets of C-style bitmask flags.
-//! It can be used for creating typesafe wrappers around C APIs.
-//!
-//! The `bitflags!` macro generates `struct`s that manage a set of flags. The
-//! flags should only be defined for integer types, otherwise unexpected type
-//! errors may occur at compile time.
-//!
-//! # Example
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     struct Flags: u32 {
-//!         const A = 0b00000001;
-//!         const B = 0b00000010;
-//!         const C = 0b00000100;
-//!         const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let e1 = Flags::A | Flags::C;
-//!     let e2 = Flags::B | Flags::C;
-//!     assert_eq!((e1 | e2), Flags::ABC);   // union
-//!     assert_eq!((e1 & e2), Flags::C);     // intersection
-//!     assert_eq!((e1 - e2), Flags::A);     // set difference
-//!     assert_eq!(!e2, Flags::A);           // set complement
-//! }
-//! ```
-//!
-//! See [`example_generated::Flags`](./example_generated/struct.Flags.html) for documentation of code
-//! generated by the above `bitflags!` expansion.
-//!
-//! The generated `struct`s can also be extended with type and trait
-//! implementations:
-//!
-//! ```
-//! use std::fmt;
-//!
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     struct Flags: u32 {
-//!         const A = 0b00000001;
-//!         const B = 0b00000010;
-//!     }
-//! }
-//!
-//! impl Flags {
-//!     pub fn clear(&mut self) {
-//!         self.bits = 0;  // The `bits` field can be accessed from within the
-//!                         // same module where the `bitflags!` macro was invoked.
-//!     }
-//! }
-//!
-//! impl fmt::Display for Flags {
-//!     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//!         write!(f, "hi!")
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let mut flags = Flags::A | Flags::B;
-//!     flags.clear();
-//!     assert!(flags.is_empty());
-//!     assert_eq!(format!("{}", flags), "hi!");
-//!     assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
-//!     assert_eq!(format!("{:?}", Flags::B), "B");
-//! }
-//! ```
-//!
-//! # Visibility
-//!
-//! The generated structs and their associated flag constants are not exported
-//! out of the current module by default. A definition can be exported out of
-//! the current module by adding `pub` before `struct`:
-//!
-//! ```
-//! mod example {
-//!     use bitflags::bitflags;
-//!
-//!     bitflags! {
-//!         pub struct Flags1: u32 {
-//!             const A = 0b00000001;
-//!         }
-//!
-//! #       pub
-//!         struct Flags2: u32 {
-//!             const B = 0b00000010;
-//!         }
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let flag1 = example::Flags1::A;
-//!     let flag2 = example::Flags2::B; // error: const `B` is private
-//! }
-//! ```
-//!
-//! # Attributes
-//!
-//! Attributes can be attached to the generated `struct`s by placing them
-//! before the `struct` keyword.
-//!
-//! ## Representations
-//!
-//! It's valid to add a `#[repr(C)]` or `#[repr(transparent)]` attribute to a type
-//! generated by `bitflags!`. In these cases, the type is guaranteed to be a newtype.
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     #[repr(transparent)]
-//!     struct Flags: u32 {
-//!         const A = 0b00000001;
-//!         const B = 0b00000010;
-//!         const C = 0b00000100;
-//!     }
-//! }
-//! ```
-//!
-//! # Trait implementations
-//!
-//! The `Copy`, `Clone`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash`
-//! traits are automatically derived for the `struct`s using the `derive` attribute.
-//! Additional traits can be derived by providing an explicit `derive`
-//! attribute on `struct`.
-//!
-//! The `Extend` and `FromIterator` traits are implemented for the `struct`s,
-//! too: `Extend` adds the union of the instances of the `struct` iterated over,
-//! while `FromIterator` calculates the union.
-//!
-//! The `Binary`, `Debug`, `LowerHex`, `Octal` and `UpperHex` traits are also
-//! implemented by displaying the bits value of the internal struct.
-//!
-//! ## Operators
-//!
-//! The following operator traits are implemented for the generated `struct`s:
-//!
-//! - `BitOr` and `BitOrAssign`: union
-//! - `BitAnd` and `BitAndAssign`: intersection
-//! - `BitXor` and `BitXorAssign`: toggle
-//! - `Sub` and `SubAssign`: set difference
-//! - `Not`: set complement
-//!
-//! # Methods
-//!
-//! The following methods are defined for the generated `struct`s:
-//!
-//! - `empty`: an empty set of flags
-//! - `all`: the set of all defined flags
-//! - `bits`: the raw value of the flags currently stored
-//! - `from_bits`: convert from underlying bit representation, unless that
-//!                representation contains bits that do not correspond to a
-//!                defined flag
-//! - `from_bits_truncate`: convert from underlying bit representation, dropping
-//!                         any bits that do not correspond to defined flags
-//! - `from_bits_unchecked`: convert from underlying bit representation, keeping
-//!                          all bits (even those not corresponding to defined
-//!                          flags)
-//! - `is_empty`: `true` if no flags are currently stored
-//! - `is_all`: `true` if currently set flags exactly equal all defined flags
-//! - `intersects`: `true` if there are flags common to both `self` and `other`
-//! - `contains`: `true` if all of the flags in `other` are contained within `self`
-//! - `insert`: inserts the specified flags in-place
-//! - `remove`: removes the specified flags in-place
-//! - `toggle`: the specified flags will be inserted if not present, and removed
-//!             if they are.
-//! - `set`: inserts or removes the specified flags depending on the passed value
-//! - `intersection`: returns a new set of flags, containing only the flags present
-//!                   in both `self` and `other` (the argument to the function).
-//! - `union`: returns a new set of flags, containing any flags present in
-//!            either `self` or `other` (the argument to the function).
-//! - `difference`: returns a new set of flags, containing all flags present in
-//!                 `self` without any of the flags present in `other` (the
-//!                 argument to the function).
-//! - `symmetric_difference`: returns a new set of flags, containing all flags
-//!                           present in either `self` or `other` (the argument
-//!                           to the function), but not both.
-//! - `complement`: returns a new set of flags, containing all flags which are
-//!                 not set in `self`, but which are allowed for this type.
-//!
-//! ## Default
-//!
-//! The `Default` trait is not automatically implemented for the generated structs.
-//!
-//! If your default value is equal to `0` (which is the same value as calling `empty()`
-//! on the generated struct), you can simply derive `Default`:
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     // Results in default value with bits: 0
-//!     #[derive(Default)]
-//!     struct Flags: u32 {
-//!         const A = 0b00000001;
-//!         const B = 0b00000010;
-//!         const C = 0b00000100;
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let derived_default: Flags = Default::default();
-//!     assert_eq!(derived_default.bits(), 0);
-//! }
-//! ```
-//!
-//! If your default value is not equal to `0` you need to implement `Default` yourself:
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     struct Flags: u32 {
-//!         const A = 0b00000001;
-//!         const B = 0b00000010;
-//!         const C = 0b00000100;
-//!     }
-//! }
-//!
-//! // explicit `Default` implementation
-//! impl Default for Flags {
-//!     fn default() -> Flags {
-//!         Flags::A | Flags::C
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let implemented_default: Flags = Default::default();
-//!     assert_eq!(implemented_default, (Flags::A | Flags::C));
-//! }
-//! ```
-//!
-//! # Zero Flags
-//!
-//! Flags with a value equal to zero will have some strange behavior that one should be aware of.
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//!     struct Flags: u32 {
-//!         const NONE = 0b00000000;
-//!         const SOME = 0b00000001;
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let empty = Flags::empty();
-//!     let none = Flags::NONE;
-//!     let some = Flags::SOME;
-//!
-//!     // Zero flags are treated as always present
-//!     assert!(empty.contains(Flags::NONE));
-//!     assert!(none.contains(Flags::NONE));
-//!     assert!(some.contains(Flags::NONE));
-//!
-//!     // Zero flags will be ignored when testing for emptiness
-//!     assert!(none.is_empty());
-//! }
-//! ```
-//!
-//! Users should generally avoid defining a flag with a value of zero.
-
-#![cfg_attr(not(test), no_std)]
-#![doc(html_root_url = "https://docs.rs/bitflags/1.3.2")]
-
-#[doc(hidden)]
-pub extern crate core as _core;
-
-/// The macro used to generate the flag structures.
-///
-/// See the [crate level docs](../bitflags/index.html) for complete documentation.
-///
-/// # Example
-///
-/// ```
-/// use bitflags::bitflags;
-///
-/// bitflags! {
-///     struct Flags: u32 {
-///         const A = 0b00000001;
-///         const B = 0b00000010;
-///         const C = 0b00000100;
-///         const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-///     }
-/// }
-///
-/// fn main() {
-///     let e1 = Flags::A | Flags::C;
-///     let e2 = Flags::B | Flags::C;
-///     assert_eq!((e1 | e2), Flags::ABC);   // union
-///     assert_eq!((e1 & e2), Flags::C);     // intersection
-///     assert_eq!((e1 - e2), Flags::A);     // set difference
-///     assert_eq!(!e2, Flags::A);           // set complement
-/// }
-/// ```
-///
-/// The generated `struct`s can also be extended with type and trait
-/// implementations:
-///
-/// ```
-/// use std::fmt;
-///
-/// use bitflags::bitflags;
-///
-/// bitflags! {
-///     struct Flags: u32 {
-///         const A = 0b00000001;
-///         const B = 0b00000010;
-///     }
-/// }
-///
-/// impl Flags {
-///     pub fn clear(&mut self) {
-///         self.bits = 0;  // The `bits` field can be accessed from within the
-///                         // same module where the `bitflags!` macro was invoked.
-///     }
-/// }
-///
-/// impl fmt::Display for Flags {
-///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-///         write!(f, "hi!")
-///     }
-/// }
-///
-/// fn main() {
-///     let mut flags = Flags::A | Flags::B;
-///     flags.clear();
-///     assert!(flags.is_empty());
-///     assert_eq!(format!("{}", flags), "hi!");
-///     assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
-///     assert_eq!(format!("{:?}", Flags::B), "B");
-/// }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! bitflags {
-    (
-        $(#[$outer:meta])*
-        $vis:vis struct $BitFlags:ident: $T:ty {
-            $(
-                $(#[$inner:ident $($args:tt)*])*
-                const $Flag:ident = $value:expr;
-            )*
-        }
-
-        $($t:tt)*
-    ) => {
-        $(#[$outer])*
-        #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
-        $vis struct $BitFlags {
-            bits: $T,
-        }
-
-        __impl_bitflags! {
-            $BitFlags: $T {
-                $(
-                    $(#[$inner $($args)*])*
-                    $Flag = $value;
-                )*
-            }
-        }
-
-        bitflags! {
-            $($t)*
-        }
-    };
-    () => {};
-}
-
-// A helper macro to implement the `all` function.
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! __impl_all_bitflags {
-    (
-        $BitFlags:ident: $T:ty {
-            $(
-                $(#[$attr:ident $($args:tt)*])*
-                $Flag:ident = $value:expr;
-            )+
-        }
-    ) => {
-        // See `Debug::fmt` for why this approach is taken.
-        #[allow(non_snake_case)]
-        trait __BitFlags {
-            $(
-                const $Flag: $T = 0;
-            )+
-        }
-        #[allow(non_snake_case)]
-        impl __BitFlags for $BitFlags {
-            $(
-                __impl_bitflags! {
-                    #[allow(deprecated)]
-                    $(? #[$attr $($args)*])*
-                    const $Flag: $T = Self::$Flag.bits;
-                }
-            )+
-        }
-        Self { bits: $(<Self as __BitFlags>::$Flag)|+ }
-    };
-    (
-        $BitFlags:ident: $T:ty { }
-    ) => {
-        Self { bits: 0 }
-    };
-}
-
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! __impl_bitflags {
-    (
-        $BitFlags:ident: $T:ty {
-            $(
-                $(#[$attr:ident $($args:tt)*])*
-                $Flag:ident = $value:expr;
-            )*
-        }
-    ) => {
-        impl $crate::_core::fmt::Debug for $BitFlags {
-            fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
-                // This convoluted approach is to handle #[cfg]-based flag
-                // omission correctly. For example it needs to support:
-                //
-                //    #[cfg(unix)] const A: Flag = /* ... */;
-                //    #[cfg(windows)] const B: Flag = /* ... */;
-
-                // Unconditionally define a check for every flag, even disabled
-                // ones.
-                #[allow(non_snake_case)]
-                trait __BitFlags {
-                    $(
-                        #[inline]
-                        fn $Flag(&self) -> bool { false }
-                    )*
-                }
-
-                // Conditionally override the check for just those flags that
-                // are not #[cfg]ed away.
-                #[allow(non_snake_case)]
-                impl __BitFlags for $BitFlags {
-                    $(
-                        __impl_bitflags! {
-                            #[allow(deprecated)]
-                            #[inline]
-                            $(? #[$attr $($args)*])*
-                            fn $Flag(&self) -> bool {
-                                if Self::$Flag.bits == 0 && self.bits != 0 {
-                                    false
-                                } else {
-                                    self.bits & Self::$Flag.bits == Self::$Flag.bits
-                                }
-                            }
-                        }
-                    )*
-                }
-
-                let mut first = true;
-                $(
-                    if <Self as __BitFlags>::$Flag(self) {
-                        if !first {
-                            f.write_str(" | ")?;
-                        }
-                        first = false;
-                        f.write_str($crate::_core::stringify!($Flag))?;
-                    }
-                )*
-                let extra_bits = self.bits & !Self::all().bits();
-                if extra_bits != 0 {
-                    if !first {
-                        f.write_str(" | ")?;
-                    }
-                    first = false;
-                    f.write_str("0x")?;
-                    $crate::_core::fmt::LowerHex::fmt(&extra_bits, f)?;
-                }
-                if first {
-                    f.write_str("(empty)")?;
-                }
-                Ok(())
-            }
-        }
-        impl $crate::_core::fmt::Binary for $BitFlags {
-            fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
-                $crate::_core::fmt::Binary::fmt(&self.bits, f)
-            }
-        }
-        impl $crate::_core::fmt::Octal for $BitFlags {
-            fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
-                $crate::_core::fmt::Octal::fmt(&self.bits, f)
-            }
-        }
-        impl $crate::_core::fmt::LowerHex for $BitFlags {
-            fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
-                $crate::_core::fmt::LowerHex::fmt(&self.bits, f)
-            }
-        }
-        impl $crate::_core::fmt::UpperHex for $BitFlags {
-            fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
-                $crate::_core::fmt::UpperHex::fmt(&self.bits, f)
-            }
-        }
-
-        #[allow(dead_code)]
-        impl $BitFlags {
-            $(
-                $(#[$attr $($args)*])*
-                pub const $Flag: Self = Self { bits: $value };
-            )*
-
-            /// Returns an empty set of flags.
-            #[inline]
-            pub const fn empty() -> Self {
-                Self { bits: 0 }
-            }
-
-            /// Returns the set containing all flags.
-            #[inline]
-            pub const fn all() -> Self {
-                __impl_all_bitflags! {
-                    $BitFlags: $T {
-                        $(
-                            $(#[$attr $($args)*])*
-                            $Flag = $value;
-                        )*
-                    }
-                }
-            }
-
-            /// Returns the raw value of the flags currently stored.
-            #[inline]
-            pub const fn bits(&self) -> $T {
-                self.bits
-            }
-
-            /// Convert from underlying bit representation, unless that
-            /// representation contains bits that do not correspond to a flag.
-            #[inline]
-            pub const fn from_bits(bits: $T) -> $crate::_core::option::Option<Self> {
-                if (bits & !Self::all().bits()) == 0 {
-                    $crate::_core::option::Option::Some(Self { bits })
-                } else {
-                    $crate::_core::option::Option::None
-                }
-            }
-
-            /// Convert from underlying bit representation, dropping any bits
-            /// that do not correspond to flags.
-            #[inline]
-            pub const fn from_bits_truncate(bits: $T) -> Self {
-                Self { bits: bits & Self::all().bits }
-            }
-
-            /// Convert from underlying bit representation, preserving all
-            /// bits (even those not corresponding to a defined flag).
-            ///
-            /// # Safety
-            ///
-            /// The caller of the `bitflags!` macro can chose to allow or
-            /// disallow extra bits for their bitflags type.
-            ///
-            /// The caller of `from_bits_unchecked()` has to ensure that
-            /// all bits correspond to a defined flag or that extra bits
-            /// are valid for this bitflags type.
-            #[inline]
-            pub const unsafe fn from_bits_unchecked(bits: $T) -> Self {
-                Self { bits }
-            }
-
-            /// Returns `true` if no flags are currently stored.
-            #[inline]
-            pub const fn is_empty(&self) -> bool {
-                self.bits() == Self::empty().bits()
-            }
-
-            /// Returns `true` if all flags are currently set.
-            #[inline]
-            pub const fn is_all(&self) -> bool {
-                Self::all().bits | self.bits == self.bits
-            }
-
-            /// Returns `true` if there are flags common to both `self` and `other`.
-            #[inline]
-            pub const fn intersects(&self, other: Self) -> bool {
-                !(Self { bits: self.bits & other.bits}).is_empty()
-            }
-
-            /// Returns `true` if all of the flags in `other` are contained within `self`.
-            #[inline]
-            pub const fn contains(&self, other: Self) -> bool {
-                (self.bits & other.bits) == other.bits
-            }
-
-            /// Inserts the specified flags in-place.
-            #[inline]
-            pub fn insert(&mut self, other: Self) {
-                self.bits |= other.bits;
-            }
-
-            /// Removes the specified flags in-place.
-            #[inline]
-            pub fn remove(&mut self, other: Self) {
-                self.bits &= !other.bits;
-            }
-
-            /// Toggles the specified flags in-place.
-            #[inline]
-            pub fn toggle(&mut self, other: Self) {
-                self.bits ^= other.bits;
-            }
-
-            /// Inserts or removes the specified flags depending on the passed value.
-            #[inline]
-            pub fn set(&mut self, other: Self, value: bool) {
-                if value {
-                    self.insert(other);
-                } else {
-                    self.remove(other);
-                }
-            }
-
-            /// Returns the intersection between the flags in `self` and
-            /// `other`.
-            ///
-            /// Specifically, the returned set contains only the flags which are
-            /// present in *both* `self` *and* `other`.
-            ///
-            /// This is equivalent to using the `&` operator (e.g.
-            /// [`ops::BitAnd`]), as in `flags & other`.
-            ///
-            /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
-            #[inline]
-            #[must_use]
-            pub const fn intersection(self, other: Self) -> Self {
-                Self { bits: self.bits & other.bits }
-            }
-
-            /// Returns the union of between the flags in `self` and `other`.
-            ///
-            /// Specifically, the returned set contains all flags which are
-            /// present in *either* `self` *or* `other`, including any which are
-            /// present in both (see [`Self::symmetric_difference`] if that
-            /// is undesirable).
-            ///
-            /// This is equivalent to using the `|` operator (e.g.
-            /// [`ops::BitOr`]), as in `flags | other`.
-            ///
-            /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
-            #[inline]
-            #[must_use]
-            pub const fn union(self, other: Self) -> Self {
-                Self { bits: self.bits | other.bits }
-            }
-
-            /// Returns the difference between the flags in `self` and `other`.
-            ///
-            /// Specifically, the returned set contains all flags present in
-            /// `self`, except for the ones present in `other`.
-            ///
-            /// It is also conceptually equivalent to the "bit-clear" operation:
-            /// `flags & !other` (and this syntax is also supported).
-            ///
-            /// This is equivalent to using the `-` operator (e.g.
-            /// [`ops::Sub`]), as in `flags - other`.
-            ///
-            /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
-            #[inline]
-            #[must_use]
-            pub const fn difference(self, other: Self) -> Self {
-                Self { bits: self.bits & !other.bits }
-            }
-
-            /// Returns the [symmetric difference][sym-diff] between the flags
-            /// in `self` and `other`.
-            ///
-            /// Specifically, the returned set contains the flags present which
-            /// are present in `self` or `other`, but that are not present in
-            /// both. Equivalently, it contains the flags present in *exactly
-            /// one* of the sets `self` and `other`.
-            ///
-            /// This is equivalent to using the `^` operator (e.g.
-            /// [`ops::BitXor`]), as in `flags ^ other`.
-            ///
-            /// [sym-diff]: https://en.wikipedia.org/wiki/Symmetric_difference
-            /// [`ops::BitXor`]: https://doc.rust-lang.org/std/ops/trait.BitXor.html
-            #[inline]
-            #[must_use]
-            pub const fn symmetric_difference(self, other: Self) -> Self {
-                Self { bits: self.bits ^ other.bits }
-            }
-
-            /// Returns the complement of this set of flags.
-            ///
-            /// Specifically, the returned set contains all the flags which are
-            /// not set in `self`, but which are allowed for this type.
-            ///
-            /// Alternatively, it can be thought of as the set difference
-            /// between [`Self::all()`] and `self` (e.g. `Self::all() - self`)
-            ///
-            /// This is equivalent to using the `!` operator (e.g.
-            /// [`ops::Not`]), as in `!flags`.
-            ///
-            /// [`Self::all()`]: Self::all
-            /// [`ops::Not`]: https://doc.rust-lang.org/std/ops/trait.Not.html
-            #[inline]
-            #[must_use]
-            pub const fn complement(self) -> Self {
-                Self::from_bits_truncate(!self.bits)
-            }
-
-        }
-
-        impl $crate::_core::ops::BitOr for $BitFlags {
-            type Output = Self;
-
-            /// Returns the union of the two sets of flags.
-            #[inline]
-            fn bitor(self, other: $BitFlags) -> Self {
-                Self { bits: self.bits | other.bits }
-            }
-        }
-
-        impl $crate::_core::ops::BitOrAssign for $BitFlags {
-            /// Adds the set of flags.
-            #[inline]
-            fn bitor_assign(&mut self, other: Self) {
-                self.bits |= other.bits;
-            }
-        }
-
-        impl $crate::_core::ops::BitXor for $BitFlags {
-            type Output = Self;
-
-            /// Returns the left flags, but with all the right flags toggled.
-            #[inline]
-            fn bitxor(self, other: Self) -> Self {
-                Self { bits: self.bits ^ other.bits }
-            }
-        }
-
-        impl $crate::_core::ops::BitXorAssign for $BitFlags {
-            /// Toggles the set of flags.
-            #[inline]
-            fn bitxor_assign(&mut self, other: Self) {
-                self.bits ^= other.bits;
-            }
-        }
-
-        impl $crate::_core::ops::BitAnd for $BitFlags {
-            type Output = Self;
-
-            /// Returns the intersection between the two sets of flags.
-            #[inline]
-            fn bitand(self, other: Self) -> Self {
-                Self { bits: self.bits & other.bits }
-            }
-        }
-
-        impl $crate::_core::ops::BitAndAssign for $BitFlags {
-            /// Disables all flags disabled in the set.
-            #[inline]
-            fn bitand_assign(&mut self, other: Self) {
-                self.bits &= other.bits;
-            }
-        }
-
-        impl $crate::_core::ops::Sub for $BitFlags {
-            type Output = Self;
-
-            /// Returns the set difference of the two sets of flags.
-            #[inline]
-            fn sub(self, other: Self) -> Self {
-                Self { bits: self.bits & !other.bits }
-            }
-        }
-
-        impl $crate::_core::ops::SubAssign for $BitFlags {
-            /// Disables all flags enabled in the set.
-            #[inline]
-            fn sub_assign(&mut self, other: Self) {
-                self.bits &= !other.bits;
-            }
-        }
-
-        impl $crate::_core::ops::Not for $BitFlags {
-            type Output = Self;
-
-            /// Returns the complement of this set of flags.
-            #[inline]
-            fn not(self) -> Self {
-                Self { bits: !self.bits } & Self::all()
-            }
-        }
-
-        impl $crate::_core::iter::Extend<$BitFlags> for $BitFlags {
-            fn extend<T: $crate::_core::iter::IntoIterator<Item=Self>>(&mut self, iterator: T) {
-                for item in iterator {
-                    self.insert(item)
-                }
-            }
-        }
-
-        impl $crate::_core::iter::FromIterator<$BitFlags> for $BitFlags {
-            fn from_iter<T: $crate::_core::iter::IntoIterator<Item=Self>>(iterator: T) -> Self {
-                let mut result = Self::empty();
-                result.extend(iterator);
-                result
-            }
-        }
-    };
-
-    // Every attribute that the user writes on a const is applied to the
-    // corresponding const that we generate, but within the implementation of
-    // Debug and all() we want to ignore everything but #[cfg] attributes. In
-    // particular, including a #[deprecated] attribute on those items would fail
-    // to compile.
-    // https://github.com/bitflags/bitflags/issues/109
-    //
-    // Input:
-    //
-    //     ? #[cfg(feature = "advanced")]
-    //     ? #[deprecated(note = "Use something else.")]
-    //     ? #[doc = r"High quality documentation."]
-    //     fn f() -> i32 { /* ... */ }
-    //
-    // Output:
-    //
-    //     #[cfg(feature = "advanced")]
-    //     fn f() -> i32 { /* ... */ }
-    (
-        $(#[$filtered:meta])*
-        ? #[cfg $($cfgargs:tt)*]
-        $(? #[$rest:ident $($restargs:tt)*])*
-        fn $($item:tt)*
-    ) => {
-        __impl_bitflags! {
-            $(#[$filtered])*
-            #[cfg $($cfgargs)*]
-            $(? #[$rest $($restargs)*])*
-            fn $($item)*
-        }
-    };
-    (
-        $(#[$filtered:meta])*
-        // $next != `cfg`
-        ? #[$next:ident $($nextargs:tt)*]
-        $(? #[$rest:ident $($restargs:tt)*])*
-        fn $($item:tt)*
-    ) => {
-        __impl_bitflags! {
-            $(#[$filtered])*
-            // $next filtered out
-            $(? #[$rest $($restargs)*])*
-            fn $($item)*
-        }
-    };
-    (
-        $(#[$filtered:meta])*
-        fn $($item:tt)*
-    ) => {
-        $(#[$filtered])*
-        fn $($item)*
-    };
-
-    // Every attribute that the user writes on a const is applied to the
-    // corresponding const that we generate, but within the implementation of
-    // Debug and all() we want to ignore everything but #[cfg] attributes. In
-    // particular, including a #[deprecated] attribute on those items would fail
-    // to compile.
-    // https://github.com/bitflags/bitflags/issues/109
-    //
-    // const version
-    //
-    // Input:
-    //
-    //     ? #[cfg(feature = "advanced")]
-    //     ? #[deprecated(note = "Use something else.")]
-    //     ? #[doc = r"High quality documentation."]
-    //     const f: i32 { /* ... */ }
-    //
-    // Output:
-    //
-    //     #[cfg(feature = "advanced")]
-    //     const f: i32 { /* ... */ }
-    (
-        $(#[$filtered:meta])*
-        ? #[cfg $($cfgargs:tt)*]
-        $(? #[$rest:ident $($restargs:tt)*])*
-        const $($item:tt)*
-    ) => {
-        __impl_bitflags! {
-            $(#[$filtered])*
-            #[cfg $($cfgargs)*]
-            $(? #[$rest $($restargs)*])*
-            const $($item)*
-        }
-    };
-    (
-        $(#[$filtered:meta])*
-        // $next != `cfg`
-        ? #[$next:ident $($nextargs:tt)*]
-        $(? #[$rest:ident $($restargs:tt)*])*
-        const $($item:tt)*
-    ) => {
-        __impl_bitflags! {
-            $(#[$filtered])*
-            // $next filtered out
-            $(? #[$rest $($restargs)*])*
-            const $($item)*
-        }
-    };
-    (
-        $(#[$filtered:meta])*
-        const $($item:tt)*
-    ) => {
-        $(#[$filtered])*
-        const $($item)*
-    };
-}
-
-#[cfg(feature = "example_generated")]
-pub mod example_generated;
-
-#[cfg(test)]
-mod tests {
-    use std::collections::hash_map::DefaultHasher;
-    use std::hash::{Hash, Hasher};
-
-    bitflags! {
-        #[doc = "> The first principle is that you must not fool yourself — and"]
-        #[doc = "> you are the easiest person to fool."]
-        #[doc = "> "]
-        #[doc = "> - Richard Feynman"]
-        #[derive(Default)]
-        struct Flags: u32 {
-            const A = 0b00000001;
-            #[doc = "<pcwalton> macros are way better at generating code than trans is"]
-            const B = 0b00000010;
-            const C = 0b00000100;
-            #[doc = "* cmr bed"]
-            #[doc = "* strcat table"]
-            #[doc = "<strcat> wait what?"]
-            const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-        }
-
-        struct _CfgFlags: u32 {
-            #[cfg(unix)]
-            const _CFG_A = 0b01;
-            #[cfg(windows)]
-            const _CFG_B = 0b01;
-            #[cfg(unix)]
-            const _CFG_C = Self::_CFG_A.bits | 0b10;
-        }
-
-        struct AnotherSetOfFlags: i8 {
-            const ANOTHER_FLAG = -1_i8;
-        }
-
-        struct LongFlags: u32 {
-            const LONG_A = 0b1111111111111111;
-        }
-    }
-
-    bitflags! {
-        struct EmptyFlags: u32 {
-        }
-    }
-
-    #[test]
-    fn test_bits() {
-        assert_eq!(Flags::empty().bits(), 0b00000000);
-        assert_eq!(Flags::A.bits(), 0b00000001);
-        assert_eq!(Flags::ABC.bits(), 0b00000111);
-
-        assert_eq!(AnotherSetOfFlags::empty().bits(), 0b00);
-        assert_eq!(AnotherSetOfFlags::ANOTHER_FLAG.bits(), !0_i8);
-
-        assert_eq!(EmptyFlags::empty().bits(), 0b00000000);
-    }
-
-    #[test]
-    fn test_from_bits() {
-        assert_eq!(Flags::from_bits(0), Some(Flags::empty()));
-        assert_eq!(Flags::from_bits(0b1), Some(Flags::A));
-        assert_eq!(Flags::from_bits(0b10), Some(Flags::B));
-        assert_eq!(Flags::from_bits(0b11), Some(Flags::A | Flags::B));
-        assert_eq!(Flags::from_bits(0b1000), None);
-
-        assert_eq!(
-            AnotherSetOfFlags::from_bits(!0_i8),
-            Some(AnotherSetOfFlags::ANOTHER_FLAG)
-        );
-
-        assert_eq!(EmptyFlags::from_bits(0), Some(EmptyFlags::empty()));
-        assert_eq!(EmptyFlags::from_bits(0b1), None);
-    }
-
-    #[test]
-    fn test_from_bits_truncate() {
-        assert_eq!(Flags::from_bits_truncate(0), Flags::empty());
-        assert_eq!(Flags::from_bits_truncate(0b1), Flags::A);
-        assert_eq!(Flags::from_bits_truncate(0b10), Flags::B);
-        assert_eq!(Flags::from_bits_truncate(0b11), (Flags::A | Flags::B));
-        assert_eq!(Flags::from_bits_truncate(0b1000), Flags::empty());
-        assert_eq!(Flags::from_bits_truncate(0b1001), Flags::A);
-
-        assert_eq!(
-            AnotherSetOfFlags::from_bits_truncate(0_i8),
-            AnotherSetOfFlags::empty()
-        );
-
-        assert_eq!(EmptyFlags::from_bits_truncate(0), EmptyFlags::empty());
-        assert_eq!(EmptyFlags::from_bits_truncate(0b1), EmptyFlags::empty());
-    }
-
-    #[test]
-    fn test_from_bits_unchecked() {
-        let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
-        assert_eq!(unsafe { Flags::from_bits_unchecked(0) }, Flags::empty());
-        assert_eq!(unsafe { Flags::from_bits_unchecked(0b1) }, Flags::A);
-        assert_eq!(unsafe { Flags::from_bits_unchecked(0b10) }, Flags::B);
-
-        assert_eq!(
-            unsafe { Flags::from_bits_unchecked(0b11) },
-            (Flags::A | Flags::B)
-        );
-        assert_eq!(
-            unsafe { Flags::from_bits_unchecked(0b1000) },
-            (extra | Flags::empty())
-        );
-        assert_eq!(
-            unsafe { Flags::from_bits_unchecked(0b1001) },
-            (extra | Flags::A)
-        );
-
-        let extra = unsafe { EmptyFlags::from_bits_unchecked(0b1000) };
-        assert_eq!(
-            unsafe { EmptyFlags::from_bits_unchecked(0b1000) },
-            (extra | EmptyFlags::empty())
-        );
-    }
-
-    #[test]
-    fn test_is_empty() {
-        assert!(Flags::empty().is_empty());
-        assert!(!Flags::A.is_empty());
-        assert!(!Flags::ABC.is_empty());
-
-        assert!(!AnotherSetOfFlags::ANOTHER_FLAG.is_empty());
-
-        assert!(EmptyFlags::empty().is_empty());
-        assert!(EmptyFlags::all().is_empty());
-    }
-
-    #[test]
-    fn test_is_all() {
-        assert!(Flags::all().is_all());
-        assert!(!Flags::A.is_all());
-        assert!(Flags::ABC.is_all());
-
-        let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
-        assert!(!extra.is_all());
-        assert!(!(Flags::A | extra).is_all());
-        assert!((Flags::ABC | extra).is_all());
-
-        assert!(AnotherSetOfFlags::ANOTHER_FLAG.is_all());
-
-        assert!(EmptyFlags::all().is_all());
-        assert!(EmptyFlags::empty().is_all());
-    }
-
-    #[test]
-    fn test_two_empties_do_not_intersect() {
-        let e1 = Flags::empty();
-        let e2 = Flags::empty();
-        assert!(!e1.intersects(e2));
-
-        assert!(AnotherSetOfFlags::ANOTHER_FLAG.intersects(AnotherSetOfFlags::ANOTHER_FLAG));
-    }
-
-    #[test]
-    fn test_empty_does_not_intersect_with_full() {
-        let e1 = Flags::empty();
-        let e2 = Flags::ABC;
-        assert!(!e1.intersects(e2));
-    }
-
-    #[test]
-    fn test_disjoint_intersects() {
-        let e1 = Flags::A;
-        let e2 = Flags::B;
-        assert!(!e1.intersects(e2));
-    }
-
-    #[test]
-    fn test_overlapping_intersects() {
-        let e1 = Flags::A;
-        let e2 = Flags::A | Flags::B;
-        assert!(e1.intersects(e2));
-    }
-
-    #[test]
-    fn test_contains() {
-        let e1 = Flags::A;
-        let e2 = Flags::A | Flags::B;
-        assert!(!e1.contains(e2));
-        assert!(e2.contains(e1));
-        assert!(Flags::ABC.contains(e2));
-
-        assert!(AnotherSetOfFlags::ANOTHER_FLAG.contains(AnotherSetOfFlags::ANOTHER_FLAG));
-
-        assert!(EmptyFlags::empty().contains(EmptyFlags::empty()));
-    }
-
-    #[test]
-    fn test_insert() {
-        let mut e1 = Flags::A;
-        let e2 = Flags::A | Flags::B;
-        e1.insert(e2);
-        assert_eq!(e1, e2);
-
-        let mut e3 = AnotherSetOfFlags::empty();
-        e3.insert(AnotherSetOfFlags::ANOTHER_FLAG);
-        assert_eq!(e3, AnotherSetOfFlags::ANOTHER_FLAG);
-    }
-
-    #[test]
-    fn test_remove() {
-        let mut e1 = Flags::A | Flags::B;
-        let e2 = Flags::A | Flags::C;
-        e1.remove(e2);
-        assert_eq!(e1, Flags::B);
-
-        let mut e3 = AnotherSetOfFlags::ANOTHER_FLAG;
-        e3.remove(AnotherSetOfFlags::ANOTHER_FLAG);
-        assert_eq!(e3, AnotherSetOfFlags::empty());
-    }
-
-    #[test]
-    fn test_operators() {
-        let e1 = Flags::A | Flags::C;
-        let e2 = Flags::B | Flags::C;
-        assert_eq!((e1 | e2), Flags::ABC); // union
-        assert_eq!((e1 & e2), Flags::C); // intersection
-        assert_eq!((e1 - e2), Flags::A); // set difference
-        assert_eq!(!e2, Flags::A); // set complement
-        assert_eq!(e1 ^ e2, Flags::A | Flags::B); // toggle
-        let mut e3 = e1;
-        e3.toggle(e2);
-        assert_eq!(e3, Flags::A | Flags::B);
-
-        let mut m4 = AnotherSetOfFlags::empty();
-        m4.toggle(AnotherSetOfFlags::empty());
-        assert_eq!(m4, AnotherSetOfFlags::empty());
-    }
-
-    #[test]
-    fn test_operators_unchecked() {
-        let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
-        let e1 = Flags::A | Flags::C | extra;
-        let e2 = Flags::B | Flags::C;
-        assert_eq!((e1 | e2), (Flags::ABC | extra)); // union
-        assert_eq!((e1 & e2), Flags::C); // intersection
-        assert_eq!((e1 - e2), (Flags::A | extra)); // set difference
-        assert_eq!(!e2, Flags::A); // set complement
-        assert_eq!(!e1, Flags::B); // set complement
-        assert_eq!(e1 ^ e2, Flags::A | Flags::B | extra); // toggle
-        let mut e3 = e1;
-        e3.toggle(e2);
-        assert_eq!(e3, Flags::A | Flags::B | extra);
-    }
-
-    #[test]
-    fn test_set_ops_basic() {
-        let ab = Flags::A.union(Flags::B);
-        let ac = Flags::A.union(Flags::C);
-        let bc = Flags::B.union(Flags::C);
-        assert_eq!(ab.bits, 0b011);
-        assert_eq!(bc.bits, 0b110);
-        assert_eq!(ac.bits, 0b101);
-
-        assert_eq!(ab, Flags::B.union(Flags::A));
-        assert_eq!(ac, Flags::C.union(Flags::A));
-        assert_eq!(bc, Flags::C.union(Flags::B));
-
-        assert_eq!(ac, Flags::A | Flags::C);
-        assert_eq!(bc, Flags::B | Flags::C);
-        assert_eq!(ab.union(bc), Flags::ABC);
-
-        assert_eq!(ac, Flags::A | Flags::C);
-        assert_eq!(bc, Flags::B | Flags::C);
-
-        assert_eq!(ac.union(bc), ac | bc);
-        assert_eq!(ac.union(bc), Flags::ABC);
-        assert_eq!(bc.union(ac), Flags::ABC);
-
-        assert_eq!(ac.intersection(bc), ac & bc);
-        assert_eq!(ac.intersection(bc), Flags::C);
-        assert_eq!(bc.intersection(ac), Flags::C);
-
-        assert_eq!(ac.difference(bc), ac - bc);
-        assert_eq!(bc.difference(ac), bc - ac);
-        assert_eq!(ac.difference(bc), Flags::A);
-        assert_eq!(bc.difference(ac), Flags::B);
-
-        assert_eq!(bc.complement(), !bc);
-        assert_eq!(bc.complement(), Flags::A);
-        assert_eq!(ac.symmetric_difference(bc), Flags::A.union(Flags::B));
-        assert_eq!(bc.symmetric_difference(ac), Flags::A.union(Flags::B));
-    }
-
-    #[test]
-    fn test_set_ops_const() {
-        // These just test that these compile and don't cause use-site panics
-        // (would be possible if we had some sort of UB)
-        const INTERSECT: Flags = Flags::all().intersection(Flags::C);
-        const UNION: Flags = Flags::A.union(Flags::C);
-        const DIFFERENCE: Flags = Flags::all().difference(Flags::A);
-        const COMPLEMENT: Flags = Flags::C.complement();
-        const SYM_DIFFERENCE: Flags = UNION.symmetric_difference(DIFFERENCE);
-        assert_eq!(INTERSECT, Flags::C);
-        assert_eq!(UNION, Flags::A | Flags::C);
-        assert_eq!(DIFFERENCE, Flags::all() - Flags::A);
-        assert_eq!(COMPLEMENT, !Flags::C);
-        assert_eq!(SYM_DIFFERENCE, (Flags::A | Flags::C) ^ (Flags::all() - Flags::A));
-    }
-
-    #[test]
-    fn test_set_ops_unchecked() {
-        let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
-        let e1 = Flags::A.union(Flags::C).union(extra);
-        let e2 = Flags::B.union(Flags::C);
-        assert_eq!(e1.bits, 0b1101);
-        assert_eq!(e1.union(e2), (Flags::ABC | extra));
-        assert_eq!(e1.intersection(e2), Flags::C);
-        assert_eq!(e1.difference(e2), Flags::A | extra);
-        assert_eq!(e2.difference(e1), Flags::B);
-        assert_eq!(e2.complement(), Flags::A);
-        assert_eq!(e1.complement(), Flags::B);
-        assert_eq!(e1.symmetric_difference(e2), Flags::A | Flags::B | extra); // toggle
-    }
-
-    #[test]
-    fn test_set_ops_exhaustive() {
-        // Define a flag that contains gaps to help exercise edge-cases,
-        // especially around "unknown" flags (e.g. ones outside of `all()`
-        // `from_bits_unchecked`).
-        // - when lhs and rhs both have different sets of unknown flags.
-        // - unknown flags at both ends, and in the middle
-        // - cases with "gaps".
-        bitflags! {
-            struct Test: u16 {
-                // Intentionally no `A`
-                const B = 0b000000010;
-                // Intentionally no `C`
-                const D = 0b000001000;
-                const E = 0b000010000;
-                const F = 0b000100000;
-                const G = 0b001000000;
-                // Intentionally no `H`
-                const I = 0b100000000;
-            }
-        }
-        let iter_test_flags =
-            || (0..=0b111_1111_1111).map(|bits| unsafe { Test::from_bits_unchecked(bits) });
-
-        for a in iter_test_flags() {
-            assert_eq!(
-                a.complement(),
-                Test::from_bits_truncate(!a.bits),
-                "wrong result: !({:?})",
-                a,
-            );
-            assert_eq!(a.complement(), !a, "named != op: !({:?})", a);
-            for b in iter_test_flags() {
-                // Check that the named operations produce the expected bitwise
-                // values.
-                assert_eq!(
-                    a.union(b).bits,
-                    a.bits | b.bits,
-                    "wrong result: `{:?}` | `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(
-                    a.intersection(b).bits,
-                    a.bits & b.bits,
-                    "wrong result: `{:?}` & `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(
-                    a.symmetric_difference(b).bits,
-                    a.bits ^ b.bits,
-                    "wrong result: `{:?}` ^ `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(
-                    a.difference(b).bits,
-                    a.bits & !b.bits,
-                    "wrong result: `{:?}` - `{:?}`",
-                    a,
-                    b,
-                );
-                // Note: Difference is checked as both `a - b` and `b - a`
-                assert_eq!(
-                    b.difference(a).bits,
-                    b.bits & !a.bits,
-                    "wrong result: `{:?}` - `{:?}`",
-                    b,
-                    a,
-                );
-                // Check that the named set operations are equivalent to the
-                // bitwise equivalents
-                assert_eq!(a.union(b), a | b, "named != op: `{:?}` | `{:?}`", a, b,);
-                assert_eq!(
-                    a.intersection(b),
-                    a & b,
-                    "named != op: `{:?}` & `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(
-                    a.symmetric_difference(b),
-                    a ^ b,
-                    "named != op: `{:?}` ^ `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(a.difference(b), a - b, "named != op: `{:?}` - `{:?}`", a, b,);
-                // Note: Difference is checked as both `a - b` and `b - a`
-                assert_eq!(b.difference(a), b - a, "named != op: `{:?}` - `{:?}`", b, a,);
-                // Verify that the operations which should be symmetric are
-                // actually symmetric.
-                assert_eq!(a.union(b), b.union(a), "asymmetry: `{:?}` | `{:?}`", a, b,);
-                assert_eq!(
-                    a.intersection(b),
-                    b.intersection(a),
-                    "asymmetry: `{:?}` & `{:?}`",
-                    a,
-                    b,
-                );
-                assert_eq!(
-                    a.symmetric_difference(b),
-                    b.symmetric_difference(a),
-                    "asymmetry: `{:?}` ^ `{:?}`",
-                    a,
-                    b,
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_set() {
-        let mut e1 = Flags::A | Flags::C;
-        e1.set(Flags::B, true);
-        e1.set(Flags::C, false);
-
-        assert_eq!(e1, Flags::A | Flags::B);
-    }
-
-    #[test]
-    fn test_assignment_operators() {
-        let mut m1 = Flags::empty();
-        let e1 = Flags::A | Flags::C;
-        // union
-        m1 |= Flags::A;
-        assert_eq!(m1, Flags::A);
-        // intersection
-        m1 &= e1;
-        assert_eq!(m1, Flags::A);
-        // set difference
-        m1 -= m1;
-        assert_eq!(m1, Flags::empty());
-        // toggle
-        m1 ^= e1;
-        assert_eq!(m1, e1);
-    }
-
-    #[test]
-    fn test_const_fn() {
-        const _M1: Flags = Flags::empty();
-
-        const M2: Flags = Flags::A;
-        assert_eq!(M2, Flags::A);
-
-        const M3: Flags = Flags::C;
-        assert_eq!(M3, Flags::C);
-    }
-
-    #[test]
-    fn test_extend() {
-        let mut flags;
-
-        flags = Flags::empty();
-        flags.extend([].iter().cloned());
-        assert_eq!(flags, Flags::empty());
-
-        flags = Flags::empty();
-        flags.extend([Flags::A, Flags::B].iter().cloned());
-        assert_eq!(flags, Flags::A | Flags::B);
-
-        flags = Flags::A;
-        flags.extend([Flags::A, Flags::B].iter().cloned());
-        assert_eq!(flags, Flags::A | Flags::B);
-
-        flags = Flags::B;
-        flags.extend([Flags::A, Flags::ABC].iter().cloned());
-        assert_eq!(flags, Flags::ABC);
-    }
-
-    #[test]
-    fn test_from_iterator() {
-        assert_eq!([].iter().cloned().collect::<Flags>(), Flags::empty());
-        assert_eq!(
-            [Flags::A, Flags::B].iter().cloned().collect::<Flags>(),
-            Flags::A | Flags::B
-        );
-        assert_eq!(
-            [Flags::A, Flags::ABC].iter().cloned().collect::<Flags>(),
-            Flags::ABC
-        );
-    }
-
-    #[test]
-    fn test_lt() {
-        let mut a = Flags::empty();
-        let mut b = Flags::empty();
-
-        assert!(!(a < b) && !(b < a));
-        b = Flags::B;
-        assert!(a < b);
-        a = Flags::C;
-        assert!(!(a < b) && b < a);
-        b = Flags::C | Flags::B;
-        assert!(a < b);
-    }
-
-    #[test]
-    fn test_ord() {
-        let mut a = Flags::empty();
-        let mut b = Flags::empty();
-
-        assert!(a <= b && a >= b);
-        a = Flags::A;
-        assert!(a > b && a >= b);
-        assert!(b < a && b <= a);
-        b = Flags::B;
-        assert!(b > a && b >= a);
-        assert!(a < b && a <= b);
-    }
-
-    fn hash<T: Hash>(t: &T) -> u64 {
-        let mut s = DefaultHasher::new();
-        t.hash(&mut s);
-        s.finish()
-    }
-
-    #[test]
-    fn test_hash() {
-        let mut x = Flags::empty();
-        let mut y = Flags::empty();
-        assert_eq!(hash(&x), hash(&y));
-        x = Flags::all();
-        y = Flags::ABC;
-        assert_eq!(hash(&x), hash(&y));
-    }
-
-    #[test]
-    fn test_default() {
-        assert_eq!(Flags::empty(), Flags::default());
-    }
-
-    #[test]
-    fn test_debug() {
-        assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
-        assert_eq!(format!("{:?}", Flags::empty()), "(empty)");
-        assert_eq!(format!("{:?}", Flags::ABC), "A | B | C | ABC");
-        let extra = unsafe { Flags::from_bits_unchecked(0xb8) };
-        assert_eq!(format!("{:?}", extra), "0xb8");
-        assert_eq!(format!("{:?}", Flags::A | extra), "A | 0xb8");
-
-        assert_eq!(
-            format!("{:?}", Flags::ABC | extra),
-            "A | B | C | ABC | 0xb8"
-        );
-
-        assert_eq!(format!("{:?}", EmptyFlags::empty()), "(empty)");
-    }
-
-    #[test]
-    fn test_binary() {
-        assert_eq!(format!("{:b}", Flags::ABC), "111");
-        assert_eq!(format!("{:#b}", Flags::ABC), "0b111");
-        let extra = unsafe { Flags::from_bits_unchecked(0b1010000) };
-        assert_eq!(format!("{:b}", Flags::ABC | extra), "1010111");
-        assert_eq!(format!("{:#b}", Flags::ABC | extra), "0b1010111");
-    }
-
-    #[test]
-    fn test_octal() {
-        assert_eq!(format!("{:o}", LongFlags::LONG_A), "177777");
-        assert_eq!(format!("{:#o}", LongFlags::LONG_A), "0o177777");
-        let extra = unsafe { LongFlags::from_bits_unchecked(0o5000000) };
-        assert_eq!(format!("{:o}", LongFlags::LONG_A | extra), "5177777");
-        assert_eq!(format!("{:#o}", LongFlags::LONG_A | extra), "0o5177777");
-    }
-
-    #[test]
-    fn test_lowerhex() {
-        assert_eq!(format!("{:x}", LongFlags::LONG_A), "ffff");
-        assert_eq!(format!("{:#x}", LongFlags::LONG_A), "0xffff");
-        let extra = unsafe { LongFlags::from_bits_unchecked(0xe00000) };
-        assert_eq!(format!("{:x}", LongFlags::LONG_A | extra), "e0ffff");
-        assert_eq!(format!("{:#x}", LongFlags::LONG_A | extra), "0xe0ffff");
-    }
-
-    #[test]
-    fn test_upperhex() {
-        assert_eq!(format!("{:X}", LongFlags::LONG_A), "FFFF");
-        assert_eq!(format!("{:#X}", LongFlags::LONG_A), "0xFFFF");
-        let extra = unsafe { LongFlags::from_bits_unchecked(0xe00000) };
-        assert_eq!(format!("{:X}", LongFlags::LONG_A | extra), "E0FFFF");
-        assert_eq!(format!("{:#X}", LongFlags::LONG_A | extra), "0xE0FFFF");
-    }
-
-    mod submodule {
-        bitflags! {
-            pub struct PublicFlags: i8 {
-                const X = 0;
-            }
-
-            struct PrivateFlags: i8 {
-                const Y = 0;
-            }
-        }
-
-        #[test]
-        fn test_private() {
-            let _ = PrivateFlags::Y;
-        }
-    }
-
-    #[test]
-    fn test_public() {
-        let _ = submodule::PublicFlags::X;
-    }
-
-    mod t1 {
-        mod foo {
-            pub type Bar = i32;
-        }
-
-        bitflags! {
-            /// baz
-            struct Flags: foo::Bar {
-                const A = 0b00000001;
-                #[cfg(foo)]
-                const B = 0b00000010;
-                #[cfg(foo)]
-                const C = 0b00000010;
-            }
-        }
-    }
-
-    #[test]
-    fn test_in_function() {
-        bitflags! {
-           struct Flags: u8 {
-                const A = 1;
-                #[cfg(any())] // false
-                const B = 2;
-            }
-        }
-        assert_eq!(Flags::all(), Flags::A);
-        assert_eq!(format!("{:?}", Flags::A), "A");
-    }
-
-    #[test]
-    fn test_deprecated() {
-        bitflags! {
-            pub struct TestFlags: u32 {
-                #[deprecated(note = "Use something else.")]
-                const ONE = 1;
-            }
-        }
-    }
-
-    #[test]
-    fn test_pub_crate() {
-        mod module {
-            bitflags! {
-                pub (crate) struct Test: u8 {
-                    const FOO = 1;
-                }
-            }
-        }
-
-        assert_eq!(module::Test::FOO.bits(), 1);
-    }
-
-    #[test]
-    fn test_pub_in_module() {
-        mod module {
-            mod submodule {
-                bitflags! {
-                    // `pub (in super)` means only the module `module` will
-                    // be able to access this.
-                    pub (in super) struct Test: u8 {
-                        const FOO = 1;
-                    }
-                }
-            }
-
-            mod test {
-                // Note: due to `pub (in super)`,
-                // this cannot be accessed directly by the testing code.
-                pub(super) fn value() -> u8 {
-                    super::submodule::Test::FOO.bits()
-                }
-            }
-
-            pub fn value() -> u8 {
-                test::value()
-            }
-        }
-
-        assert_eq!(module::value(), 1)
-    }
-
-    #[test]
-    fn test_zero_value_flags() {
-        bitflags! {
-            struct Flags: u32 {
-                const NONE = 0b0;
-                const SOME = 0b1;
-            }
-        }
-
-        assert!(Flags::empty().contains(Flags::NONE));
-        assert!(Flags::SOME.contains(Flags::NONE));
-        assert!(Flags::NONE.is_empty());
-
-        assert_eq!(format!("{:?}", Flags::empty()), "NONE");
-        assert_eq!(format!("{:?}", Flags::SOME), "SOME");
-    }
-
-    #[test]
-    fn test_empty_bitflags() {
-        bitflags! {}
-    }
-
-    #[test]
-    fn test_u128_bitflags() {
-        bitflags! {
-            struct Flags128: u128 {
-                const A = 0x0000_0000_0000_0000_0000_0000_0000_0001;
-                const B = 0x0000_0000_0000_1000_0000_0000_0000_0000;
-                const C = 0x8000_0000_0000_0000_0000_0000_0000_0000;
-                const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-            }
-        }
-
-        assert_eq!(Flags128::ABC, Flags128::A | Flags128::B | Flags128::C);
-        assert_eq!(Flags128::A.bits, 0x0000_0000_0000_0000_0000_0000_0000_0001);
-        assert_eq!(Flags128::B.bits, 0x0000_0000_0000_1000_0000_0000_0000_0000);
-        assert_eq!(Flags128::C.bits, 0x8000_0000_0000_0000_0000_0000_0000_0000);
-        assert_eq!(
-            Flags128::ABC.bits,
-            0x8000_0000_0000_1000_0000_0000_0000_0001
-        );
-        assert_eq!(format!("{:?}", Flags128::A), "A");
-        assert_eq!(format!("{:?}", Flags128::B), "B");
-        assert_eq!(format!("{:?}", Flags128::C), "C");
-        assert_eq!(format!("{:?}", Flags128::ABC), "A | B | C | ABC");
-    }
-
-    #[test]
-    fn test_serde_bitflags_serialize() {
-        let flags = SerdeFlags::A | SerdeFlags::B;
-
-        let serialized = serde_json::to_string(&flags).unwrap();
-
-        assert_eq!(serialized, r#"{"bits":3}"#);
-    }
-
-    #[test]
-    fn test_serde_bitflags_deserialize() {
-        let deserialized: SerdeFlags = serde_json::from_str(r#"{"bits":12}"#).unwrap();
-
-        let expected = SerdeFlags::C | SerdeFlags::D;
-
-        assert_eq!(deserialized.bits, expected.bits);
-    }
-
-    #[test]
-    fn test_serde_bitflags_roundtrip() {
-        let flags = SerdeFlags::A | SerdeFlags::B;
-
-        let deserialized: SerdeFlags = serde_json::from_str(&serde_json::to_string(&flags).unwrap()).unwrap();
-
-        assert_eq!(deserialized.bits, flags.bits);
-    }
-
-    bitflags! {
-        #[derive(serde::Serialize, serde::Deserialize)]
-        struct SerdeFlags: u32 {
-            const A = 1;
-            const B = 2;
-            const C = 4;
-            const D = 8;
-        }
-    }
-}
diff --git a/vendor/bitflags/tests/basic.rs b/vendor/bitflags/tests/basic.rs
deleted file mode 100644
index 73a52bec..00000000
--- a/vendor/bitflags/tests/basic.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![no_std]
-
-use bitflags::bitflags;
-
-bitflags! {
-    /// baz
-    struct Flags: u32 {
-        const A = 0b00000001;
-        #[doc = "bar"]
-        const B = 0b00000010;
-        const C = 0b00000100;
-        #[doc = "foo"]
-        const ABC = Flags::A.bits | Flags::B.bits | Flags::C.bits;
-    }
-}
-
-#[test]
-fn basic() {
-    assert_eq!(Flags::ABC, Flags::A | Flags::B | Flags::C);
-}
diff --git a/vendor/bitflags/tests/compile-fail/impls/copy.rs b/vendor/bitflags/tests/compile-fail/impls/copy.rs
deleted file mode 100644
index 38f4822f..00000000
--- a/vendor/bitflags/tests/compile-fail/impls/copy.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    #[derive(Clone, Copy)]
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta b/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta
deleted file mode 100644
index 0c13aa50..00000000
--- a/vendor/bitflags/tests/compile-fail/impls/copy.stderr.beta
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Flags`
- --> $DIR/copy.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(Clone, Copy)]
-  | |              ----- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `Flags`
- --> $DIR/copy.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(Clone, Copy)]
-  | |                     ---- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/impls/eq.rs b/vendor/bitflags/tests/compile-fail/impls/eq.rs
deleted file mode 100644
index 4abbd630..00000000
--- a/vendor/bitflags/tests/compile-fail/impls/eq.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    #[derive(PartialEq, Eq)]
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta b/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta
deleted file mode 100644
index 8a1a3b41..00000000
--- a/vendor/bitflags/tests/compile-fail/impls/eq.stderr.beta
+++ /dev/null
@@ -1,55 +0,0 @@
-error[E0119]: conflicting implementations of trait `std::cmp::PartialEq` for type `Flags`
- --> $DIR/eq.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(PartialEq, Eq)]
-  | |              --------- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::cmp::Eq` for type `Flags`
- --> $DIR/eq.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(PartialEq, Eq)]
-  | |                         -- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::StructuralPartialEq` for type `Flags`
- --> $DIR/eq.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(PartialEq, Eq)]
-  | |              --------- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::StructuralEq` for type `Flags`
- --> $DIR/eq.rs:3:1
-  |
-3 | / bitflags! {
-4 | |     #[derive(PartialEq, Eq)]
-  | |                         -- first implementation here
-5 | |     struct Flags: u32 {
-6 | |         const A = 0b00000001;
-7 | |     }
-8 | | }
-  | |_^ conflicting implementation for `Flags`
-  |
-  = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs
deleted file mode 100644
index c2856b10..00000000
--- a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use std::{
-    fmt::{
-        self,
-        Debug,
-        Display,
-        LowerHex,
-        UpperHex,
-        Octal,
-        Binary,
-    },
-    ops::{
-        BitAnd,
-        BitOr,
-        BitXor,
-        BitAndAssign,
-        BitOrAssign,
-        BitXorAssign,
-        Not,
-    },
-};
-
-use bitflags::bitflags;
-
-// Ideally we'd actually want this to work, but currently need something like `num`'s `Zero`
-// With some design work it could be made possible
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct MyInt(u8);
-
-impl BitAnd for MyInt {
-    type Output = Self;
-
-    fn bitand(self, other: Self) -> Self {
-        MyInt(self.0 & other.0)
-    }
-}
-
-impl BitOr for MyInt {
-    type Output = Self;
-
-    fn bitor(self, other: Self) -> Self {
-        MyInt(self.0 | other.0)
-    }
-}
-
-impl BitXor for MyInt {
-    type Output = Self;
-
-    fn bitxor(self, other: Self) -> Self {
-        MyInt(self.0 ^ other.0)
-    }
-}
-
-impl BitAndAssign for MyInt {
-    fn bitand_assign(&mut self, other: Self) {
-        self.0 &= other.0
-    }
-}
-
-impl BitOrAssign for MyInt {
-    fn bitor_assign(&mut self, other: Self) {
-        self.0 |= other.0
-    }
-}
-
-impl BitXorAssign for MyInt {
-    fn bitxor_assign(&mut self, other: Self) {
-        self.0 ^= other.0
-    }
-}
-
-impl Debug for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.0, f)
-    }
-}
-
-impl Display for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
-impl LowerHex for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        LowerHex::fmt(&self.0, f)
-    }
-}
-
-impl UpperHex for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        UpperHex::fmt(&self.0, f)
-    }
-}
-
-impl Octal for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Octal::fmt(&self.0, f)
-    }
-}
-
-impl Binary for MyInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Binary::fmt(&self.0, f)
-    }
-}
-
-impl Not for MyInt {
-    type Output = MyInt;
-
-    fn not(self) -> Self {
-        MyInt(!self.0)
-    }
-}
-
-bitflags! {
-    struct Flags128: MyInt {
-        const A = MyInt(0b0000_0001u8);
-        const B = MyInt(0b0000_0010u8);
-        const C = MyInt(0b0000_0100u8);
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta b/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta
deleted file mode 100644
index 1f0fb5cf..00000000
--- a/vendor/bitflags/tests/compile-fail/non_integer_base/all_defined.stderr.beta
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0308]: mismatched types
-   --> $DIR/all_defined.rs:115:1
-    |
-115 | / bitflags! {
-116 | |     struct Flags128: MyInt {
-117 | |         const A = MyInt(0b0000_0001u8);
-118 | |         const B = MyInt(0b0000_0010u8);
-119 | |         const C = MyInt(0b0000_0100u8);
-120 | |     }
-121 | | }
-    | |_^ expected struct `MyInt`, found integer
-    |
-    = note: this error originates in the macro `__impl_all_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0308]: mismatched types
-   --> $DIR/all_defined.rs:115:1
-    |
-115 | / bitflags! {
-116 | |     struct Flags128: MyInt {
-117 | |         const A = MyInt(0b0000_0001u8);
-118 | |         const B = MyInt(0b0000_0010u8);
-119 | |         const C = MyInt(0b0000_0100u8);
-120 | |     }
-121 | | }
-    | |_^ expected struct `MyInt`, found integer
-    |
-    = note: this error originates in the macro `__impl_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs
deleted file mode 100644
index fff6b2cc..00000000
--- a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use bitflags::bitflags;
-
-struct MyInt(u8);
-
-bitflags! {
-    struct Flags128: MyInt {
-        const A = MyInt(0b0000_0001);
-        const B = MyInt(0b0000_0010);
-        const C = MyInt(0b0000_0100);
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta b/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta
deleted file mode 100644
index ee95f836..00000000
--- a/vendor/bitflags/tests/compile-fail/non_integer_base/all_missing.stderr.beta
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0204]: the trait `Copy` may not be implemented for this type
-  --> $DIR/all_missing.rs:5:1
-   |
-5  | / bitflags! {
-6  | |     struct Flags128: MyInt {
-7  | |         const A = MyInt(0b0000_0001);
-8  | |         const B = MyInt(0b0000_0010);
-9  | |         const C = MyInt(0b0000_0100);
-10 | |     }
-11 | | }
-   | |_^ this field does not implement `Copy`
-   |
-   = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_field.rs b/vendor/bitflags/tests/compile-fail/visibility/private_field.rs
deleted file mode 100644
index a6a3912a..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/private_field.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod example {
-    use bitflags::bitflags;
-
-    bitflags! {
-        pub struct Flags1: u32 {
-            const FLAG_A = 0b00000001;
-        }
-    }
-}
-
-fn main() {
-    let flag1 = example::Flags1::FLAG_A.bits;
-}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta
deleted file mode 100644
index 58a04660..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/private_field.stderr.beta
+++ /dev/null
@@ -1,10 +0,0 @@
-error[E0616]: field `bits` of struct `Flags1` is private
-  --> $DIR/private_field.rs:12:41
-   |
-12 |     let flag1 = example::Flags1::FLAG_A.bits;
-   |                                         ^^^^ private field
-   |
-help: a method `bits` also exists, call it with parentheses
-   |
-12 |     let flag1 = example::Flags1::FLAG_A.bits();
-   |                                             ^^
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs b/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs
deleted file mode 100644
index 85a5b186..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/private_flags.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-mod example {
-    use bitflags::bitflags;
-
-    bitflags! {
-        pub struct Flags1: u32 {
-            const FLAG_A = 0b00000001;
-        }
-
-        struct Flags2: u32 {
-            const FLAG_B = 0b00000010;
-        }
-    }
-}
-
-fn main() {
-    let flag1 = example::Flags1::FLAG_A;
-    let flag2 = example::Flags2::FLAG_B;
-}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta
deleted file mode 100644
index d23f8320..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/private_flags.stderr.beta
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0603]: struct `Flags2` is private
-  --> $DIR/private_flags.rs:17:26
-   |
-17 |     let flag2 = example::Flags2::FLAG_B;
-   |                          ^^^^^^ private struct
-   |
-note: the struct `Flags2` is defined here
-  --> $DIR/private_flags.rs:4:5
-   |
-4  | /     bitflags! {
-5  | |         pub struct Flags1: u32 {
-6  | |             const FLAG_A = 0b00000001;
-7  | |         }
-...  |
-11 | |         }
-12 | |     }
-   | |_____^
-   = note: this error originates in the macro `bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs b/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs
deleted file mode 100644
index b90f0ce9..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/pub_const.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    pub struct Flags1: u32 {
-        pub const FLAG_A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta b/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta
deleted file mode 100644
index b01122c7..00000000
--- a/vendor/bitflags/tests/compile-fail/visibility/pub_const.stderr.beta
+++ /dev/null
@@ -1,5 +0,0 @@
-error: no rules expected the token `pub`
- --> $DIR/pub_const.rs:5:9
-  |
-5 |         pub const FLAG_A = 0b00000001;
-  |         ^^^ no rules expected this token in macro call
diff --git a/vendor/bitflags/tests/compile-pass/impls/convert.rs b/vendor/bitflags/tests/compile-pass/impls/convert.rs
deleted file mode 100644
index 1f02982a..00000000
--- a/vendor/bitflags/tests/compile-pass/impls/convert.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-impl From<u32> for Flags {
-    fn from(v: u32) -> Flags {
-        Flags::from_bits_truncate(v)
-    }
-}
-
-fn main() {
-
-}
diff --git a/vendor/bitflags/tests/compile-pass/impls/default.rs b/vendor/bitflags/tests/compile-pass/impls/default.rs
deleted file mode 100644
index a97b6536..00000000
--- a/vendor/bitflags/tests/compile-pass/impls/default.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    #[derive(Default)]
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs b/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs
deleted file mode 100644
index 3052c460..00000000
--- a/vendor/bitflags/tests/compile-pass/impls/inherent_methods.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-impl Flags {
-    pub fn new() -> Flags {
-        Flags::A
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/redefinition/core.rs b/vendor/bitflags/tests/compile-pass/redefinition/core.rs
deleted file mode 100644
index 47549215..00000000
--- a/vendor/bitflags/tests/compile-pass/redefinition/core.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use bitflags::bitflags;
-
-// Checks for possible errors caused by overriding names used by `bitflags!` internally.
-
-mod core {}
-mod _core {}
-
-bitflags! {
-    struct Test: u8 {
-        const A = 1;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs b/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs
deleted file mode 100644
index b04f2f6a..00000000
--- a/vendor/bitflags/tests/compile-pass/redefinition/stringify.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use bitflags::bitflags;
-
-// Checks for possible errors caused by overriding names used by `bitflags!` internally.
-
-#[allow(unused_macros)]
-macro_rules! stringify {
-    ($($t:tt)*) => { "..." };
-}
-
-bitflags! {
-    struct Test: u8 {
-        const A = 1;
-    }
-}
-
-fn main() {
-    // Just make sure we don't call the redefined `stringify` macro
-    assert_eq!(format!("{:?}", Test::A), "A");
-}
diff --git a/vendor/bitflags/tests/compile-pass/repr/c.rs b/vendor/bitflags/tests/compile-pass/repr/c.rs
deleted file mode 100644
index 6feba36e..00000000
--- a/vendor/bitflags/tests/compile-pass/repr/c.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    #[repr(C)]
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/repr/transparent.rs b/vendor/bitflags/tests/compile-pass/repr/transparent.rs
deleted file mode 100644
index e38db4dd..00000000
--- a/vendor/bitflags/tests/compile-pass/repr/transparent.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    #[repr(transparent)]
-    struct Flags: u32 {
-        const A = 0b00000001;
-    }
-}
-
-fn main() {}
diff --git a/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs b/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs
deleted file mode 100644
index 33a7967e..00000000
--- a/vendor/bitflags/tests/compile-pass/visibility/bits_field.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
-    pub struct Flags1: u32 {
-        const FLAG_A = 0b00000001;
-    }
-}
-
-fn main() {
-    assert_eq!(0b00000001, Flags1::FLAG_A.bits);
-}
diff --git a/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs b/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs
deleted file mode 100644
index c11050e3..00000000
--- a/vendor/bitflags/tests/compile-pass/visibility/pub_in.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-mod a {
-    mod b {
-        use bitflags::bitflags;
-
-        bitflags! {
-            pub(in crate::a) struct Flags: u32 {
-                const FLAG_A = 0b00000001;
-            }
-        }
-    }
-
-    pub fn flags() -> u32 {
-        b::Flags::FLAG_A.bits()
-    }
-}
-
-fn main() {
-    assert_eq!(0b00000001, a::flags());
-}
diff --git a/vendor/bitflags/tests/compile.rs b/vendor/bitflags/tests/compile.rs
deleted file mode 100644
index ed02d01e..00000000
--- a/vendor/bitflags/tests/compile.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use std::{
-    fs,
-    ffi::OsStr,
-    io,
-    path::Path,
-};
-
-use walkdir::WalkDir;
-
-#[test]
-fn fail() {
-    prepare_stderr_files("tests/compile-fail").unwrap();
-
-    let t = trybuild::TestCases::new();
-    t.compile_fail("tests/compile-fail/**/*.rs");
-}
-
-#[test]
-fn pass() {
-    let t = trybuild::TestCases::new();
-    t.pass("tests/compile-pass/**/*.rs");
-}
-
-// Compiler messages may change between versions
-// We don't want to have to track these too closely for `bitflags`, but
-// having some message to check makes sure user-facing errors are sensical.
-// 
-// The approach we use is to run the test on all compilers, but only check stderr
-// output on beta (which is the next stable release). We do this by default ignoring
-// any `.stderr` files in the `compile-fail` directory, and copying `.stderr.beta` files
-// when we happen to be running on a beta compiler.
-fn prepare_stderr_files(path: impl AsRef<Path>) -> io::Result<()> {
-    for entry in WalkDir::new(path) {
-        let entry = entry?;
-
-        if entry.path().extension().and_then(OsStr::to_str) == Some("beta") {
-            let renamed = entry.path().with_extension("");
-
-            // Unconditionally remove a corresponding `.stderr` file for a `.stderr.beta`
-            // file if it exists. On `beta` compilers, we'll recreate it. On other compilers,
-            // we don't want to end up checking it anyways.
-            if renamed.exists() {
-                fs::remove_file(&renamed)?;
-            }
-
-            rename_beta_stderr(entry.path(), renamed)?;
-        }
-    }
-
-    Ok(())
-}
-
-#[rustversion::beta]
-fn rename_beta_stderr(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
-    fs::copy(from, to)?;
-
-    Ok(())
-}
-
-#[rustversion::not(beta)]
-fn rename_beta_stderr(_: impl AsRef<Path>, _: impl AsRef<Path>) -> io::Result<()> {
-    Ok(())
-}
diff --git a/vendor/bytemuck/.cargo-checksum.json b/vendor/bytemuck/.cargo-checksum.json
deleted file mode 100644
index 60d865af..00000000
--- a/vendor/bytemuck/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"7c8549c6fa80cd41ae7621ada77dacbe019621067299848f9db637c20bf61586","LICENSE-APACHE":"870e20c217d15bcfcbe53d7c5867cd8fac44a4ca0b41fc1eb843557e16063eba","LICENSE-MIT":"0b2d108c9c686a74ac312990ee8377902756a2a081a7af3b0f9d68abf0a8f1a1","LICENSE-ZLIB":"682b4c81b85e83ce6cc6e1ace38fdd97aeb4de0e972bd2b44aa0916c54af8c96","README.md":"0adbc44aa99089d69cdc3c9d1608524a1a9b913656ed4b0e637fc201a3ab74fc","changelog.md":"be39168557b84c812934224715184174db97274c58b54dd6b0c5e743bf96eaf0","rustfmt.toml":"f4c215534437936f924c937dbb1677f614761589300d6b389f3b518b3eb551b8","src/allocation.rs":"c5d85bc9697333a83da8dd5ac8e47471b80c7ae7eedb387564953e16024d7031","src/contiguous.rs":"867e162651b435aa0298caad1d81f46877c22c74a2766d9e79be0ab3c615ce46","src/lib.rs":"6efa427faed025a11a6ed4349649586c8773cd6b61c7f034f044ab9e5c1a7716","src/offset_of.rs":"2afd190ef0462b30ade786fe813a91e7bf41cc2fa99a1d79002cbafab5964f37","src/pod.rs":"bee5f9569b82b891d1216c62a2af27eb7df995f6eb9023d9e5119e8d0758e5d5","src/transparent.rs":"04dfa5d947a22fbd955fc0bcb93fd499161bed4bc8264e62f3dfe8a462b960a8","src/zeroable.rs":"e7b321d98d5196cb59c19be099c35ca5a88c9d0f4340328fdf926fa028957a90","tests/array_tests.rs":"98ca7a0dcd93e65f70d4db19643e707cafae5a249561ab151998cedb89b2e036","tests/cast_slice_tests.rs":"567e4de061f9ad1eeba5abac75b3395a75d5cf48b3bd1186e740ece5c8cffd1b","tests/derive.rs":"6843d5278aa8d6a53f4b4907f84e4c1d144818b954b4e69e0f8f683de7a90ec9","tests/doc_tests.rs":"eb4ce9cb167dbc1d6742b7d5c518c0636c77ce020c7cde28802d8dd67961bd15","tests/offset_of_tests.rs":"435a92c321865ddba9f29b81fc27c23f268e1dc12955a3c8b01ff2cc0c4f5615","tests/std_tests.rs":"ba0936ed2508b109bb4d3edda1294f61cda28118f511f9909dc6916be4e59207","tests/transparent.rs":"df39457958906e7708fc59d1bbc100d55701e9777424562aac2c4e70923fe6e6","tests/wrapper_forgets.rs":"c6330546f6aa696245625056e7323b3916e3fb1a9fbecefe9c9e62d3726812d9"},"package":"439989e6b8c38d1b6570a384ef1e49c8848128f5a97f3914baef02920842712f"}
\ No newline at end of file
diff --git a/vendor/bytemuck/Cargo.toml b/vendor/bytemuck/Cargo.toml
deleted file mode 100644
index 9811483f..00000000
--- a/vendor/bytemuck/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "bytemuck"
-version = "1.7.3"
-authors = ["Lokathor <zefria@gmail.com>"]
-exclude = ["/pedantic.bat"]
-description = "A crate for mucking around with piles of bytes."
-readme = "README.md"
-keywords = ["transmute", "bytes", "casting"]
-categories = ["encoding", "no-std"]
-license = "Zlib OR Apache-2.0 OR MIT"
-repository = "https://github.com/Lokathor/bytemuck"
-[package.metadata.docs.rs]
-features = ["derive", "extern_crate_alloc", "extern_crate_std", "zeroable_maybe_uninit", "min_const_generics", "wasm_simd"]
-
-[package.metadata.playground]
-features = ["derive", "extern_crate_alloc", "extern_crate_std", "zeroable_maybe_uninit", "min_const_generics", "wasm_simd"]
-[dependencies.bytemuck_derive]
-version = "1"
-optional = true
-
-[features]
-derive = ["bytemuck_derive"]
-extern_crate_alloc = []
-extern_crate_std = ["extern_crate_alloc"]
-min_const_generics = []
-nightly_portable_simd = []
-unsound_ptr_pod_impl = []
-wasm_simd = []
-zeroable_maybe_uninit = []
diff --git a/vendor/bytemuck/LICENSE-APACHE b/vendor/bytemuck/LICENSE-APACHE
deleted file mode 100644
index 1d02268d..00000000
--- a/vendor/bytemuck/LICENSE-APACHE
+++ /dev/null
@@ -1,61 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-        "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
-
-        "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
-
-        "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
-
-        "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
-
-        "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
-
-        "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
-
-        "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
-
-        "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
-
-        "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
-
-        "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
-    2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
-    3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
-    4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
-        (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
-        (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
-        (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
-        (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
-
-        You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
-    5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
-    6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
-    7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
-    8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
-    9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/bytemuck/LICENSE-MIT b/vendor/bytemuck/LICENSE-MIT
deleted file mode 100644
index 0aa88160..00000000
--- a/vendor/bytemuck/LICENSE-MIT
+++ /dev/null
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/bytemuck/LICENSE-ZLIB b/vendor/bytemuck/LICENSE-ZLIB
deleted file mode 100644
index aa2dabe6..00000000
--- a/vendor/bytemuck/LICENSE-ZLIB
+++ /dev/null
@@ -1,11 +0,0 @@
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
diff --git a/vendor/bytemuck/README.md b/vendor/bytemuck/README.md
deleted file mode 100644
index d8026e10..00000000
--- a/vendor/bytemuck/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-[![License:Zlib](https://img.shields.io/badge/License-Zlib-brightgreen.svg)](https://opensource.org/licenses/Zlib)
-![Minimum Rust Version](https://img.shields.io/badge/Min%20Rust-1.34-green.svg)
-[![crates.io](https://img.shields.io/crates/v/bytemuck.svg)](https://crates.io/crates/bytemuck)
-[![docs.rs](https://docs.rs/bytemuck/badge.svg)](https://docs.rs/bytemuck/)
-
-# bytemuck
-
-A crate for mucking around with piles of bytes.
-
-## Stability
-
-The goal is to stay at 1.y.z until _at least_ the next edition of Rust.
-
-I consider any increase of the Minimum Rust Version to be a semver breaking change,
-so `rustc-1.34` will continue to be supported for at least the rest of the
-`bytemuck-1.y.z` series of the crate.
-
-(The secret goal is to get all of this functionality into the standard library
-some day so that we don't even need to import a crate to do all this fun stuff.)
diff --git a/vendor/bytemuck/changelog.md b/vendor/bytemuck/changelog.md
deleted file mode 100644
index a5834f52..00000000
--- a/vendor/bytemuck/changelog.md
+++ /dev/null
@@ -1,161 +0,0 @@
-# `bytemuck` changelog
-
-## 1.7.3
-
-* Experimental support for the `portable_simd` language extension under the
-  `nightly_portable_simd` cargo feature. As the name implies, this is an
-  experimental crate feature and it's **not** part of the semver contract. All
-  it does is add the appropriate `Zeroable` and `Pod` impls.
-
-## 1.7.2
-
-* Why does this repo keep being hit with publishing problems? What did I do to
-  deserve this curse, Ferris? This doesn't ever happen with tinyvec or fermium,
-  only bytemuck.
-
-## 1.7.1
-
-* **Soundness Fix:** The wrap/peel methods for owned value conversion, added to
-  `TransparentWrapper` in 1.6, can cause a double-drop if used with types that
-  impl `Drop`. The fix was simply to add a `ManuallyDrop` layer around the value
-  before doing the `transmute_copy` that is used to wrap/peel. While this fix
-  could technically be backported to the 1.6 series, since 1.7 is semver
-  compatible anyway the 1.6 series has simply been yanked.
-
-## 1.7
-
-* In response to [Unsafe Code Guidelines Issue
-  #286](https://github.com/rust-lang/unsafe-code-guidelines/issues/286), this
-  version of Bytemuck has a ***Soundness-Required Breaking Change***. This is
-  "allowed" under Rust's backwards-compatibility guidelines, but it's still
-  annoying of course so we're trying to keep the damage minimal.
-  * **The Reason:** It turns out that pointer values should not have been `Pod`. More
-    specifically, `ptr as usize` is *not* the same operation as calling
-    `transmute::<_, usize>(ptr)`.
-  * LLVM has yet to fully sort out their story, but until they do, transmuting
-    pointers can cause miscompilations. They may fix things up in the future,
-    but we're not gonna just wait and have broken code in the mean time.
-  * **The Fix:** The breaking change is that the `Pod` impls for `*const T`,
-    `*mut T`, and `Option<NonNull<T>` are now gated behind the
-    `unsound_ptr_pod_impl` feature, which is off by default.
-  * You are *strongly discouraged* from using this feature, but if a dependency
-    of yours doesn't work when you upgrade to 1.7 because it relied on pointer
-    casting, then you might wish to temporarily enable the feature just to get
-    that dependency to build. Enabled features are global across all users of a
-    given semver compatible version, so if you enable the feature in your own
-    crate, your dependency will also end up getting the feature too, and then
-    it'll be able to compile.
-  * Please move away from using this feature as soon as you can. Consider it to
-    *already* be deprecated.
-  * [PR 65](https://github.com/Lokathor/bytemuck/pull/65)
-
-## 1.6.3
-
-* Small goof with an errant `;`, so [PR 69](https://github.com/Lokathor/bytemuck/pull/69)
-  *actually* got things working on SPIR-V.
-
-## 1.6.2
-
-cargo upload goof! ignore this one.
-
-## 1.6.1
-
-* [DJMcNab](https://github.com/DJMcNab) did a fix so that the crate can build for SPIR-V
-  [PR 67](https://github.com/Lokathor/bytemuck/pull/67)
-
-## 1.6
-
-* The `TransparentWrapper` trait now has more methods. More ways to wrap, and
-  now you can "peel" too! Note that we don't call it "unwrap" because that name
-  is too strongly associated with the Option/Result methods.
-  Thanks to [LU15W1R7H](https://github.com/LU15W1R7H) for doing
-  [PR 58](https://github.com/Lokathor/bytemuck/pull/58)
-* Min Const Generics! Now there's Pod and Zeroable for arrays of any size when
-  you turn on the `min_const_generics` crate feature.
-  [zakarumych](https://github.com/zakarumych) got the work started in
-  [PR 59](https://github.com/Lokathor/bytemuck/pull/59),
-  and [chorman0773](https://github.com/chorman0773) finished off the task in
-  [PR 63](https://github.com/Lokathor/bytemuck/pull/63)
-
-## 1.5.1
-
-* Fix `bytes_of` failing on zero sized types.
-  [PR 53](https://github.com/Lokathor/bytemuck/pull/53)
-
-## 1.5
-
-* Added `pod_collect_to_vec`, which will gather a slice into a vec,
-allowing you to change the pod type while also safely ignoring alignment.
-[PR 50](https://github.com/Lokathor/bytemuck/pull/50)
-
-## 1.4.2
-
-* [Kimundi](https://github.com/Kimundi) fixed an issue that could make `try_zeroed_box`
-stack overflow for large values at low optimization levels.
-[PR 43](https://github.com/Lokathor/bytemuck/pull/43)
-
-## 1.4.1
-
-* [thomcc](https://github.com/thomcc) fixed up the CI and patched over a soundness hole in `offset_of!`.
-[PR 38](https://github.com/Lokathor/bytemuck/pull/38)
-
-## 1.4
-
-* [icewind1991](https://github.com/icewind1991) has contributed the proc-macros
-  for deriving impls of `Pod`, `TransparentWrapper`, `Zeroable`!! Everyone has
-  been waiting for this one folks! It's a big deal. Just enable the `derive`
-  cargo feature and then you'll be able to derive the traits on your types. It
-  generates all the appropriate tests for you.
-* The `zeroable_maybe_uninit` feature now adds a `Zeroable` impl to the
-  `MaybeUninit` type. This is only behind a feature flag because `MaybeUninit`
-  didn't exist back in `1.34.0` (the minimum rust version of `bytemuck`).
-
-## 1.3.1
-
-* The entire crate is now available under the `Apache-2.0 OR MIT` license as
-  well as the previous `Zlib` license
-  [#24](https://github.com/Lokathor/bytemuck/pull/24).
-* [HeroicKatora](https://github.com/HeroicKatora) added the
-  `try_zeroed_slice_box` function
-  [#10](https://github.com/Lokathor/bytemuck/pull/17). `zeroed_slice_box` is
-  also available.
-* The `offset_of!` macro now supports a 2-arg version. For types that impl
-  Default, it'll just make an instance using `default` and then call over to the
-  3-arg version.
-* The `PodCastError` type now supports `Hash` and `Display`. Also if you enable
-  the `extern_crate_std` feature then it will support `std::error::Error`.
-* We now provide a `TransparentWrapper<T>` impl for `core::num::Wrapper<T>`.
-* The error type of `try_from_bytes` and `try_from_bytes_mut` when the input
-  isn't aligned has been corrected from being `AlignmentMismatch` (intended for
-  allocation casting only) to `TargetAlignmentGreaterAndInputNotAligned`.
-
-## 1.3.0
-
-* Had a bug because the CI was messed up! It wasn't soundness related, because
-  it prevented the crate from building entirely if the `extern_crate_alloc`
-  feature was used. Still, this is yanked, sorry.
-
-## 1.2.0
-
-* [thomcc](https://github.com/thomcc) added many things:
-  * A fully sound `offset_of!` macro
-    [#10](https://github.com/Lokathor/bytemuck/pull/10)
-  * A `Contiguous` trait for when you've got enums with declared values
-    all in a row [#12](https://github.com/Lokathor/bytemuck/pull/12)
-  * A `TransparentWrapper` marker trait for when you want to more clearly
-    enable adding and removing a wrapper struct to its inner value
-    [#15](https://github.com/Lokathor/bytemuck/pull/15)
-  * Now MIRI is run on CI in every single push!
-    [#16](https://github.com/Lokathor/bytemuck/pull/16)
-
-## 1.1.0
-
-* [SimonSapin](https://github.com/SimonSapin) added `from_bytes`,
-  `from_bytes_mut`, `try_from_bytes`, and `try_from_bytes_mut` ([PR
-  Link](https://github.com/Lokathor/bytemuck/pull/8))
-
-## 1.0.1
-
-* Changed to the [zlib](https://opensource.org/licenses/Zlib) license.
-* Added much more proper documentation.
-* Reduced the minimum Rust version to 1.34
diff --git a/vendor/bytemuck/rustfmt.toml b/vendor/bytemuck/rustfmt.toml
deleted file mode 100644
index a572164a..00000000
--- a/vendor/bytemuck/rustfmt.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-# Based on
-# https://github.com/rust-lang/rustfmt/blob/rustfmt-1.4.19/Configurations.md
-
-# Stable
-edition = "2018"
-fn_args_layout = "Compressed"
-max_width = 80
-tab_spaces = 2
-use_field_init_shorthand = true
-use_try_shorthand = true
-use_small_heuristics = "Max"
-
-# Unstable
-format_code_in_doc_comments = true
-imports_granularity = "Crate"
-wrap_comments = true
diff --git a/vendor/bytemuck/src/allocation.rs b/vendor/bytemuck/src/allocation.rs
deleted file mode 100644
index d2c98899..00000000
--- a/vendor/bytemuck/src/allocation.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-#![cfg(feature = "extern_crate_alloc")]
-
-//! Stuff to boost things in the `alloc` crate.
-//!
-//! * You must enable the `extern_crate_alloc` feature of `bytemuck` or you will
-//!   not be able to use this module! This is generally done by adding the
-//!   feature to the dependency in Cargo.toml like so: 
-//!   `bytemuck = { version = "VERSION_YOU_ARE_USING", features = ["extern_crate_alloc"]}`
-
-
-use super::*;
-use alloc::{
-  alloc::{alloc_zeroed, Layout},
-  boxed::Box,
-  vec,
-  vec::Vec,
-};
-use core::convert::TryInto;
-
-/// As [`try_cast_box`](try_cast_box), but unwraps for you.
-#[inline]
-pub fn cast_box<A: Pod, B: Pod>(input: Box<A>) -> Box<B> {
-  try_cast_box(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Box`](alloc::boxed::Box).
-///
-/// On failure you get back an error along with the starting `Box`.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Box` must have the exact same
-///   alignment.
-/// * The start and end size of the `Box` must have the exact same size.
-#[inline]
-pub fn try_cast_box<A: Pod, B: Pod>(
-  input: Box<A>,
-) -> Result<Box<B>, (PodCastError, Box<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    Err((PodCastError::SizeMismatch, input))
-  } else {
-    // Note(Lokathor): This is much simpler than with the Vec casting!
-    let ptr: *mut B = Box::into_raw(input) as *mut B;
-    Ok(unsafe { Box::from_raw(ptr) })
-  }
-}
-
-/// Allocates a `Box<T>` with all of the contents being zeroed out.
-///
-/// This uses the global allocator to create a zeroed allocation and _then_
-/// turns it into a Box. In other words, it's 100% assured that the zeroed data
-/// won't be put temporarily on the stack. You can make a box of any size
-/// without fear of a stack overflow.
-///
-/// ## Failure
-///
-/// This fails if the allocation fails.
-#[inline]
-pub fn try_zeroed_box<T: Zeroable>() -> Result<Box<T>, ()> {
-  if size_of::<T>() == 0 {
-    // This will not allocate but simple create a dangling slice pointer.
-    // NB: We go the way via a push to `Vec<T>` to ensure the compiler
-    // does not allocate space for T on the stack even if the branch
-    // would not be taken.
-    let mut vec = Vec::with_capacity(1);
-    vec.resize_with(1, || T::zeroed());
-    let ptr: Box<[T; 1]> = vec.into_boxed_slice().try_into().ok().unwrap();
-    debug_assert!(
-      align_of::<[T; 1]>() == align_of::<T>()
-        && size_of::<[T; 1]>() == size_of::<T>()
-    );
-    // NB: We basically do the same as in try_cast_box here:
-    let ptr: Box<T> = unsafe { Box::from_raw(Box::into_raw(ptr) as *mut _) };
-    return Ok(ptr);
-  }
-  let layout =
-    Layout::from_size_align(size_of::<T>(), align_of::<T>()).unwrap();
-  let ptr = unsafe { alloc_zeroed(layout) };
-  if ptr.is_null() {
-    // we don't know what the error is because `alloc_zeroed` is a dumb API
-    Err(())
-  } else {
-    Ok(unsafe { Box::<T>::from_raw(ptr as *mut T) })
-  }
-}
-
-/// As [`try_zeroed_box`], but unwraps for you.
-#[inline]
-pub fn zeroed_box<T: Zeroable>() -> Box<T> {
-  try_zeroed_box().unwrap()
-}
-
-/// Allocates a `Box<[T]>` with all contents being zeroed out.
-///
-/// This uses the global allocator to create a zeroed allocation and _then_
-/// turns it into a Box. In other words, it's 100% assured that the zeroed data
-/// won't be put temporarily on the stack. You can make a box of any size
-/// without fear of a stack overflow.
-///
-/// ## Failure
-///
-/// This fails if the allocation fails.
-#[inline]
-pub fn try_zeroed_slice_box<T: Zeroable>(
-  length: usize,
-) -> Result<Box<[T]>, ()> {
-  if size_of::<T>() == 0 {
-    // This will not allocate but simple create a dangling slice pointer.
-    let mut vec = Vec::with_capacity(length);
-    vec.resize_with(length, || T::zeroed());
-    return Ok(vec.into_boxed_slice());
-  }
-  if length == 0 {
-    // This will also not allocate.
-    return Ok(Vec::new().into_boxed_slice());
-  }
-  // For Pod types, the layout of the array/slice is equivalent to repeating the
-  // type.
-  let layout_length = size_of::<T>().checked_mul(length).ok_or(())?;
-  assert!(layout_length != 0);
-  let layout =
-    Layout::from_size_align(layout_length, align_of::<T>()).map_err(|_| ())?;
-  let ptr = unsafe { alloc_zeroed(layout) };
-  if ptr.is_null() {
-    // we don't know what the error is because `alloc_zeroed` is a dumb API
-    Err(())
-  } else {
-    let slice =
-      unsafe { core::slice::from_raw_parts_mut(ptr as *mut T, length) };
-    Ok(unsafe { Box::<[T]>::from_raw(slice) })
-  }
-}
-
-/// As [`try_zeroed_slice_box`](try_zeroed_slice_box), but unwraps for you.
-pub fn zeroed_slice_box<T: Zeroable>(length: usize) -> Box<[T]> {
-  try_zeroed_slice_box(length).unwrap()
-}
-
-/// As [`try_cast_vec`](try_cast_vec), but unwraps for you.
-#[inline]
-pub fn cast_vec<A: Pod, B: Pod>(input: Vec<A>) -> Vec<B> {
-  try_cast_vec(input).map_err(|(e, _v)| e).unwrap()
-}
-
-/// Attempts to cast the content type of a [`Vec`](alloc::vec::Vec).
-///
-/// On failure you get back an error along with the starting `Vec`.
-///
-/// ## Failure
-///
-/// * The start and end content type of the `Vec` must have the exact same
-///   alignment.
-/// * The start and end size of the `Vec` must have the exact same size.
-/// * In the future this second restriction might be lessened by having the
-///   capacity and length get adjusted during transmutation, but for now it's
-///   absolute.
-#[inline]
-pub fn try_cast_vec<A: Pod, B: Pod>(
-  input: Vec<A>,
-) -> Result<Vec<B>, (PodCastError, Vec<A>)> {
-  if align_of::<A>() != align_of::<B>() {
-    Err((PodCastError::AlignmentMismatch, input))
-  } else if size_of::<A>() != size_of::<B>() {
-    // Note(Lokathor): Under some conditions it would be possible to cast
-    // between Vec content types of the same alignment but different sizes by
-    // changing the capacity and len values in the output Vec. However, we will
-    // not attempt that for now.
-    Err((PodCastError::SizeMismatch, input))
-  } else {
-    // Note(Lokathor): First we record the length and capacity, which don't have
-    // any secret provenance metadata.
-    let length: usize = input.len();
-    let capacity: usize = input.capacity();
-    // Note(Lokathor): Next we "pre-forget" the old Vec by wrapping with
-    // ManuallyDrop, because if we used `core::mem::forget` after taking the
-    // pointer then that would invalidate our pointer. In nightly there's a
-    // "into raw parts" method, which we can switch this too eventually.
-    let mut manual_drop_vec = ManuallyDrop::new(input);
-    let vec_ptr: *mut A = manual_drop_vec.as_mut_ptr();
-    let ptr: *mut B = vec_ptr as *mut B;
-    Ok(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
-  }
-}
-
-/// This "collects" a slice of pod data into a vec of a different pod type.
-///
-/// Unlike with [`cast_slice`] and [`cast_slice_mut`], this will always work.
-///
-/// The output vec will be of a minimal size/capacity to hold the slice given.
-///
-/// ```rust
-/// # use bytemuck::*;
-/// let halfwords: [u16; 4] = [5, 6, 7, 8];
-/// let vec_of_words: Vec<u32> = pod_collect_to_vec(&halfwords);
-/// if cfg!(target_endian = "little") {
-///   assert_eq!(&vec_of_words[..], &[0x0006_0005, 0x0008_0007][..])
-/// } else {
-///   assert_eq!(&vec_of_words[..], &[0x0005_0006, 0x0007_0008][..])
-/// }
-/// ```
-pub fn pod_collect_to_vec<A: Pod, B: Pod>(src: &[A]) -> Vec<B> {
-  let src_size = size_of_val(src);
-  // Note(Lokathor): dst_count is rounded up so that the dest will always be at
-  // least as many bytes as the src.
-  let dst_count = src_size / size_of::<B>()
-    + if src_size % size_of::<B>() != 0 { 1 } else { 0 };
-  let mut dst = vec![B::zeroed(); dst_count];
-
-  let src_bytes: &[u8] = cast_slice(src);
-  let dst_bytes: &mut [u8] = cast_slice_mut(&mut dst[..]);
-  dst_bytes[..src_size].copy_from_slice(src_bytes);
-  dst
-}
diff --git a/vendor/bytemuck/src/contiguous.rs b/vendor/bytemuck/src/contiguous.rs
deleted file mode 100644
index f84a6124..00000000
--- a/vendor/bytemuck/src/contiguous.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-use super::*;
-
-/// A trait indicating that:
-///
-/// 1. A type has an equivalent representation to some known integral type.
-/// 2. All instances of this type fall in a fixed range of values.
-/// 3. Within that range, there are no gaps.
-///
-/// This is generally useful for fieldless enums (aka "c-style" enums), however
-/// it's important that it only be used for those with an explicit `#[repr]`, as
-/// `#[repr(Rust)]` fieldess enums have an unspecified layout.
-///
-/// Additionally, you shouldn't assume that all implementations are enums. Any
-/// type which meets the requirements above while following the rules under
-/// "Safety" below is valid.
-///
-/// # Example
-///
-/// ```
-/// # use bytemuck::Contiguous;
-/// #[repr(u8)]
-/// #[derive(Debug, Copy, Clone, PartialEq)]
-/// enum Foo {
-///   A = 0,
-///   B = 1,
-///   C = 2,
-///   D = 3,
-///   E = 4,
-/// }
-/// unsafe impl Contiguous for Foo {
-///   type Int = u8;
-///   const MIN_VALUE: u8 = Foo::A as u8;
-///   const MAX_VALUE: u8 = Foo::E as u8;
-/// }
-/// assert_eq!(Foo::from_integer(3).unwrap(), Foo::D);
-/// assert_eq!(Foo::from_integer(8), None);
-/// assert_eq!(Foo::C.into_integer(), 2);
-/// ```
-/// # Safety
-///
-/// This is an unsafe trait, and incorrectly implementing it is undefined
-/// behavior.
-///
-/// Informally, by implementing it, you're asserting that `C` is identical to
-/// the integral type `C::Int`, and that every `C` falls between `C::MIN_VALUE`
-/// and `C::MAX_VALUE` exactly once, without any gaps.
-///
-/// Precisely, the guarantees you must uphold when implementing `Contiguous` for
-/// some type `C` are:
-///
-/// 1. The size of `C` and `C::Int` must be the same, and neither may be a ZST.
-///    (Note: alignment is explicitly allowed to differ)
-///
-/// 2. `C::Int` must be a primitive integer, and not a wrapper type. In the
-///    future, this may be lifted to include cases where the behavior is
-///    identical for a relevant set of traits (Ord, arithmetic, ...).
-///
-/// 3. All `C::Int`s which are in the *inclusive* range between `C::MIN_VALUE`
-///    and `C::MAX_VALUE` are bitwise identical to unique valid instances of
-///    `C`.
-///
-/// 4. There exist no instances of `C` such that their bitpatterns, when
-///    interpreted as instances of `C::Int`, fall outside of the `MAX_VALUE` /
-///    `MIN_VALUE` range -- It is legal for unsafe code to assume that if it
-///    gets a `C` that implements `Contiguous`, it is in the appropriate range.
-///
-/// 5. Finally, you promise not to provide overridden implementations of
-///    `Contiguous::from_integer` and `Contiguous::into_integer`.
-///
-/// For clarity, the following rules could be derived from the above, but are
-/// listed explicitly:
-///
-/// - `C::MAX_VALUE` must be greater or equal to `C::MIN_VALUE` (therefore, `C`
-///   must be an inhabited type).
-///
-/// - There exist no two values between `MIN_VALUE` and `MAX_VALUE` such that
-///   when interpreted as a `C` they are considered identical (by, say, match).
-pub unsafe trait Contiguous: Copy + 'static {
-  /// The primitive integer type with an identical representation to this
-  /// type.
-  ///
-  /// Contiguous is broadly intended for use with fieldless enums, and for
-  /// these the correct integer type is easy: The enum should have a
-  /// `#[repr(Int)]` or `#[repr(C)]` attribute, (if it does not, it is
-  /// *unsound* to implement `Contiguous`!).
-  ///
-  /// - For `#[repr(Int)]`, use the listed `Int`. e.g. `#[repr(u8)]` should use
-  ///   `type Int = u8`.
-  ///
-  /// - For `#[repr(C)]`, use whichever type the C compiler will use to
-  ///   represent the given enum. This is usually `c_int` (from `std::os::raw`
-  ///   or `libc`), but it's up to you to make the determination as the
-  ///   implementer of the unsafe trait.
-  ///
-  /// For precise rules, see the list under "Safety" above.
-  type Int: Copy + Ord;
-
-  /// The upper *inclusive* bound for valid instances of this type.
-  const MAX_VALUE: Self::Int;
-
-  /// The lower *inclusive* bound for valid instances of this type.
-  const MIN_VALUE: Self::Int;
-
-  /// If `value` is within the range for valid instances of this type,
-  /// returns `Some(converted_value)`, otherwise, returns `None`.
-  ///
-  /// This is a trait method so that you can write `value.into_integer()` in
-  /// your code. It is a contract of this trait that if you implement
-  /// `Contiguous` on your type you **must not** override this method.
-  ///
-  /// # Panics
-  ///
-  /// We will not panic for any correct implementation of `Contiguous`, but
-  /// *may* panic if we detect an incorrect one.
-  ///
-  /// This is undefined behavior regardless, so it could have been the nasal
-  /// demons at that point anyway ;).
-  #[inline]
-  fn from_integer(value: Self::Int) -> Option<Self> {
-    // Guard against an illegal implementation of Contiguous. Annoyingly we
-    // can't rely on `transmute` to do this for us (see below), but
-    // whatever, this gets compiled into nothing in release.
-    assert!(size_of::<Self>() == size_of::<Self::Int>());
-    if Self::MIN_VALUE <= value && value <= Self::MAX_VALUE {
-      // SAFETY: We've checked their bounds (and their size, even though
-      // they've sworn under the Oath Of Unsafe Rust that that already
-      // matched) so this is allowed by `Contiguous`'s unsafe contract.
-      //
-      // So, the `transmute!`. ideally we'd use transmute here, which
-      // is more obviously safe. Sadly, we can't, as these types still
-      // have unspecified sizes.
-      Some(unsafe { transmute!(value) })
-    } else {
-      None
-    }
-  }
-
-  /// Perform the conversion from `C` into the underlying integral type. This
-  /// mostly exists otherwise generic code would need unsafe for the `value as
-  /// integer`
-  ///
-  /// This is a trait method so that you can write `value.into_integer()` in
-  /// your code. It is a contract of this trait that if you implement
-  /// `Contiguous` on your type you **must not** override this method.
-  ///
-  /// # Panics
-  ///
-  /// We will not panic for any correct implementation of `Contiguous`, but
-  /// *may* panic if we detect an incorrect one.
-  ///
-  /// This is undefined behavior regardless, so it could have been the nasal
-  /// demons at that point anyway ;).
-  #[inline]
-  fn into_integer(self) -> Self::Int {
-    // Guard against an illegal implementation of Contiguous. Annoyingly we
-    // can't rely on `transmute` to do the size check for us (see
-    // `from_integer's comment`), but whatever, this gets compiled into
-    // nothing in release. Note that we don't check the result of cast
-    assert!(size_of::<Self>() == size_of::<Self::Int>());
-
-    // SAFETY: The unsafe contract requires that these have identical
-    // representations, and that the range be entirely valid. Using
-    // transmute! instead of transmute here is annoying, but is required
-    // as `Self` and `Self::Int` have unspecified sizes still.
-    unsafe { transmute!(self) }
-  }
-}
-
-macro_rules! impl_contiguous {
-  ($($src:ty as $repr:ident in [$min:expr, $max:expr];)*) => {$(
-    unsafe impl Contiguous for $src {
-      type Int = $repr;
-      const MAX_VALUE: $repr = $max;
-      const MIN_VALUE: $repr = $min;
-    }
-  )*};
-}
-
-impl_contiguous! {
-  bool as u8 in [0, 1];
-
-  u8 as u8 in [0, u8::max_value()];
-  u16 as u16 in [0, u16::max_value()];
-  u32 as u32 in [0, u32::max_value()];
-  u64 as u64 in [0, u64::max_value()];
-  u128 as u128 in [0, u128::max_value()];
-  usize as usize in [0, usize::max_value()];
-
-  i8 as i8 in [i8::min_value(), i8::max_value()];
-  i16 as i16 in [i16::min_value(), i16::max_value()];
-  i32 as i32 in [i32::min_value(), i32::max_value()];
-  i64 as i64 in [i64::min_value(), i64::max_value()];
-  i128 as i128 in [i128::min_value(), i128::max_value()];
-  isize as isize in [isize::min_value(), isize::max_value()];
-
-  NonZeroU8 as u8 in [1, u8::max_value()];
-  NonZeroU16 as u16 in [1, u16::max_value()];
-  NonZeroU32 as u32 in [1, u32::max_value()];
-  NonZeroU64 as u64 in [1, u64::max_value()];
-  NonZeroU128 as u128 in [1, u128::max_value()];
-  NonZeroUsize as usize in [1, usize::max_value()];
-}
diff --git a/vendor/bytemuck/src/lib.rs b/vendor/bytemuck/src/lib.rs
deleted file mode 100644
index 42d901e2..00000000
--- a/vendor/bytemuck/src/lib.rs
+++ /dev/null
@@ -1,471 +0,0 @@
-#![no_std]
-#![warn(missing_docs)]
-#![cfg_attr(feature = "nightly_portable_simd", feature(portable_simd))]
-
-//! This crate gives small utilities for casting between plain data types.
-//!
-//! ## Basics
-//!
-//! Data comes in five basic forms in Rust, so we have five basic casting
-//! functions:
-//!
-//! * `T` uses [`cast`]
-//! * `&T` uses [`cast_ref`]
-//! * `&mut T` uses [`cast_mut`]
-//! * `&[T]` uses [`cast_slice`]
-//! * `&mut [T]` uses [`cast_slice_mut`]
-//!
-//! Some casts will never fail (eg: `cast::<u32, f32>` always works), other
-//! casts might fail (eg: `cast_ref::<[u8; 4], u32>` will fail if the reference
-//! isn't already aligned to 4). Each casting function has a "try" version which
-//! will return a `Result`, and the "normal" version which will simply panic on
-//! invalid input.
-//!
-//! ## Using Your Own Types
-//!
-//! All the functions here are guarded by the [`Pod`] trait, which is a
-//! sub-trait of the [`Zeroable`] trait.
-//!
-//! If you're very sure that your type is eligible, you can implement those
-//! traits for your type and then they'll have full casting support. However,
-//! these traits are `unsafe`, and you should carefully read the requirements
-//! before adding the them to your own types.
-//!
-//! ## Features
-//!
-//! * This crate is core only by default, but if you're using Rust 1.36 or later
-//!   you can enable the `extern_crate_alloc` cargo feature for some additional
-//!   methods related to `Box` and `Vec`. Note that the `docs.rs` documentation
-//!   is always built with `extern_crate_alloc` cargo feature enabled.
-
-#[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-use core::arch::wasm32;
-#[cfg(target_arch = "x86")]
-use core::arch::x86;
-#[cfg(target_arch = "x86_64")]
-use core::arch::x86_64;
-//
-use core::{marker::*, mem::*, num::*, ptr::*};
-
-// Used from macros to ensure we aren't using some locally defined name and
-// actually are referencing libcore. This also would allow pre-2018 edition
-// crates to use our macros, but I'm not sure how important that is.
-#[doc(hidden)]
-pub use ::core as __core;
-
-#[cfg(not(feature = "min_const_generics"))]
-macro_rules! impl_unsafe_marker_for_array {
-  ( $marker:ident , $( $n:expr ),* ) => {
-    $(unsafe impl<T> $marker for [T; $n] where T: $marker {})*
-  }
-}
-
-/// A macro to transmute between two types without requiring knowing size
-/// statically.
-macro_rules! transmute {
-  ($val:expr) => {
-    transmute_copy(&ManuallyDrop::new($val))
-  };
-}
-
-#[cfg(feature = "extern_crate_std")]
-extern crate std;
-
-#[cfg(feature = "extern_crate_alloc")]
-extern crate alloc;
-#[cfg(feature = "extern_crate_alloc")]
-pub mod allocation;
-#[cfg(feature = "extern_crate_alloc")]
-pub use allocation::*;
-
-mod zeroable;
-pub use zeroable::*;
-
-mod pod;
-pub use pod::*;
-
-mod contiguous;
-pub use contiguous::*;
-
-mod offset_of;
-pub use offset_of::*;
-
-mod transparent;
-pub use transparent::*;
-
-#[cfg(feature = "derive")]
-pub use bytemuck_derive::{Contiguous, Pod, TransparentWrapper, Zeroable};
-
-/*
-
-Note(Lokathor): We've switched all of the `unwrap` to `match` because there is
-apparently a bug: https://github.com/rust-lang/rust/issues/68667
-and it doesn't seem to show up in simple godbolt examples but has been reported
-as having an impact when there's a cast mixed in with other more complicated
-code around it. Rustc/LLVM ends up missing that the `Err` can't ever happen for
-particular type combinations, and then it doesn't fully eliminated the panic
-possibility code branch.
-
-*/
-
-/// Immediately panics.
-#[cold]
-#[inline(never)]
-fn something_went_wrong(_src: &str, _err: PodCastError) -> ! {
-  // Note(Lokathor): Keeping the panic here makes the panic _formatting_ go
-  // here too, which helps assembly readability and also helps keep down
-  // the inline pressure.
-  #[cfg(not(target_arch = "spirv"))]
-  panic!("{src}>{err:?}", src = _src, err = _err);
-  // Note: On the spirv targets from [rust-gpu](https://github.com/EmbarkStudios/rust-gpu)
-  // panic formatting cannot be used. We we just give a generic error message
-  // The chance that the panicking version of these functions will ever get
-  // called on spir-v targets with invalid inputs is small, but giving a
-  // simple error message is better than no error message at all.
-  #[cfg(target_arch = "spirv")]
-  panic!("Called a panicing helper from bytemuck which paniced");
-}
-
-/// Re-interprets `&T` as `&[u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline]
-pub fn bytes_of<T: Pod>(t: &T) -> &[u8] {
-  if size_of::<T>() == 0 {
-    &[]
-  } else {
-    match try_cast_slice::<T, u8>(core::slice::from_ref(t)) {
-      Ok(s) => s,
-      Err(_) => unreachable!(),
-    }
-  }
-}
-
-/// Re-interprets `&mut T` as `&mut [u8]`.
-///
-/// Any ZST becomes an empty slice, and in that case the pointer value of that
-/// empty slice might not match the pointer value of the input reference.
-#[inline]
-pub fn bytes_of_mut<T: Pod>(t: &mut T) -> &mut [u8] {
-  if size_of::<T>() == 0 {
-    &mut []
-  } else {
-    match try_cast_slice_mut::<T, u8>(core::slice::from_mut(t)) {
-      Ok(s) => s,
-      Err(_) => unreachable!(),
-    }
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes`] but will panic on error.
-#[inline]
-pub fn from_bytes<T: Pod>(s: &[u8]) -> &T {
-  match try_from_bytes(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes", e),
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes_mut`] but will panic on error.
-#[inline]
-pub fn from_bytes_mut<T: Pod>(s: &mut [u8]) -> &mut T {
-  match try_from_bytes_mut(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes_mut", e),
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub fn try_from_bytes<T: Pod>(s: &[u8]) -> Result<&T, PodCastError> {
-  if s.len() != size_of::<T>() {
-    Err(PodCastError::SizeMismatch)
-  } else if (s.as_ptr() as usize) % align_of::<T>() != 0 {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else {
-    Ok(unsafe { &*(s.as_ptr() as *const T) })
-  }
-}
-
-/// Re-interprets `&mut [u8]` as `&mut T`.
-///
-/// ## Failure
-///
-/// * If the slice isn't aligned for the new type
-/// * If the slice's length isn’t exactly the size of the new type
-#[inline]
-pub fn try_from_bytes_mut<T: Pod>(
-  s: &mut [u8],
-) -> Result<&mut T, PodCastError> {
-  if s.len() != size_of::<T>() {
-    Err(PodCastError::SizeMismatch)
-  } else if (s.as_ptr() as usize) % align_of::<T>() != 0 {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else {
-    Ok(unsafe { &mut *(s.as_mut_ptr() as *mut T) })
-  }
-}
-
-/// The things that can go wrong when casting between [`Pod`] data forms.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum PodCastError {
-  /// You tried to cast a slice to an element type with a higher alignment
-  /// requirement but the slice wasn't aligned.
-  TargetAlignmentGreaterAndInputNotAligned,
-  /// If the element size changes then the output slice changes length
-  /// accordingly. If the output slice wouldn't be a whole number of elements
-  /// then the conversion fails.
-  OutputSliceWouldHaveSlop,
-  /// When casting a slice you can't convert between ZST elements and non-ZST
-  /// elements. When casting an individual `T`, `&T`, or `&mut T` value the
-  /// source size and destination size must be an exact match.
-  SizeMismatch,
-  /// For this type of cast the alignments must be exactly the same and they
-  /// were not so now you're sad.
-  ///
-  /// This error is generated **only** by operations that cast allocated types
-  /// (such as `Box` and `Vec`), because in that case the alignment must stay
-  /// exact.
-  AlignmentMismatch,
-}
-#[cfg(not(target_arch = "spirv"))]
-impl core::fmt::Display for PodCastError {
-  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-    write!(f, "{:?}", self)
-  }
-}
-#[cfg(feature = "extern_crate_std")]
-impl std::error::Error for PodCastError {}
-
-/// Cast `T` into `U`
-///
-/// ## Panics
-///
-/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch.
-#[inline]
-pub fn cast<A: Pod, B: Pod>(a: A) -> B {
-  if size_of::<A>() == size_of::<B>() {
-    unsafe { transmute!(a) }
-  } else {
-    something_went_wrong("cast", PodCastError::SizeMismatch)
-  }
-}
-
-/// Cast `&mut T` into `&mut U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_mut`] but will panic on error.
-#[inline]
-pub fn cast_mut<A: Pod, B: Pod>(a: &mut A) -> &mut B {
-  if size_of::<A>() == size_of::<B>() && align_of::<A>() >= align_of::<B>() {
-    // Plz mr compiler, just notice that we can't ever hit Err in this case.
-    match try_cast_mut(a) {
-      Ok(b) => b,
-      Err(_) => unreachable!(),
-    }
-  } else {
-    match try_cast_mut(a) {
-      Ok(b) => b,
-      Err(e) => something_went_wrong("cast_mut", e),
-    }
-  }
-}
-
-/// Cast `&T` into `&U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_ref`] but will panic on error.
-#[inline]
-pub fn cast_ref<A: Pod, B: Pod>(a: &A) -> &B {
-  if size_of::<A>() == size_of::<B>() && align_of::<A>() >= align_of::<B>() {
-    // Plz mr compiler, just notice that we can't ever hit Err in this case.
-    match try_cast_ref(a) {
-      Ok(b) => b,
-      Err(_) => unreachable!(),
-    }
-  } else {
-    match try_cast_ref(a) {
-      Ok(b) => b,
-      Err(e) => something_went_wrong("cast_ref", e),
-    }
-  }
-}
-
-/// Cast `&[A]` into `&[B]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice`] but will panic on error.
-#[inline]
-pub fn cast_slice<A: Pod, B: Pod>(a: &[A]) -> &[B] {
-  match try_cast_slice(a) {
-    Ok(b) => b,
-    Err(e) => something_went_wrong("cast_slice", e),
-  }
-}
-
-/// Cast `&mut [T]` into `&mut [U]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice_mut`] but will panic on error.
-#[inline]
-pub fn cast_slice_mut<A: Pod, B: Pod>(a: &mut [A]) -> &mut [B] {
-  match try_cast_slice_mut(a) {
-    Ok(b) => b,
-    Err(e) => something_went_wrong("cast_slice_mut", e),
-  }
-}
-
-/// As `align_to`, but safe because of the [`Pod`] bound.
-#[inline]
-pub fn pod_align_to<T: Pod, U: Pod>(vals: &[T]) -> (&[T], &[U], &[T]) {
-  unsafe { vals.align_to::<U>() }
-}
-
-/// As `align_to_mut`, but safe because of the [`Pod`] bound.
-#[inline]
-pub fn pod_align_to_mut<T: Pod, U: Pod>(
-  vals: &mut [T],
-) -> (&mut [T], &mut [U], &mut [T]) {
-  unsafe { vals.align_to_mut::<U>() }
-}
-
-/// Try to cast `T` into `U`.
-///
-/// Note that for this particular type of cast, alignment isn't a factor. The
-/// input value is semantically copied into the function and then returned to a
-/// new memory location which will have whatever the required alignment of the
-/// output type is.
-///
-/// ## Failure
-///
-/// * If the types don't have the same size this fails.
-#[inline]
-pub fn try_cast<A: Pod, B: Pod>(a: A) -> Result<B, PodCastError> {
-  if size_of::<A>() == size_of::<B>() {
-    Ok(unsafe { transmute!(a) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert a `&T` into `&U`.
-///
-/// ## Failure
-///
-/// * If the reference isn't aligned in the new type
-/// * If the source type and target type aren't the same size.
-#[inline]
-pub fn try_cast_ref<A: Pod, B: Pod>(a: &A) -> Result<&B, PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && (a as *const A as usize) % align_of::<B>() != 0
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { &*(a as *const A as *const B) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert a `&mut T` into `&mut U`.
-///
-/// As [`try_cast_ref`], but `mut`.
-#[inline]
-pub fn try_cast_mut<A: Pod, B: Pod>(a: &mut A) -> Result<&mut B, PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && (a as *mut A as usize) % align_of::<B>() != 0
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { &mut *(a as *mut A as *mut B) })
-  } else {
-    Err(PodCastError::SizeMismatch)
-  }
-}
-
-/// Try to convert `&[A]` into `&[B]` (possibly with a change in length).
-///
-/// * `input.as_ptr() as usize == output.as_ptr() as usize`
-/// * `input.len() * size_of::<A>() == output.len() * size_of::<B>()`
-///
-/// ## Failure
-///
-/// * If the target type has a greater alignment requirement and the input slice
-///   isn't aligned.
-/// * If the target element type is a different size from the current element
-///   type, and the output slice wouldn't be a whole number of elements when
-///   accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so
-///   that's a failure).
-/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts)
-///   and a non-ZST.
-#[inline]
-pub fn try_cast_slice<A: Pod, B: Pod>(a: &[A]) -> Result<&[B], PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && (a.as_ptr() as usize) % align_of::<B>() != 0
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, a.len()) })
-  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
-    Err(PodCastError::SizeMismatch)
-  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
-    let new_len = core::mem::size_of_val(a) / size_of::<B>();
-    Ok(unsafe { core::slice::from_raw_parts(a.as_ptr() as *const B, new_len) })
-  } else {
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  }
-}
-
-/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in
-/// length).
-///
-/// As [`try_cast_slice`], but `&mut`.
-#[inline]
-pub fn try_cast_slice_mut<A: Pod, B: Pod>(
-  a: &mut [A],
-) -> Result<&mut [B], PodCastError> {
-  // Note(Lokathor): everything with `align_of` and `size_of` will optimize away
-  // after monomorphization.
-  if align_of::<B>() > align_of::<A>()
-    && (a.as_mut_ptr() as usize) % align_of::<B>() != 0
-  {
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  } else if size_of::<B>() == size_of::<A>() {
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, a.len())
-    })
-  } else if size_of::<A>() == 0 || size_of::<B>() == 0 {
-    Err(PodCastError::SizeMismatch)
-  } else if core::mem::size_of_val(a) % size_of::<B>() == 0 {
-    let new_len = core::mem::size_of_val(a) / size_of::<B>();
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(a.as_mut_ptr() as *mut B, new_len)
-    })
-  } else {
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  }
-}
diff --git a/vendor/bytemuck/src/offset_of.rs b/vendor/bytemuck/src/offset_of.rs
deleted file mode 100644
index 3de23276..00000000
--- a/vendor/bytemuck/src/offset_of.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-#![forbid(unsafe_code)]
-
-/// Find the offset in bytes of the given `$field` of `$Type`. Requires an
-/// already initialized `$instance` value to work with.
-///
-/// This is similar to the macro from [`memoffset`](https://docs.rs/memoffset),
-/// however it uses no `unsafe` code.
-///
-/// This macro has a 3-argument and 2-argument version.
-/// * In the 3-arg version you specify an instance of the type, the type itself,
-///   and the field name.
-/// * In the 2-arg version the macro will call the [`default`](Default::default)
-///   method to make a temporary instance of the type for you.
-///
-/// The output of this macro is the byte offset of the field (as a `usize`). The
-/// calculations of the macro are fixed across the entire program, but if the
-/// type used is `repr(Rust)` then they're *not* fixed across compilations or
-/// compilers.
-///
-/// ## Examples
-///
-/// ### 3-arg Usage
-///
-/// ```rust
-/// # use bytemuck::offset_of;
-/// // enums can't derive default, and for this example we don't pick one
-/// enum MyExampleEnum {
-///   A,
-///   B,
-///   C,
-/// }
-///
-/// // so now our struct here doesn't have Default
-/// #[repr(C)]
-/// struct MyNotDefaultType {
-///   pub counter: i32,
-///   pub some_field: MyExampleEnum,
-/// }
-///
-/// // but we provide an instance of the type and it's all good.
-/// let val = MyNotDefaultType { counter: 5, some_field: MyExampleEnum::A };
-/// assert_eq!(offset_of!(val, MyNotDefaultType, some_field), 4);
-/// ```
-///
-/// ### 2-arg Usage
-///
-/// ```rust
-/// # use bytemuck::offset_of;
-/// #[derive(Default)]
-/// #[repr(C)]
-/// struct Vertex {
-///   pub loc: [f32; 3],
-///   pub color: [f32; 3],
-/// }
-/// // if the type impls Default the macro can make its own default instance.
-/// assert_eq!(offset_of!(Vertex, loc), 0);
-/// assert_eq!(offset_of!(Vertex, color), 12);
-/// ```
-///
-/// # Usage with `#[repr(packed)]` structs
-///
-/// Attempting to compute the offset of a `#[repr(packed)]` struct with
-/// `bytemuck::offset_of!` requires an `unsafe` block. We hope to relax this in
-/// the future, but currently it is required to work around a soundness hole in
-/// Rust (See [rust-lang/rust#27060]).
-///
-/// [rust-lang/rust#27060]: https://github.com/rust-lang/rust/issues/27060
-///
-/// <p style="background:rgba(255,181,77,0.16);padding:0.75em;">
-/// <strong>Warning:</strong> This is only true for versions of bytemuck >
-/// 1.4.0. Previous versions of
-/// <code style="background:rgba(41,24,0,0.1);">bytemuck::offset_of!</code>
-/// will only emit a warning when used on the field of a packed struct in safe
-/// code, which can lead to unsoundness.
-/// </p>
-///
-/// For example, the following will fail to compile:
-///
-/// ```compile_fail
-/// #[repr(C, packed)]
-/// #[derive(Default)]
-/// struct Example {
-///   field: u32,
-/// }
-/// // Doesn't compile:
-/// let _offset = bytemuck::offset_of!(Example, field);
-/// ```
-///
-/// While the error message this generates will mention the
-/// `safe_packed_borrows` lint, the macro will still fail to compile even if
-/// that lint is `#[allow]`ed:
-///
-/// ```compile_fail
-/// # #[repr(C, packed)] #[derive(Default)] struct Example { field: u32 }
-/// // Still doesn't compile:
-/// #[allow(safe_packed_borrows)]
-/// {
-///   let _offset = bytemuck::offset_of!(Example, field);
-/// }
-/// ```
-///
-/// This *can* be worked around by using `unsafe`, but it is only sound to do so
-/// if you can guarantee that taking a reference to the field is sound.
-///
-/// In practice, this means it only works for fields of align(1) types, or if
-/// you know the field's offset in advance (defeating the point of `offset_of`)
-/// and can prove that the struct's alignment and the field's offset are enough
-/// to prove the field's alignment.
-///
-/// Once the `raw_ref` macros are available, a future version of this crate will
-/// use them to lift the limitations of packed structs. For the duration of the
-/// `1.x` version of this crate that will be behind an on-by-default cargo
-/// feature (to maintain minimum rust version support).
-#[macro_export]
-macro_rules! offset_of {
-  ($instance:expr, $Type:path, $field:tt) => {{
-    #[forbid(safe_packed_borrows)]
-    {
-      // This helps us guard against field access going through a Deref impl.
-      #[allow(clippy::unneeded_field_pattern)]
-      let $Type { $field: _, .. };
-      let reference: &$Type = &$instance;
-      let address = reference as *const _ as usize;
-      let field_pointer = &reference.$field as *const _ as usize;
-      // These asserts/unwraps are compiled away at release, and defend against
-      // the case where somehow a deref impl is still invoked.
-      let result = field_pointer.checked_sub(address).unwrap();
-      assert!(result <= $crate::__core::mem::size_of::<$Type>());
-      result
-    }
-  }};
-  ($Type:path, $field:tt) => {{
-    $crate::offset_of!(<$Type as Default>::default(), $Type, $field)
-  }};
-}
diff --git a/vendor/bytemuck/src/pod.rs b/vendor/bytemuck/src/pod.rs
deleted file mode 100644
index 8e044366..00000000
--- a/vendor/bytemuck/src/pod.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-use super::*;
-
-/// Marker trait for "plain old data".
-///
-/// The point of this trait is that once something is marked "plain old data"
-/// you can really go to town with the bit fiddling and bit casting. Therefore,
-/// it's a relatively strong claim to make about a type. Do not add this to your
-/// type casually.
-///
-/// **Reminder:** The results of casting around bytes between data types are
-/// _endian dependant_. Little-endian machines are the most common, but
-/// big-endian machines do exist (and big-endian is also used for "network
-/// order" bytes).
-///
-/// ## Safety
-///
-/// * The type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * The type must allow any bit pattern (eg: no `bool` or `char`, which have
-///   illegal bit patterns).
-/// * The type must not contain any padding bytes, either in the middle or on
-///   the end (eg: no `#[repr(C)] struct Foo(u8, u16)`, which has padding in the
-///   middle, and also no `#[repr(C)] struct Foo(u16, u8)`, which has padding on
-///   the end).
-/// * The type needs to have all fields also be `Pod`.
-/// * The type needs to be `repr(C)` or `repr(transparent)`. In the case of
-///   `repr(C)`, the `packed` and `align` repr modifiers can be used as long as
-///   all other rules end up being followed.
-pub unsafe trait Pod: Zeroable + Copy + 'static {}
-
-unsafe impl Pod for () {}
-unsafe impl Pod for u8 {}
-unsafe impl Pod for i8 {}
-unsafe impl Pod for u16 {}
-unsafe impl Pod for i16 {}
-unsafe impl Pod for u32 {}
-unsafe impl Pod for i32 {}
-unsafe impl Pod for u64 {}
-unsafe impl Pod for i64 {}
-unsafe impl Pod for usize {}
-unsafe impl Pod for isize {}
-unsafe impl Pod for u128 {}
-unsafe impl Pod for i128 {}
-unsafe impl Pod for f32 {}
-unsafe impl Pod for f64 {}
-unsafe impl<T: Pod> Pod for Wrapping<T> {}
-
-unsafe impl Pod for Option<NonZeroI8> {}
-unsafe impl Pod for Option<NonZeroI16> {}
-unsafe impl Pod for Option<NonZeroI32> {}
-unsafe impl Pod for Option<NonZeroI64> {}
-unsafe impl Pod for Option<NonZeroI128> {}
-unsafe impl Pod for Option<NonZeroIsize> {}
-unsafe impl Pod for Option<NonZeroU8> {}
-unsafe impl Pod for Option<NonZeroU16> {}
-unsafe impl Pod for Option<NonZeroU32> {}
-unsafe impl Pod for Option<NonZeroU64> {}
-unsafe impl Pod for Option<NonZeroU128> {}
-unsafe impl Pod for Option<NonZeroUsize> {}
-
-#[cfg(feature = "unsound_ptr_pod_impl")]
-unsafe impl<T: 'static> Pod for *mut T {}
-#[cfg(feature = "unsound_ptr_pod_impl")]
-unsafe impl<T: 'static> Pod for *const T {}
-#[cfg(feature = "unsound_ptr_pod_impl")]
-unsafe impl<T: 'static> Pod for Option<NonNull<T>> {}
-
-unsafe impl<T: Pod> Pod for PhantomData<T> {}
-unsafe impl Pod for PhantomPinned {}
-unsafe impl<T: Pod> Pod for ManuallyDrop<T> {}
-
-// Note(Lokathor): MaybeUninit can NEVER be Pod.
-
-#[cfg(feature = "min_const_generics")]
-unsafe impl<T, const N: usize> Pod for [T; N] where T: Pod {}
-
-#[cfg(not(feature = "min_const_generics"))]
-impl_unsafe_marker_for_array!(
-  Pod, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-  20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 48, 64, 96, 128, 256,
-  512, 1024, 2048, 4096
-);
-
-#[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-unsafe impl Pod for wasm32::v128 {}
-
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m128i {}
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m128 {}
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m128d {}
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m256i {}
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m256 {}
-#[cfg(target_arch = "x86")]
-unsafe impl Pod for x86::__m256d {}
-
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m128i {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m128 {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m128d {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m256i {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m256 {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Pod for x86_64::__m256d {}
-
-#[cfg(feature = "nightly_portable_simd")]
-unsafe impl<T, const N: usize> Pod for core::simd::Simd<T, N>
-where
-  T: core::simd::SimdElement + Pod,
-  core::simd::LaneCount<N>: core::simd::SupportedLaneCount,
-{
-}
diff --git a/vendor/bytemuck/src/transparent.rs b/vendor/bytemuck/src/transparent.rs
deleted file mode 100644
index 8405ad50..00000000
--- a/vendor/bytemuck/src/transparent.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-use super::*;
-
-/// A trait which indicates that a type is a `#[repr(transparent)]` wrapper
-/// around the `Inner` value.
-///
-/// This allows safely copy transmuting between the `Inner` type and the
-/// `TransparentWrapper` type. Functions like `wrap_{}` convert from the inner
-/// type to the wrapper type and `peel_{}` functions do the inverse conversion
-/// from the wrapper type to the inner type. We deliberately do not call the
-/// wrapper-removing methods "unwrap" because at this point that word is too
-/// strongly tied to the Option/ Result methods.
-///
-/// # Safety
-///
-/// The safety contract of `TransparentWrapper` is relatively simple:
-///
-/// For a given `Wrapper` which implements `TransparentWrapper<Inner>`:
-///
-/// 1. `Wrapper` must be a wrapper around `Inner` with an identical data
-///    representations. This    either means that it must be a
-///    `#[repr(transparent)]` struct which    contains a either a field of type
-///    `Inner` (or a field of some other    transparent wrapper for `Inner`) as
-///    the only non-ZST field.
-///
-/// 2. Any fields *other* than the `Inner` field must be trivially constructable
-///    ZSTs, for example `PhantomData`, `PhantomPinned`, etc.
-///
-/// 3. The `Wrapper` may not impose additional alignment requirements over
-///    `Inner`.
-///     - Note: this is currently guaranteed by `repr(transparent)`, but there
-///       have been discussions of lifting it, so it's stated here explicitly.
-///
-/// 4. All functions on `TransparentWrapper` **may not** be overridden.
-///
-/// ## Caveats
-///
-/// If the wrapper imposes additional constraints upon the inner type which are
-/// required for safety, it's responsible for ensuring those still hold -- this
-/// generally requires preventing access to instances of the inner type, as
-/// implementing `TransparentWrapper<U> for T` means anybody can call
-/// `T::cast_ref(any_instance_of_u)`.
-///
-/// For example, it would be invalid to implement TransparentWrapper for `str`
-/// to implement `TransparentWrapper` around `[u8]` because of this.
-///
-/// # Examples
-///
-/// ## Basic
-///
-/// ```
-/// use bytemuck::TransparentWrapper;
-/// # #[derive(Default)]
-/// # struct SomeStruct(u32);
-///
-/// #[repr(transparent)]
-/// struct MyWrapper(SomeStruct);
-///
-/// unsafe impl TransparentWrapper<SomeStruct> for MyWrapper {}
-///
-/// // interpret a reference to &SomeStruct as a &MyWrapper
-/// let thing = SomeStruct::default();
-/// let inner_ref: &MyWrapper = MyWrapper::wrap_ref(&thing);
-///
-/// // Works with &mut too.
-/// let mut mut_thing = SomeStruct::default();
-/// let inner_mut: &mut MyWrapper = MyWrapper::wrap_mut(&mut mut_thing);
-///
-/// # let _ = (inner_ref, inner_mut); // silence warnings
-/// ```
-///
-/// ## Use with dynamically sized types
-///
-/// ```
-/// use bytemuck::TransparentWrapper;
-///
-/// #[repr(transparent)]
-/// struct Slice<T>([T]);
-///
-/// unsafe impl<T> TransparentWrapper<[T]> for Slice<T> {}
-///
-/// let s = Slice::wrap_ref(&[1u32, 2, 3]);
-/// assert_eq!(&s.0, &[1, 2, 3]);
-///
-/// let mut buf = [1, 2, 3u8];
-/// let sm = Slice::wrap_mut(&mut buf);
-/// ```
-pub unsafe trait TransparentWrapper<Inner: ?Sized> {
-  /// Convert the inner type into the wrapper type.
-  #[inline]
-  fn wrap(s: Inner) -> Self
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    // SAFETY: The unsafe contract requires that `Self` and `Inner` have
-    // identical representations.
-    unsafe { transmute!(s) }
-  }
-
-  /// Convert a reference to the inner type into a reference to the wrapper
-  /// type.
-  #[inline]
-  fn wrap_ref(s: &Inner) -> &Self {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let inner_ptr = s as *const Inner;
-      let wrapper_ptr: *const Self = transmute!(inner_ptr);
-      &*wrapper_ptr
-    }
-  }
-
-  /// Convert a mutable reference to the inner type into a mutable reference to
-  /// the wrapper type.
-  #[inline]
-  fn wrap_mut(s: &mut Inner) -> &mut Self {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let inner_ptr = s as *mut Inner;
-      let wrapper_ptr: *mut Self = transmute!(inner_ptr);
-      &mut *wrapper_ptr
-    }
-  }
-
-  /// Convert a slice to the inner type into a slice to the wrapper type.
-  #[inline]
-  fn wrap_slice(s: &[Inner]) -> &[Self]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      assert!(align_of::<*const Inner>() == align_of::<*const Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts(s.as_ptr() as *const Self, s.len())
-    }
-  }
-
-  /// Convert a mutable slice to the inner type into a mutable slice to the
-  /// wrapper type.
-  #[inline]
-  fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      assert!(align_of::<*mut Inner>() == align_of::<*mut Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts_mut(s.as_mut_ptr() as *mut Self, s.len())
-    }
-  }
-
-  /// Convert the wrapper type into the inner type.
-  #[inline]
-  fn peel(s: Self) -> Inner
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe { transmute!(s) }
-  }
-
-  /// Convert a reference to the wrapper type into a reference to the inner
-  /// type.
-  #[inline]
-  fn peel_ref(s: &Self) -> &Inner {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let wrapper_ptr = s as *const Self;
-      let inner_ptr: *const Inner = transmute!(wrapper_ptr);
-      &*inner_ptr
-    }
-  }
-
-  /// Convert a mutable reference to the wrapper type into a mutable reference
-  /// to the inner type.
-  #[inline]
-  fn peel_mut(s: &mut Self) -> &mut Inner {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      // A pointer cast doesn't work here because rustc can't tell that
-      // the vtables match (because of the `?Sized` restriction relaxation).
-      // A `transmute` doesn't work because the sizes are unspecified.
-      //
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations.
-      let wrapper_ptr = s as *mut Self;
-      let inner_ptr: *mut Inner = transmute!(wrapper_ptr);
-      &mut *inner_ptr
-    }
-  }
-
-  /// Convert a slice to the wrapped type into a slice to the inner type.
-  #[inline]
-  fn peel_slice(s: &[Self]) -> &[Inner]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*const Inner>() == size_of::<*const Self>());
-      assert!(align_of::<*const Inner>() == align_of::<*const Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts(s.as_ptr() as *const Inner, s.len())
-    }
-  }
-
-  /// Convert a mutable slice to the wrapped type into a mutable slice to the
-  /// inner type.
-  #[inline]
-  fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]
-  where
-    Self: Sized,
-    Inner: Sized,
-  {
-    unsafe {
-      assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
-      assert!(align_of::<*mut Inner>() == align_of::<*mut Self>());
-      // SAFETY: The unsafe contract requires that these two have
-      // identical representations (size and alignment).
-      core::slice::from_raw_parts_mut(s.as_mut_ptr() as *mut Inner, s.len())
-    }
-  }
-}
-
-unsafe impl<T> TransparentWrapper<T> for core::num::Wrapping<T> {}
diff --git a/vendor/bytemuck/src/zeroable.rs b/vendor/bytemuck/src/zeroable.rs
deleted file mode 100644
index aea9028e..00000000
--- a/vendor/bytemuck/src/zeroable.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use super::*;
-
-/// Trait for types that can be safely created with
-/// [`zeroed`](core::mem::zeroed).
-///
-/// An all-zeroes value may or may not be the same value as the
-/// [Default](core::default::Default) value of the type.
-///
-/// ## Safety
-///
-/// * Your type must be inhabited (eg: no
-///   [Infallible](core::convert::Infallible)).
-/// * Your type must be allowed to be an "all zeroes" bit pattern (eg: no
-///   [`NonNull<T>`](core::ptr::NonNull)).
-pub unsafe trait Zeroable: Sized {
-  /// Calls [`zeroed`](core::mem::zeroed).
-  ///
-  /// This is a trait method so that you can write `MyType::zeroed()` in your
-  /// code. It is a contract of this trait that if you implement it on your type
-  /// you **must not** override this method.
-  #[inline]
-  fn zeroed() -> Self {
-    unsafe { core::mem::zeroed() }
-  }
-}
-unsafe impl Zeroable for () {}
-unsafe impl Zeroable for bool {}
-unsafe impl Zeroable for char {}
-unsafe impl Zeroable for u8 {}
-unsafe impl Zeroable for i8 {}
-unsafe impl Zeroable for u16 {}
-unsafe impl Zeroable for i16 {}
-unsafe impl Zeroable for u32 {}
-unsafe impl Zeroable for i32 {}
-unsafe impl Zeroable for u64 {}
-unsafe impl Zeroable for i64 {}
-unsafe impl Zeroable for usize {}
-unsafe impl Zeroable for isize {}
-unsafe impl Zeroable for u128 {}
-unsafe impl Zeroable for i128 {}
-unsafe impl Zeroable for f32 {}
-unsafe impl Zeroable for f64 {}
-unsafe impl<T: Zeroable> Zeroable for Wrapping<T> {}
-
-unsafe impl Zeroable for Option<NonZeroI8> {}
-unsafe impl Zeroable for Option<NonZeroI16> {}
-unsafe impl Zeroable for Option<NonZeroI32> {}
-unsafe impl Zeroable for Option<NonZeroI64> {}
-unsafe impl Zeroable for Option<NonZeroI128> {}
-unsafe impl Zeroable for Option<NonZeroIsize> {}
-unsafe impl Zeroable for Option<NonZeroU8> {}
-unsafe impl Zeroable for Option<NonZeroU16> {}
-unsafe impl Zeroable for Option<NonZeroU32> {}
-unsafe impl Zeroable for Option<NonZeroU64> {}
-unsafe impl Zeroable for Option<NonZeroU128> {}
-unsafe impl Zeroable for Option<NonZeroUsize> {}
-
-unsafe impl<T> Zeroable for *mut T {}
-unsafe impl<T> Zeroable for *const T {}
-unsafe impl<T> Zeroable for Option<NonNull<T>> {}
-unsafe impl<T: Zeroable> Zeroable for PhantomData<T> {}
-unsafe impl Zeroable for PhantomPinned {}
-unsafe impl<T: Zeroable> Zeroable for ManuallyDrop<T> {}
-
-#[cfg(feature = "zeroable_maybe_uninit")]
-unsafe impl<T> Zeroable for core::mem::MaybeUninit<T> {}
-
-unsafe impl<A: Zeroable> Zeroable for (A,) {}
-unsafe impl<A: Zeroable, B: Zeroable> Zeroable for (A, B) {}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable> Zeroable for (A, B, C) {}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable, D: Zeroable> Zeroable
-  for (A, B, C, D)
-{
-}
-unsafe impl<A: Zeroable, B: Zeroable, C: Zeroable, D: Zeroable, E: Zeroable>
-  Zeroable for (A, B, C, D, E)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-  > Zeroable for (A, B, C, D, E, F)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-    G: Zeroable,
-  > Zeroable for (A, B, C, D, E, F, G)
-{
-}
-unsafe impl<
-    A: Zeroable,
-    B: Zeroable,
-    C: Zeroable,
-    D: Zeroable,
-    E: Zeroable,
-    F: Zeroable,
-    G: Zeroable,
-    H: Zeroable,
-  > Zeroable for (A, B, C, D, E, F, G, H)
-{
-}
-
-#[cfg(feature = "min_const_generics")]
-unsafe impl<T, const N: usize> Zeroable for [T; N] where T: Zeroable {}
-
-#[cfg(not(feature = "min_const_generics"))]
-impl_unsafe_marker_for_array!(
-  Zeroable, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-  19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 48, 64, 96, 128, 256,
-  512, 1024, 2048, 4096
-);
-
-#[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))]
-unsafe impl Zeroable for wasm32::v128 {}
-
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m128i {}
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m128 {}
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m128d {}
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m256i {}
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m256 {}
-#[cfg(target_arch = "x86")]
-unsafe impl Zeroable for x86::__m256d {}
-
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m128i {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m128 {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m128d {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m256i {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m256 {}
-#[cfg(target_arch = "x86_64")]
-unsafe impl Zeroable for x86_64::__m256d {}
-
-#[cfg(feature = "nightly_portable_simd")]
-unsafe impl<T, const N: usize> Zeroable for core::simd::Simd<T, N>
-where
-  T: core::simd::SimdElement + Zeroable,
-  core::simd::LaneCount<N>: core::simd::SupportedLaneCount,
-{
-}
diff --git a/vendor/bytemuck/tests/array_tests.rs b/vendor/bytemuck/tests/array_tests.rs
deleted file mode 100644
index 552de08f..00000000
--- a/vendor/bytemuck/tests/array_tests.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#[test]
-pub fn test_cast_array() {
-  let x = [0u32, 1u32, 2u32];
-  let _: [u16; 6] = bytemuck::cast(x);
-}
-
-#[cfg(feature = "min_const_generics")]
-#[test]
-pub fn test_cast_long_array() {
-  let x = [0u32; 65];
-  let _: [u16; 130] = bytemuck::cast(x);
-}
diff --git a/vendor/bytemuck/tests/cast_slice_tests.rs b/vendor/bytemuck/tests/cast_slice_tests.rs
deleted file mode 100644
index fa3b1446..00000000
--- a/vendor/bytemuck/tests/cast_slice_tests.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use core::mem::size_of;
-
-use bytemuck::*;
-
-#[test]
-fn test_try_cast_slice() {
-  // some align4 data
-  let u32_slice: &[u32] = &[4, 5, 6];
-  // the same data as align1
-  let the_bytes: &[u8] = try_cast_slice(u32_slice).unwrap();
-
-  assert_eq!(
-    u32_slice.as_ptr() as *const u32 as usize,
-    the_bytes.as_ptr() as *const u8 as usize
-  );
-  assert_eq!(
-    u32_slice.len() * size_of::<u32>(),
-    the_bytes.len() * size_of::<u8>()
-  );
-
-  // by taking one byte off the front, we're definitely mis-aligned for u32.
-  let mis_aligned_bytes = &the_bytes[1..];
-  assert_eq!(
-    try_cast_slice::<u8, u32>(mis_aligned_bytes),
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  );
-
-  // by taking one byte off the end, we're aligned but would have slop bytes for
-  // u32
-  let the_bytes_len_minus1 = the_bytes.len() - 1;
-  let slop_bytes = &the_bytes[..the_bytes_len_minus1];
-  assert_eq!(
-    try_cast_slice::<u8, u32>(slop_bytes),
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  );
-
-  // if we don't mess with it we can up-alignment cast
-  try_cast_slice::<u8, u32>(the_bytes).unwrap();
-}
-
-#[test]
-fn test_try_cast_slice_mut() {
-  // some align4 data
-  let u32_slice: &mut [u32] = &mut [4, 5, 6];
-  let u32_len = u32_slice.len();
-  let u32_ptr = u32_slice.as_ptr();
-
-  // the same data as align1
-  let the_bytes: &mut [u8] = try_cast_slice_mut(u32_slice).unwrap();
-  let the_bytes_len = the_bytes.len();
-  let the_bytes_ptr = the_bytes.as_ptr();
-
-  assert_eq!(
-    u32_ptr as *const u32 as usize,
-    the_bytes_ptr as *const u8 as usize
-  );
-  assert_eq!(u32_len * size_of::<u32>(), the_bytes_len * size_of::<u8>());
-
-  // by taking one byte off the front, we're definitely mis-aligned for u32.
-  let mis_aligned_bytes = &mut the_bytes[1..];
-  assert_eq!(
-    try_cast_slice_mut::<u8, u32>(mis_aligned_bytes),
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  );
-
-  // by taking one byte off the end, we're aligned but would have slop bytes for
-  // u32
-  let the_bytes_len_minus1 = the_bytes.len() - 1;
-  let slop_bytes = &mut the_bytes[..the_bytes_len_minus1];
-  assert_eq!(
-    try_cast_slice_mut::<u8, u32>(slop_bytes),
-    Err(PodCastError::OutputSliceWouldHaveSlop)
-  );
-
-  // if we don't mess with it we can up-alignment cast
-  try_cast_slice_mut::<u8, u32>(the_bytes).unwrap();
-}
-
-#[test]
-fn test_types() {
-  let _: i32 = cast(1.0_f32);
-  let _: &mut i32 = cast_mut(&mut 1.0_f32);
-  let _: &i32 = cast_ref(&1.0_f32);
-  let _: &[i32] = cast_slice(&[1.0_f32]);
-  let _: &mut [i32] = cast_slice_mut(&mut [1.0_f32]);
-  //
-  let _: Result<i32, PodCastError> = try_cast(1.0_f32);
-  let _: Result<&mut i32, PodCastError> = try_cast_mut(&mut 1.0_f32);
-  let _: Result<&i32, PodCastError> = try_cast_ref(&1.0_f32);
-  let _: Result<&[i32], PodCastError> = try_cast_slice(&[1.0_f32]);
-  let _: Result<&mut [i32], PodCastError> = try_cast_slice_mut(&mut [1.0_f32]);
-}
-
-#[test]
-fn test_bytes_of() {
-  assert_eq!(bytes_of(&0xaabbccdd_u32), &0xaabbccdd_u32.to_ne_bytes());
-  assert_eq!(
-    bytes_of_mut(&mut 0xaabbccdd_u32),
-    &mut 0xaabbccdd_u32.to_ne_bytes()
-  );
-  let mut a = 0xaabbccdd_u32;
-  let a_addr = &a as *const _ as usize;
-  // ensure addresses match.
-  assert_eq!(bytes_of(&a).as_ptr() as usize, a_addr);
-  assert_eq!(bytes_of_mut(&mut a).as_ptr() as usize, a_addr);
-}
-
-#[test]
-fn test_try_from_bytes() {
-  let u32s = [0xaabbccdd, 0x11223344_u32];
-  let bytes = bytemuck::cast_slice::<u32, u8>(&u32s);
-  assert_eq!(try_from_bytes::<u32>(&bytes[..4]), Ok(&u32s[0]));
-  assert_eq!(
-    try_from_bytes::<u32>(&bytes[..5]),
-    Err(PodCastError::SizeMismatch)
-  );
-  assert_eq!(
-    try_from_bytes::<u32>(&bytes[..3]),
-    Err(PodCastError::SizeMismatch)
-  );
-  assert_eq!(
-    try_from_bytes::<u32>(&bytes[1..5]),
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  );
-}
-
-#[test]
-fn test_try_from_bytes_mut() {
-  let mut abcd = 0xaabbccdd;
-  let mut u32s = [abcd, 0x11223344_u32];
-  let bytes = bytemuck::cast_slice_mut::<u32, u8>(&mut u32s);
-  assert_eq!(try_from_bytes_mut::<u32>(&mut bytes[..4]), Ok(&mut abcd));
-  assert_eq!(try_from_bytes_mut::<u32>(&mut bytes[..4]), Ok(&mut abcd));
-  assert_eq!(
-    try_from_bytes_mut::<u32>(&mut bytes[..5]),
-    Err(PodCastError::SizeMismatch)
-  );
-  assert_eq!(
-    try_from_bytes_mut::<u32>(&mut bytes[..3]),
-    Err(PodCastError::SizeMismatch)
-  );
-  assert_eq!(
-    try_from_bytes::<u32>(&mut bytes[1..5]),
-    Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned)
-  );
-}
-
-#[test]
-fn test_from_bytes() {
-  let abcd = 0xaabbccdd_u32;
-  let aligned_bytes = bytemuck::bytes_of(&abcd);
-  assert_eq!(from_bytes::<u32>(aligned_bytes), &abcd);
-  assert!(core::ptr::eq(from_bytes(aligned_bytes), &abcd));
-}
-
-#[test]
-fn test_from_bytes_mut() {
-  let mut a = 0xaabbccdd_u32;
-  let a_addr = &a as *const _ as usize;
-  let aligned_bytes = bytemuck::bytes_of_mut(&mut a);
-  assert_eq!(*from_bytes_mut::<u32>(aligned_bytes), 0xaabbccdd_u32);
-  assert_eq!(
-    from_bytes_mut::<u32>(aligned_bytes) as *const u32 as usize,
-    a_addr
-  );
-}
-
-// like #[should_panic], but can be a part of another test, instead of requiring
-// it to be it's own test.
-macro_rules! should_panic {
-  ($ex:expr) => {
-    assert!(
-      std::panic::catch_unwind(|| {
-        let _ = $ex;
-      })
-      .is_err(),
-      concat!("should have panicked: `", stringify!($ex), "`")
-    );
-  };
-}
-
-#[test]
-fn test_panics() {
-  should_panic!(cast_slice::<u8, u32>(&[1u8, 2u8]));
-  should_panic!(cast_slice_mut::<u8, u32>(&mut [1u8, 2u8]));
-  should_panic!(from_bytes::<u32>(&[1u8, 2]));
-  should_panic!(from_bytes::<u32>(&[1u8, 2, 3, 4, 5]));
-  should_panic!(from_bytes_mut::<u32>(&mut [1u8, 2]));
-  should_panic!(from_bytes_mut::<u32>(&mut [1u8, 2, 3, 4, 5]));
-  // use cast_slice on some u32s to get some align>=4 bytes, so we can know
-  // we'll give from_bytes unaligned ones.
-  let aligned_bytes = bytemuck::cast_slice::<u32, u8>(&[0, 0]);
-  should_panic!(from_bytes::<u32>(&aligned_bytes[1..5]));
-}
diff --git a/vendor/bytemuck/tests/derive.rs b/vendor/bytemuck/tests/derive.rs
deleted file mode 100644
index ac30216b..00000000
--- a/vendor/bytemuck/tests/derive.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![cfg(feature = "derive")]
-#![allow(dead_code)]
-
-use bytemuck::{Pod, TransparentWrapper, Zeroable};
-
-#[derive(Copy, Clone, Pod, Zeroable)]
-#[repr(C)]
-struct Test {
-  a: u16,
-  b: u16,
-}
-
-#[derive(TransparentWrapper)]
-#[repr(transparent)]
-struct TransparentSingle {
-  a: u16,
-}
-
-#[derive(TransparentWrapper)]
-#[repr(transparent)]
-#[transparent(u16)]
-struct TransparentWithZeroSized {
-  a: u16,
-  b: (),
-}
diff --git a/vendor/bytemuck/tests/doc_tests.rs b/vendor/bytemuck/tests/doc_tests.rs
deleted file mode 100644
index 091226cf..00000000
--- a/vendor/bytemuck/tests/doc_tests.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-//! Cargo miri doesn't run doctests yet, so we duplicate these here. It's
-//! probably not that important to sweat keeping these perfectly up to date, but
-//! we should try to catch the cases where the primary tests are doctests.
-use bytemuck::*;
-
-// Miri doesn't run on doctests, so... copypaste to the rescue.
-#[test]
-fn test_transparent_slice() {
-  #[repr(transparent)]
-  struct Slice<T>([T]);
-
-  unsafe impl<T> TransparentWrapper<[T]> for Slice<T> {}
-
-  let s = Slice::wrap_ref(&[1u32, 2, 3]);
-  assert_eq!(&s.0, &[1, 2, 3]);
-
-  let mut buf = [1, 2, 3u8];
-  let _sm = Slice::wrap_mut(&mut buf);
-}
-
-#[test]
-fn test_transparent_basic() {
-  #[derive(Default)]
-  struct SomeStruct(u32);
-
-  #[repr(transparent)]
-  struct MyWrapper(SomeStruct);
-
-  unsafe impl TransparentWrapper<SomeStruct> for MyWrapper {}
-
-  // interpret a reference to &SomeStruct as a &MyWrapper
-  let thing = SomeStruct::default();
-  let wrapped_ref: &MyWrapper = MyWrapper::wrap_ref(&thing);
-
-  // Works with &mut too.
-  let mut mut_thing = SomeStruct::default();
-  let wrapped_mut: &mut MyWrapper = MyWrapper::wrap_mut(&mut mut_thing);
-  let _ = (wrapped_ref, wrapped_mut);
-}
-
-// Work around miri not running doctests
-#[test]
-fn test_contiguous_doc() {
-  #[repr(u8)]
-  #[derive(Debug, Copy, Clone, PartialEq)]
-  enum Foo {
-    A = 0,
-    B = 1,
-    C = 2,
-    D = 3,
-    E = 4,
-  }
-  unsafe impl Contiguous for Foo {
-    type Int = u8;
-    const MIN_VALUE: u8 = Foo::A as u8;
-    const MAX_VALUE: u8 = Foo::E as u8;
-  }
-
-  assert_eq!(Foo::from_integer(3).unwrap(), Foo::D);
-  assert_eq!(Foo::from_integer(8), None);
-  assert_eq!(Foo::C.into_integer(), 2);
-  assert_eq!(Foo::B.into_integer(), Foo::B as u8);
-}
-
-#[test]
-fn test_offsetof_vertex() {
-  #[repr(C)]
-  struct Vertex {
-    pos: [f32; 2],
-    uv: [u16; 2],
-    color: [u8; 4],
-  }
-  unsafe impl Zeroable for Vertex {}
-
-  let pos = offset_of!(Zeroable::zeroed(), Vertex, pos);
-  let uv = offset_of!(Zeroable::zeroed(), Vertex, uv);
-  let color = offset_of!(Zeroable::zeroed(), Vertex, color);
-
-  assert_eq!(pos, 0);
-  assert_eq!(uv, 8);
-  assert_eq!(color, 12);
-}
-
-#[test]
-fn test_offsetof_nonpod() {
-  #[derive(Default)]
-  struct Foo {
-    a: u8,
-    b: &'static str,
-    c: i32,
-  }
-
-  let a_offset = offset_of!(Default::default(), Foo, a);
-  let b_offset = offset_of!(Default::default(), Foo, b);
-  let c_offset = offset_of!(Default::default(), Foo, c);
-
-  assert_ne!(a_offset, b_offset);
-  assert_ne!(b_offset, c_offset);
-  // We can't check against hardcoded values for a repr(Rust) type,
-  // but prove to ourself this way.
-
-  let foo = Foo::default();
-  // Note: offsets are in bytes.
-  let as_bytes = &foo as *const _ as *const u8;
-
-  // we're using wrapping_offset here becasue it's not worth
-  // the unsafe block, but it would be valid to use `add` instead,
-  // as it cannot overflow.
-  assert_eq!(
-    &foo.a as *const _ as usize,
-    as_bytes.wrapping_add(a_offset) as usize
-  );
-  assert_eq!(
-    &foo.b as *const _ as usize,
-    as_bytes.wrapping_add(b_offset) as usize
-  );
-  assert_eq!(
-    &foo.c as *const _ as usize,
-    as_bytes.wrapping_add(c_offset) as usize
-  );
-}
diff --git a/vendor/bytemuck/tests/offset_of_tests.rs b/vendor/bytemuck/tests/offset_of_tests.rs
deleted file mode 100644
index d4848457..00000000
--- a/vendor/bytemuck/tests/offset_of_tests.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use bytemuck::{offset_of, Zeroable};
-
-#[test]
-fn test_offset_of_vertex() {
-  #[repr(C)]
-  struct Vertex {
-    pos: [f32; 2],
-    uv: [u16; 2],
-    color: [u8; 4],
-  }
-  unsafe impl Zeroable for Vertex {}
-
-  let pos = offset_of!(Zeroable::zeroed(), Vertex, pos);
-  let uv = offset_of!(Zeroable::zeroed(), Vertex, uv);
-  let color = offset_of!(Zeroable::zeroed(), Vertex, color);
-
-  assert_eq!(pos, 0);
-  assert_eq!(uv, 8);
-  assert_eq!(color, 12);
-}
-
-#[test]
-fn test_offset_of_foo() {
-  #[derive(Default)]
-  struct Foo {
-    a: u8,
-    b: &'static str,
-    c: i32,
-  }
-
-  let a_offset = offset_of!(Default::default(), Foo, a);
-  let b_offset = offset_of!(Default::default(), Foo, b);
-  let c_offset = offset_of!(Default::default(), Foo, c);
-
-  assert_ne!(a_offset, b_offset);
-  assert_ne!(b_offset, c_offset);
-  // We can't check against hardcoded values for a repr(Rust) type,
-  // but prove to ourself this way.
-
-  let foo = Foo::default();
-  // Note: offsets are in bytes.
-  let as_bytes = &foo as *const _ as *const u8;
-
-  // we're using wrapping_offset here because it's not worth
-  // the unsafe block, but it would be valid to use `add` instead,
-  // as it cannot overflow.
-  assert_eq!(
-    &foo.a as *const _ as usize,
-    as_bytes.wrapping_add(a_offset) as usize
-  );
-  assert_eq!(
-    &foo.b as *const _ as usize,
-    as_bytes.wrapping_add(b_offset) as usize
-  );
-  assert_eq!(
-    &foo.c as *const _ as usize,
-    as_bytes.wrapping_add(c_offset) as usize
-  );
-}
diff --git a/vendor/bytemuck/tests/std_tests.rs b/vendor/bytemuck/tests/std_tests.rs
deleted file mode 100644
index a91ee361..00000000
--- a/vendor/bytemuck/tests/std_tests.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! The integration tests seem to always have `std` linked, so things that would
-//! depend on that can go here.
-
-use bytemuck::*;
-
-#[test]
-fn test_transparent_vtabled() {
-  use core::fmt::Display;
-
-  #[repr(transparent)]
-  struct DisplayTraitObj(dyn Display);
-
-  unsafe impl TransparentWrapper<dyn Display> for DisplayTraitObj {}
-
-  impl Display for DisplayTraitObj {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-      self.0.fmt(f)
-    }
-  }
-
-  let v = DisplayTraitObj::wrap_ref(&5i32);
-  let s = format!("{}", v);
-  assert_eq!(s, "5");
-
-  let mut x = 100i32;
-  let v_mut = DisplayTraitObj::wrap_mut(&mut x);
-  let s = format!("{}", v_mut);
-  assert_eq!(s, "100");
-}
-
-#[test]
-#[cfg(feature = "extern_crate_alloc")]
-fn test_large_box_alloc() {
-  type SuperPage = [[u8; 4096]; 4096];
-  let _: Box<SuperPage> = try_zeroed_box().unwrap();
-}
-
-#[test]
-#[cfg(feature = "extern_crate_alloc")]
-fn test_zero_sized_box_alloc() {
-  #[repr(align(4096))]
-  struct Empty;
-  unsafe impl Zeroable for Empty {}
-  let _: Box<Empty> = try_zeroed_box().unwrap();
-}
diff --git a/vendor/bytemuck/tests/transparent.rs b/vendor/bytemuck/tests/transparent.rs
deleted file mode 100644
index 8381ad4f..00000000
--- a/vendor/bytemuck/tests/transparent.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Currently this test doesn't actually check the output of the functions.
-// It's only here for miri to check for any potential undefined behaviour.
-// TODO: check function results
-
-#[test]
-fn test_transparent_wrapper() {
-  // An external type defined in a different crate.
-  #[derive(Copy, Clone, Default)]
-  struct Foreign(u8);
-
-  use bytemuck::TransparentWrapper;
-
-  #[derive(Copy, Clone)]
-  #[repr(transparent)]
-  struct Wrapper(Foreign);
-
-  unsafe impl TransparentWrapper<Foreign> for Wrapper {}
-
-  // Traits can be implemented on crate-local wrapper.
-  unsafe impl bytemuck::Zeroable for Wrapper {}
-  unsafe impl bytemuck::Pod for Wrapper {}
-
-  let _: u8 = bytemuck::cast(Wrapper::wrap(Foreign::default()));
-  let _: Foreign = Wrapper::peel(bytemuck::cast(u8::default()));
-
-  let _: &u8 = bytemuck::cast_ref(Wrapper::wrap_ref(&Foreign::default()));
-  let _: &Foreign = Wrapper::peel_ref(bytemuck::cast_ref(&u8::default()));
-
-  let _: &mut u8 =
-    bytemuck::cast_mut(Wrapper::wrap_mut(&mut Foreign::default()));
-  let _: &mut Foreign =
-    Wrapper::peel_mut(bytemuck::cast_mut(&mut u8::default()));
-
-  let _: &[u8] =
-    bytemuck::cast_slice(Wrapper::wrap_slice(&[Foreign::default()]));
-  let _: &[Foreign] =
-    Wrapper::peel_slice(bytemuck::cast_slice(&[u8::default()]));
-
-  let _: &mut [u8] =
-    bytemuck::cast_slice_mut(Wrapper::wrap_slice_mut(
-      &mut [Foreign::default()],
-    ));
-  let _: &mut [Foreign] =
-    Wrapper::peel_slice_mut(bytemuck::cast_slice_mut(&mut [u8::default()]));
-
-  let _: &[u8] = bytemuck::bytes_of(Wrapper::wrap_ref(&Foreign::default()));
-  let _: &Foreign = Wrapper::peel_ref(bytemuck::from_bytes(&[u8::default()]));
-
-  let _: &mut [u8] =
-    bytemuck::bytes_of_mut(Wrapper::wrap_mut(&mut Foreign::default()));
-  let _: &mut Foreign =
-    Wrapper::peel_mut(bytemuck::from_bytes_mut(&mut [u8::default()]));
-
-  // not sure if this is the right usage
-  let _ =
-    bytemuck::pod_align_to::<_, u8>(Wrapper::wrap_slice(&[Foreign::default()]));
-  // counterpart?
-
-  // not sure if this is the right usage
-  let _ = bytemuck::pod_align_to_mut::<_, u8>(Wrapper::wrap_slice_mut(&mut [
-    Foreign::default(),
-  ]));
-  // counterpart?
-}
diff --git a/vendor/bytemuck/tests/wrapper_forgets.rs b/vendor/bytemuck/tests/wrapper_forgets.rs
deleted file mode 100644
index da3404f3..00000000
--- a/vendor/bytemuck/tests/wrapper_forgets.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use bytemuck::TransparentWrapper;
-
-#[repr(transparent)]
-struct Wrap(Box<u32>);
-
-// SAFETY: it's #[repr(transparent)]
-unsafe impl TransparentWrapper<Box<u32>> for Wrap {}
-
-fn main() {
-  let value = Box::new(5);
-  // This used to duplicate the wrapped value, creating a double free :(
-  Wrap::wrap(value);
-}
diff --git a/vendor/bytemuck_derive/.cargo-checksum.json b/vendor/bytemuck_derive/.cargo-checksum.json
deleted file mode 100644
index ef4dfff2..00000000
--- a/vendor/bytemuck_derive/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"e3bc406eee45f74e5abc5e0935867cf7cbda2a21c9aae5b9ef5e223827f07445","LICENSE-APACHE":"e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb","LICENSE-MIT":"9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2","LICENSE-ZLIB":"84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151","README.md":"09d8238fd7fdac39857da88e090667d8327ca9ac240768e216ef2079c2f06846","changelog.md":"5314b666a08dbabbb4a09d0cebfaba9b742e4c39fa45b96cf65638d615ca7272","src/lib.rs":"ba381a12be6aca1a9e8b255e7948d87846f382629316473f6b7cad7640d9e47a","src/traits.rs":"163308df190e889b1b68ca5dab530fbf283998e9d0e47cd9ec0e357a1addfa5a","tests/basic.rs":"dd02611e39aa53c941f39be0d10c1eba319650a31fd8222e459cbcc9f9346219"},"package":"8e215f8c2f9f79cb53c8335e687ffd07d5bfcb6fe5fc80723762d0be46e7cc54"}
\ No newline at end of file
diff --git a/vendor/bytemuck_derive/Cargo.toml b/vendor/bytemuck_derive/Cargo.toml
deleted file mode 100644
index 4365f061..00000000
--- a/vendor/bytemuck_derive/Cargo.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "bytemuck_derive"
-version = "1.0.1"
-authors = ["Lokathor <zefria@gmail.com>"]
-description = "derive proc-macros for `bytemuck`"
-readme = "README.md"
-keywords = ["transmute", "bytes", "casting"]
-categories = ["encoding", "no-std"]
-license = "Zlib OR Apache-2.0 OR MIT"
-repository = "https://github.com/Lokathor/bytemuck"
-
-[lib]
-name = "bytemuck_derive"
-proc-macro = true
-[dependencies.proc-macro2]
-version = "1"
-
-[dependencies.quote]
-version = "1"
-
-[dependencies.syn]
-version = "1"
-[dev-dependencies.bytemuck]
-version = "1.2"
diff --git a/vendor/bytemuck_derive/LICENSE-APACHE b/vendor/bytemuck_derive/LICENSE-APACHE
deleted file mode 100644
index 136d9004..00000000
--- a/vendor/bytemuck_derive/LICENSE-APACHE
+++ /dev/null
@@ -1,61 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-        "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
-
-        "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
-
-        "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
-
-        "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
-
-        "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
-
-        "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
-
-        "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
-
-        "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
-
-        "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
-
-        "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
-    2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
-    3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
-    4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
-        (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
-        (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
-        (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
-        (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
-
-        You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
-    5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
-    6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
-    7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
-    8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
-    9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/bytemuck_derive/LICENSE-MIT b/vendor/bytemuck_derive/LICENSE-MIT
deleted file mode 100644
index 164045fa..00000000
--- a/vendor/bytemuck_derive/LICENSE-MIT
+++ /dev/null
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/bytemuck_derive/LICENSE-ZLIB b/vendor/bytemuck_derive/LICENSE-ZLIB
deleted file mode 100644
index d70707c7..00000000
--- a/vendor/bytemuck_derive/LICENSE-ZLIB
+++ /dev/null
@@ -1,11 +0,0 @@
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
diff --git a/vendor/bytemuck_derive/README.md b/vendor/bytemuck_derive/README.md
deleted file mode 100644
index 553a40ef..00000000
--- a/vendor/bytemuck_derive/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-
-# bytemuck_derive
-
-Derive macros for [bytemuck](https://docs.rs/bytemuck) traits.
diff --git a/vendor/bytemuck_derive/changelog.md b/vendor/bytemuck_derive/changelog.md
deleted file mode 100644
index eccfaf03..00000000
--- a/vendor/bytemuck_derive/changelog.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-## `bytemuck_derive` changelog
-
-## 1.0.1
-
-* [yanchith](https://github.com/yanchith) fixed the derive checks code to make clippy more happy.
-[PR 45](https://github.com/Lokathor/bytemuck/pull/45)
-
-## 1.0.0
-
-* Initial stable release.
diff --git a/vendor/bytemuck_derive/src/lib.rs b/vendor/bytemuck_derive/src/lib.rs
deleted file mode 100644
index 924270a0..00000000
--- a/vendor/bytemuck_derive/src/lib.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-//! Derive macros for [bytemuck](https://docs.rs/bytemuck) traits.
-
-extern crate proc_macro;
-
-mod traits;
-
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
-
-use crate::traits::{Contiguous, Derivable, Pod, TransparentWrapper, Zeroable};
-
-/// Derive the `Pod` trait for a struct
-///
-/// The macro ensures that the struct follows all the the safety requirements
-/// for the `Pod` trait.
-///
-/// The following constraints need to be satisfied for the macro to succeed
-///
-/// - All fields in the struct must implement `Pod`
-/// - The struct must be `#[repr(C)]` or `#[repr(transparent)]`
-/// - The struct must not contain any padding bytes
-/// - The struct contains no generic parameters
-///
-/// ## Example
-///
-/// ```rust
-/// # use bytemuck_derive::{Pod, Zeroable};
-///
-/// #[derive(Copy, Clone, Pod, Zeroable)]
-/// #[repr(C)]
-/// struct Test {
-///   a: u16,
-///   b: u16,
-/// }
-/// ```
-#[proc_macro_derive(Pod)]
-pub fn derive_pod(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-  let expanded =
-    derive_marker_trait::<Pod>(parse_macro_input!(input as DeriveInput));
-
-  proc_macro::TokenStream::from(expanded)
-}
-
-/// Derive the `Zeroable` trait for a struct
-///
-/// The macro ensures that the struct follows all the the safety requirements
-/// for the `Zeroable` trait.
-///
-/// The following constraints need to be satisfied for the macro to succeed
-///
-/// - All fields ind the struct must to implement `Zeroable`
-///
-/// ## Example
-///
-/// ```rust
-/// # use bytemuck_derive::{Zeroable};
-///
-/// #[derive(Copy, Clone, Zeroable)]
-/// #[repr(C)]
-/// struct Test {
-///   a: u16,
-///   b: u16,
-/// }
-/// ```
-#[proc_macro_derive(Zeroable)]
-pub fn derive_zeroable(
-  input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-  let expanded =
-    derive_marker_trait::<Zeroable>(parse_macro_input!(input as DeriveInput));
-
-  proc_macro::TokenStream::from(expanded)
-}
-
-/// Derive the `TransparentWrapper` trait for a struct
-///
-/// The macro ensures that the struct follows all the the safety requirements
-/// for the `TransparentWrapper` trait.
-///
-/// The following constraints need to be satisfied for the macro to succeed
-///
-/// - The struct must be `#[repr(transparent)]`
-/// - The struct must contain the `Wrapped` type
-///
-/// If the struct only contains a single field, the `Wrapped` type will
-/// automatically be determined if there is more then one field in the struct,
-/// you need to specify the `Wrapped` type using `#[transparent(T)]`
-///
-/// ## Example
-///
-/// ```rust
-/// # use bytemuck_derive::TransparentWrapper;
-/// # use std::marker::PhantomData;
-///
-/// #[derive(Copy, Clone, TransparentWrapper)]
-/// #[repr(transparent)]
-/// #[transparent(u16)]
-/// struct Test<T> {
-///   inner: u16,
-///   extra: PhantomData<T>,
-/// }
-/// ```
-#[proc_macro_derive(TransparentWrapper, attributes(transparent))]
-pub fn derive_transparent(
-  input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-  let expanded = derive_marker_trait::<TransparentWrapper>(parse_macro_input!(
-    input as DeriveInput
-  ));
-
-  proc_macro::TokenStream::from(expanded)
-}
-
-/// Derive the `Contiguous` trait for an enum
-///
-/// The macro ensures that the enum follows all the the safety requirements
-/// for the `Contiguous` trait.
-///
-/// The following constraints need to be satisfied for the macro to succeed
-///
-/// - The enum must be `#[repr(Int)]`
-/// - The enum must be fieldless
-/// - The enum discriminants must form a contiguous range
-///
-/// ## Example
-///
-/// ```rust
-/// # use bytemuck_derive::{Contiguous};
-///
-/// #[derive(Copy, Clone, Contiguous)]
-/// #[repr(u8)]
-/// enum Test {
-///   A = 0,
-///   B = 1,
-///   C = 2,
-/// }
-/// ```
-#[proc_macro_derive(Contiguous)]
-pub fn derive_contiguous(
-  input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-  let expanded =
-    derive_marker_trait::<Contiguous>(parse_macro_input!(input as DeriveInput));
-
-  proc_macro::TokenStream::from(expanded)
-}
-
-/// Basic wrapper for error handling
-fn derive_marker_trait<Trait: Derivable>(input: DeriveInput) -> TokenStream {
-  derive_marker_trait_inner::<Trait>(input).unwrap_or_else(|err| {
-    quote! {
-      compile_error!(#err);
-    }
-  })
-}
-
-fn derive_marker_trait_inner<Trait: Derivable>(
-  input: DeriveInput,
-) -> Result<TokenStream, &'static str> {
-  let name = &input.ident;
-
-  let (impl_generics, ty_generics, where_clause) =
-    input.generics.split_for_impl();
-
-  let trait_ = Trait::ident();
-  Trait::check_attributes(&input.attrs)?;
-  let asserts = Trait::struct_asserts(&input)?;
-  let trait_params = Trait::generic_params(&input)?;
-  let trait_impl = Trait::trait_impl(&input)?;
-
-  Ok(quote! {
-    #asserts
-
-    unsafe impl #impl_generics #trait_ #trait_params for #name #ty_generics #where_clause {
-      #trait_impl
-    }
-  })
-}
diff --git a/vendor/bytemuck_derive/src/traits.rs b/vendor/bytemuck_derive/src/traits.rs
deleted file mode 100644
index 03147916..00000000
--- a/vendor/bytemuck_derive/src/traits.rs
+++ /dev/null
@@ -1,328 +0,0 @@
-use proc_macro2::{Ident, TokenStream, TokenTree};
-use quote::{quote, quote_spanned, ToTokens};
-use syn::{
-  spanned::Spanned, AttrStyle, Attribute, Data, DataEnum, DataStruct,
-  DeriveInput, Expr, ExprLit, ExprUnary, Fields, Lit, LitInt, Type, UnOp,
-  Variant,
-};
-
-pub trait Derivable {
-  fn ident() -> TokenStream;
-  fn generic_params(_input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    Ok(quote!())
-  }
-  fn struct_asserts(_input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    Ok(quote!())
-  }
-  fn check_attributes(_attributes: &[Attribute]) -> Result<(), &'static str> {
-    Ok(())
-  }
-  fn trait_impl(_input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    Ok(quote!())
-  }
-}
-
-pub struct Pod;
-
-impl Derivable for Pod {
-  fn ident() -> TokenStream {
-    quote!(::bytemuck::Pod)
-  }
-
-  fn struct_asserts(input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    if !input.generics.params.is_empty() {
-      return Err("Pod requires cannot be derived for structs containing generic parameters because the padding requirements can't be verified for generic structs");
-    }
-
-    let assert_no_padding = generate_assert_no_padding(input)?;
-    let assert_fields_are_pod =
-      generate_fields_are_trait(input, Self::ident())?;
-
-    Ok(quote!(
-      #assert_no_padding
-      #assert_fields_are_pod
-    ))
-  }
-
-  fn check_attributes(attributes: &[Attribute]) -> Result<(), &'static str> {
-    let repr = get_repr(attributes);
-    match repr.as_ref().map(|repr| repr.as_str()) {
-      Some("C") => Ok(()),
-      Some("transparent") => Ok(()),
-      _ => {
-        Err("Pod requires the struct to be #[repr(C)] or #[repr(transparent)]")
-      }
-    }
-  }
-}
-
-pub struct Zeroable;
-
-impl Derivable for Zeroable {
-  fn ident() -> TokenStream {
-    quote!(::bytemuck::Zeroable)
-  }
-
-  fn struct_asserts(input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    generate_fields_are_trait(input, Self::ident())
-  }
-}
-
-pub struct TransparentWrapper;
-
-impl TransparentWrapper {
-  fn get_wrapper_type(
-    attributes: &[Attribute], fields: &Fields,
-  ) -> Option<TokenStream> {
-    let transparent_param = get_simple_attr(attributes, "transparent");
-    transparent_param.map(|ident| ident.to_token_stream()).or_else(|| {
-      let mut types = get_field_types(fields);
-      let first_type = types.next();
-      if let Some(_) = types.next() {
-        // can't guess param type if there is more than one field
-        return None;
-      } else {
-        first_type.map(|ty| ty.to_token_stream())
-      }
-    })
-  }
-}
-
-impl Derivable for TransparentWrapper {
-  fn ident() -> TokenStream {
-    quote!(::bytemuck::TransparentWrapper)
-  }
-
-  fn generic_params(input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    let fields = get_struct_fields(input)?;
-
-    Self::get_wrapper_type(&input.attrs, fields).map(|ty| quote!(<#ty>))
-            .ok_or("when deriving TransparentWrapper for a struct with more than one field you need to specify the transparent field using #[transparent(T)]")
-  }
-
-  fn struct_asserts(input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    let fields = get_struct_fields(input)?;
-    let wrapped_type = match Self::get_wrapper_type(&input.attrs, fields) {
-      Some(wrapped_type) => wrapped_type.to_string(),
-      None => unreachable!(), /* other code will already reject this derive */
-    };
-    let mut wrapped_fields = fields
-      .iter()
-      .filter(|field| field.ty.to_token_stream().to_string() == wrapped_type);
-    if let None = wrapped_fields.next() {
-      return Err("TransparentWrapper must have one field of the wrapped type");
-    };
-    if let Some(_) = wrapped_fields.next() {
-      Err("TransparentWrapper can only have one field of the wrapped type")
-    } else {
-      Ok(quote!())
-    }
-  }
-
-  fn check_attributes(attributes: &[Attribute]) -> Result<(), &'static str> {
-    let repr = get_repr(attributes);
-
-    match repr.as_ref().map(|repr| repr.as_str()) {
-      Some("transparent") => Ok(()),
-      _ => {
-        Err("TransparentWrapper requires the struct to be #[repr(transparent)]")
-      }
-    }
-  }
-}
-
-pub struct Contiguous;
-
-impl Derivable for Contiguous {
-  fn ident() -> TokenStream {
-    quote!(::bytemuck::Contiguous)
-  }
-
-  fn trait_impl(input: &DeriveInput) -> Result<TokenStream, &'static str> {
-    let repr = get_repr(&input.attrs)
-      .ok_or("Contiguous requires the enum to be #[repr(Int)]")?;
-
-    if !repr.starts_with('u') && !repr.starts_with('i') {
-      return Err("Contiguous requires the enum to be #[repr(Int)]");
-    }
-
-    let variants = get_enum_variants(input)?;
-    let mut variants_with_discriminator =
-      VariantDiscriminantIterator::new(variants);
-
-    let (min, max, count) = variants_with_discriminator.try_fold(
-      (i64::max_value(), i64::min_value(), 0),
-      |(min, max, count), res| {
-        let discriminator = res?;
-        Ok((
-          i64::min(min, discriminator),
-          i64::max(max, discriminator),
-          count + 1,
-        ))
-      },
-    )?;
-
-    if max - min != count - 1 {
-      return Err(
-        "Contiguous requires the enum discriminants to be contiguous",
-      );
-    }
-
-    let repr_ident = Ident::new(&repr, input.span());
-    let min_lit = LitInt::new(&format!("{}", min), input.span());
-    let max_lit = LitInt::new(&format!("{}", max), input.span());
-
-    Ok(quote! {
-        type Int = #repr_ident;
-        const MIN_VALUE: #repr_ident = #min_lit;
-        const MAX_VALUE: #repr_ident = #max_lit;
-    })
-  }
-}
-
-fn get_struct_fields(input: &DeriveInput) -> Result<&Fields, &'static str> {
-  if let Data::Struct(DataStruct { fields, .. }) = &input.data {
-    Ok(fields)
-  } else {
-    Err("deriving this trait is only supported for structs")
-  }
-}
-
-fn get_enum_variants<'a>(
-  input: &'a DeriveInput,
-) -> Result<impl Iterator<Item = &'a Variant> + 'a, &'static str> {
-  if let Data::Enum(DataEnum { variants, .. }) = &input.data {
-    Ok(variants.iter())
-  } else {
-    Err("deriving this trait is only supported for enums")
-  }
-}
-
-fn get_field_types<'a>(
-  fields: &'a Fields,
-) -> impl Iterator<Item = &'a Type> + 'a {
-  fields.iter().map(|field| &field.ty)
-}
-
-/// Check that a struct has no padding by asserting that the size of the struct
-/// is equal to the sum of the size of it's fields
-fn generate_assert_no_padding(
-  input: &DeriveInput,
-) -> Result<TokenStream, &'static str> {
-  let struct_type = &input.ident;
-  let span = input.ident.span();
-  let fields = get_struct_fields(input)?;
-
-  let mut field_types = get_field_types(&fields);
-  let size_sum = if let Some(first) = field_types.next() {
-    let size_first = quote_spanned!(span => ::core::mem::size_of::<#first>());
-    let size_rest =
-      quote_spanned!(span => #( + ::core::mem::size_of::<#field_types>() )*);
-
-    quote_spanned!(span => #size_first#size_rest)
-  } else {
-    quote_spanned!(span => 0)
-  };
-
-  Ok(quote_spanned! {span => const _: fn() = || {
-    struct TypeWithoutPadding([u8; #size_sum]);
-    let _ = ::core::mem::transmute::<#struct_type, TypeWithoutPadding>;
-  };})
-}
-
-/// Check that all fields implement a given trait
-fn generate_fields_are_trait(
-  input: &DeriveInput, trait_: TokenStream,
-) -> Result<TokenStream, &'static str> {
-  let (impl_generics, _ty_generics, where_clause) =
-    input.generics.split_for_impl();
-  let fields = get_struct_fields(input)?;
-  let span = input.span();
-  let field_types = get_field_types(&fields);
-  Ok(quote_spanned! {span => #(const _: fn() = || {
-      fn check #impl_generics () #where_clause {
-        fn assert_impl<T: #trait_>() {}
-        assert_impl::<#field_types>();
-      }
-    };)*
-  })
-}
-
-fn get_ident_from_stream(tokens: TokenStream) -> Option<Ident> {
-  match tokens.into_iter().next() {
-    Some(TokenTree::Group(group)) => get_ident_from_stream(group.stream()),
-    Some(TokenTree::Ident(ident)) => Some(ident),
-    _ => None,
-  }
-}
-
-/// get a simple #[foo(bar)] attribute, returning "bar"
-fn get_simple_attr(attributes: &[Attribute], attr_name: &str) -> Option<Ident> {
-  for attr in attributes {
-    if let (AttrStyle::Outer, Some(outer_ident), Some(inner_ident)) = (
-      &attr.style,
-      attr.path.get_ident(),
-      get_ident_from_stream(attr.tokens.clone()),
-    ) {
-      if outer_ident.to_string() == attr_name {
-        return Some(inner_ident);
-      }
-    }
-  }
-
-  None
-}
-
-fn get_repr(attributes: &[Attribute]) -> Option<String> {
-  get_simple_attr(attributes, "repr").map(|ident| ident.to_string())
-}
-
-struct VariantDiscriminantIterator<'a, I: Iterator<Item = &'a Variant> + 'a> {
-  inner: I,
-  last_value: i64,
-}
-
-impl<'a, I: Iterator<Item = &'a Variant> + 'a>
-  VariantDiscriminantIterator<'a, I>
-{
-  fn new(inner: I) -> Self {
-    VariantDiscriminantIterator { inner, last_value: -1 }
-  }
-}
-
-impl<'a, I: Iterator<Item = &'a Variant> + 'a> Iterator
-  for VariantDiscriminantIterator<'a, I>
-{
-  type Item = Result<i64, &'static str>;
-
-  fn next(&mut self) -> Option<Self::Item> {
-    let variant = self.inner.next()?;
-    if !variant.fields.is_empty() {
-      return Some(Err("Only fieldless enums are supported"));
-    }
-
-    if let Some((_, discriminant)) = &variant.discriminant {
-      let discriminant_value = match parse_int_expr(discriminant) {
-        Ok(value) => value,
-        Err(e) => return Some(Err(e)),
-      };
-      self.last_value = discriminant_value;
-    } else {
-      self.last_value += 1;
-    }
-
-    Some(Ok(self.last_value))
-  }
-}
-
-fn parse_int_expr(expr: &Expr) -> Result<i64, &'static str> {
-  match expr {
-    Expr::Unary(ExprUnary { op: UnOp::Neg(_), expr, .. }) => {
-      parse_int_expr(expr).map(|int| -int)
-    }
-    Expr::Lit(ExprLit { lit: Lit::Int(int), .. }) => {
-      int.base10_parse().map_err(|_| "Invalid integer expression")
-    }
-    _ => Err("Not an integer expression"),
-  }
-}
diff --git a/vendor/bytemuck_derive/tests/basic.rs b/vendor/bytemuck_derive/tests/basic.rs
deleted file mode 100644
index 867399a0..00000000
--- a/vendor/bytemuck_derive/tests/basic.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![allow(dead_code)]
-
-use bytemuck_derive::{Contiguous, Pod, TransparentWrapper, Zeroable};
-use std::marker::PhantomData;
-
-#[derive(Copy, Clone, Pod, Zeroable)]
-#[repr(C)]
-struct Test {
-  a: u16,
-  b: u16,
-}
-
-#[derive(Zeroable)]
-struct ZeroGeneric<T: bytemuck::Zeroable> {
-  a: T,
-}
-
-#[derive(TransparentWrapper)]
-#[repr(transparent)]
-struct TransparentSingle {
-  a: u16,
-}
-
-#[derive(TransparentWrapper)]
-#[repr(transparent)]
-#[transparent(u16)]
-struct TransparentWithZeroSized<T> {
-  a: u16,
-  b: PhantomData<T>,
-}
-
-#[repr(u8)]
-#[derive(Clone, Copy, Contiguous)]
-enum ContiguousWithValues {
-  A = 0,
-  B = 1,
-  C = 2,
-  D = 3,
-  E = 4,
-}
-
-#[repr(i8)]
-#[derive(Clone, Copy, Contiguous)]
-enum ContiguousWithImplicitValues {
-  A = -10,
-  B,
-  C,
-  D,
-  E,
-}
diff --git a/vendor/fake-enum/.cargo-checksum.json b/vendor/fake-enum/.cargo-checksum.json
deleted file mode 100644
index 00f45400..00000000
--- a/vendor/fake-enum/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"d5007319bb050aafdb2d9928048ab8c70c7deae5cab4fb135c6183231a3a8bf7","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"6294b1a107fec2877a4869ae2fb31088258700fa763bae44be802458adbe126f","Makefile.in":"20c33db75369d0a839d5e96aadf870ab0be9850585a165d421150e1641c5f8a9","README.md":"661076a770da8e07d214958efe9b02b50229b1d4b9b6fb0473eb16eefd70f319","aclocal.m4":"3e49d379f015e7aa565af29b60183aaf7835ef22b56d164a3437da1a059b3966","build-dirs.sh":"81b97d919f0b95f63cd12d1a4876a10ae10640f418b6db080e46259d36190bd6","config.guess":"7d1e3c79b86de601c3a0457855ab854dffd15163f53c91edac54a7be2e9c931b","config.sub":"a55026ac66184483db385cc065dd6cdc1a6788ffc1c3f82eddb5fceee2231a6d","configure":"2ddeb47f60f559829f869aa6f8b0f895bc205cecafeca40657ce1540bd03b5fd","configure.ac":"26595d8dc2caa3f6b962cb20a33dfdf7b8d220932190f6a8a155bd7a6d7d76a6","install-sh":"3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2","m4/ax_prog_cc_for_build.m4":"3480058391c4511a3c2c73b4ddd018bc36de6dabbc58d876c0ce4ffe239c36fc","m4/bindgen.m4":"15de8141b578a8ca2657f61f65a28eacb1ba7cb811bfe159e74aac3c4e833bfc","m4/build_std.m4":"4b2da2c135c431c7ca846326e60cd44fde8747ffe91e45562e252bcb1fa465cd","m4/lcrust_checks.m4":"8bd58fa9ce76f1cb1369e15ce244be2fdd5f421f895f5415e4a9d780791f487f","m4/lcrust_prog_rustc.m4":"cf1e0d65c0758bd9028f40d8b0e3880f181aa8849cdc7ff3e052d6339fd3ddb9","run-tests.sh":"6301cdd717d770d946503076778ccd7fecb712acaadc6379372cf35740a5b5a9","src/lib.rs":"9832edec5ebd97c1ac62d3bb6a3799b10013410db26a3ba0c0204e4563614fda"},"package":"185b4cd26aff3789b8662aa73732b585d46b9756cd3c6b302be72f68302c5eba"}
\ No newline at end of file
diff --git a/vendor/fake-enum/Cargo.toml b/vendor/fake-enum/Cargo.toml
deleted file mode 100644
index e0758aac..00000000
--- a/vendor/fake-enum/Cargo.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "fake-enum"
-version = "0.1.4"
-authors = ["Connor <chorman64@gmail.com>"]
-description = "    A rust crate for creating FFI safe \"fake\" enum types\n"
-readme = "README.md"
-license = "MIT AND Apache-2.0"
-repository = "https://github.com/chorman0773/rust-fake-enum"
-
-[dependencies]
diff --git a/vendor/fake-enum/LICENSE-APACHE b/vendor/fake-enum/LICENSE-APACHE
deleted file mode 100644
index 261eeb9e..00000000
--- a/vendor/fake-enum/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/fake-enum/LICENSE-MIT b/vendor/fake-enum/LICENSE-MIT
deleted file mode 100644
index a13ecd59..00000000
--- a/vendor/fake-enum/LICENSE-MIT
+++ /dev/null
@@ -1,8 +0,0 @@
-Copyright 2021 Connor Horman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
diff --git a/vendor/fake-enum/Makefile.in b/vendor/fake-enum/Makefile.in
deleted file mode 100644
index 3ba6ed36..00000000
--- a/vendor/fake-enum/Makefile.in
+++ /dev/null
@@ -1,179 +0,0 @@
-# Copyright 2021 Connor Horman
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-# Makefile.in template for library rust projects
-
-
-# Root Options
-
-ifeq ($(OS),Windows_NT)
-DLLEXT = .dll
-else
-DLLEXT = .so
-endif
-
-srcdir = @srcdir@
-builddir = @builddir@
-abs_builddir = @abs_builddir@
-
-RUSTC = @RUSTC@
-RUSTFLAGS := @RUSTFLAGS@
-
-INSTALL := @INSTALL@
-
-RUSTC_IS_LCCC = @rustc_is_lccc@
-
-## Install directories
-
-prefix = @prefix@
-exec_prefix = @exec_prefix@
-bindir = @bindir@
-libdir = @libdir@
-includedir = @includedir@
-sbindir = @sbindir@
-libexecdir = @libexecdir@
-datarootdir = @datarootdir@
-datadir = @datadir@
-mandir = @mandir@
-docdir = @docdir@
-infodir = @infodir@
-localedir = @localedir@
-sysconfdir = @sysconfdir@
-localstatedir = @localstatedir@
-runstatedir = @runstatedir@
-sharedstatedir = @sharedstatedir@
-
-
-# Other Configuration
-
-features = 
-binaries =
-tests = 
-# Package specific Configuration
-
-EXTRA_RUSTFLAGS = 
-
-# The package version
-version = 0.1.4
-
-# The output file of the library
-OUTPUT = fake-enum
-
-# The crate name of the library
-CRATE_NAME = fake_enum
-
-# The path to find dependencies located in
-
-DEPENDENCY_DIR = @abs_builddir@/vendor
-
-# Any dependencies of the library
-DEPENDENCIES = 
-
-PROC_MACROS = 
-
-SUBDIRS = 
-
-# Autogenerated variables
-
-file_to_crate = $(subst -,_,$(1))
-
-binary_outputs = $(foreach bin,$(binaries),$(bin)@EXEEXT@)
-
-CFG = $(foreach feature,$(features),feature="$feature") 
-
-EXTERN_CRATES = $(foreach procmacro,$(PROC_MACROS),$(call file_to_crate,$(notdir $(procmacro)))=$(DEPENDENCY_DIR)/$(build)/$(procmacro)/lib$(procmacro).$(DLLEXT))  $(foreach dep,$(DEPENDENCIES),--extern $(call file_to_crate,$(notdir $(dep)))=$(DEPENDENCY_DIR)/$(dep)/lib$(dep).rlib)
-
-export CARGO_PKG_VERSION=$(version)
-export CARGO_MANIFEST_DIR=@abs_srcdir@
-export OUT_DIR=@abs_builddir@
-
-# Targets
-
-all: 
-	+@srcdir@/build-dirs.sh $(SUBDIRS)
-	+$(MAKE) stamp
-
-.PHONY: all clean distclean install install-strip $(binary_outputs:%=install-%) $(binary_outputs:%=install-strip-%) $(foreach subdir,$(SUBDIRS),$(subdir)/install) $(foreach subdir,$(SUBDIRS),$(subdir)/install-strip) $(foreach subdir,$(SUBDIRS),$(subdir)/clean) $(foreach subdir,$(SUBDIRS),$(subdir)/distclean) $(foreach subdir,$(SUBDIRS),$(subdir)/check)
-
-
-Makefile: config.status @srcdir@/Makefile.in
-	@builddir@/config.status Makefile
-
-
-config.status: @srcdir@/configure
-	@builddir@/config.status --recheck
-
-
-stamp: $(binaries) $(OUTPUT)
-	touch stamp
-
-$(OUTPUT): Makefile
-
-
-include $(OUTPUT).d
-
-$(OUTPUT).d: $(srcdir)/src/lib.rs $(foreach subdir,$(SUBDIRS),$(subdir)/stamp)
-	$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-$(OUTPUT): $(srcdir)/src/lib.rs $(foreach subdir,$(SUBDIRS),$(subdir)/stamp)
-	+$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d --emit link=@abs_builddir@/$(OUTPUT) -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-include $(foreach bin,$(binary_outputs),$(bin).d)
-
-$(foreach out,$(binary_outputs),$(out).d): %@EXEEXT@.d: $(srcdir)/src/bin/%.rs $(OUTPUT)
-	$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS)$(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@ -o$*@EXEEXT@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-$(binary_outputs): %@EXEEXT@: $(srcdir)/src/bin/%.rs $(OUTPUT)
-	+$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-clean: $(foreach subdir,$(SUBDIRS),$(subdir)/clean)
-	rm -f $(OUTPUT) $(binary_outputs) test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=%@EXEEXT@) stamp
-
-distclean: clean $(foreach subdir,$(SUBDIRS),$(subdir)/distclean)
-	rm -f config.status config.log $(OUTPUT).d test-$(OUTPUT:%.rlib=%@EXEEXT@).d $(foreach out,$(binary_outputs),$(out).d) Makefile
-
-$(binary_outputs:%=install-%): install-%: %
-	$(INSTALL) -m755 $< ${bindir}/
-
-$(binary_outputs:%=install-strip-%): install-strip-%: %
-	$(INSTALL) -s -m755 $< ${bindir}/
-
-install: $(binary_outputs:%=install-%) $(foreach subdir,$(SUBDIRS),$(subdir)/install)
-
-install-strip: $(binary_outputs:%=install-strip-%) $(foreach subdir,$(SUBDIRS),$(subdir)/install-strip)
-
-include test-$(OUTPUT:%.rlib=%@EXEEXT@).d
-
-tests/:
-	mkdir tests/
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@).d: $(srcdir)/src/lib.rs
-	$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS)  $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d -otest-$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@): $(srcdir)/src/lib.rs
-	+$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS)  $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d --emit link=@abs_builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) -o$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-$(tests:%.rs=%@EXEEXT@): %@EXEEXT@: $(srcdir)/%.rs $(OUTPUT) tests/
-	+$(RUSTC) $(RUSTFLAGS) $(EXTRA_RUSTFLAGS) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$(*F)) --test --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-check: @builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=@builddir@/%@EXEEXT@) $(foreach subdir,$(SUBDIRS),$(subdir)/check)
-	$(srcdir)/run-tests.sh $(foreach file,$^,@builddir@/$(file))
-
-%/stamp: %/Makefile
-	+$(MAKE) -C $* stamp
-
-%/clean:
-	+$(MAKE) -C $* clean
-
-%/install:
-	+$(MAKE) -C $* install
-%/install:
-	+$(MAKE) -C $* install-strip
-
-%/check:
-	+$(MAKE) -C $* check
diff --git a/vendor/fake-enum/README.md b/vendor/fake-enum/README.md
deleted file mode 100644
index e2cf23f9..00000000
--- a/vendor/fake-enum/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Rust Fake Enums
-
-A small library that allows you to declare "fake" enums, which can be safely used with FFI,
- or reinterpreted from bytes sourced from a user-controlled input. 
-
-## License
-
-Copyright (C) 2021 Connor Horman
-
-This repository is dual licensed under the terms of the MIT and Apachev2 license. If you deal in the software, you must comply with the terms of both licenses. 
-
-Any contributions intentionally submitted by you for inclusion in this repository must be dual licensed as above. 
-
diff --git a/vendor/fake-enum/aclocal.m4 b/vendor/fake-enum/aclocal.m4
deleted file mode 100644
index 2823c249..00000000
--- a/vendor/fake-enum/aclocal.m4
+++ /dev/null
@@ -1,16 +0,0 @@
-# generated automatically by aclocal 1.16.3 -*- Autoconf -*-
-
-# Copyright (C) 1996-2020 Free Software Foundation, Inc.
-
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
-m4_include([m4/lcrust_checks.m4])
-m4_include([m4/lcrust_prog_rustc.m4])
diff --git a/vendor/fake-enum/build-dirs.sh b/vendor/fake-enum/build-dirs.sh
deleted file mode 100755
index e5079d95..00000000
--- a/vendor/fake-enum/build-dirs.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-for s in $*
-do
-    ${MAKE} -C $s
-done
\ No newline at end of file
diff --git a/vendor/fake-enum/config.guess b/vendor/fake-enum/config.guess
deleted file mode 100755
index 1972fda8..00000000
--- a/vendor/fake-enum/config.guess
+++ /dev/null
@@ -1,1700 +0,0 @@
-#! /bin/sh
-# Attempt to guess a canonical system name.
-#   Copyright 1992-2021 Free Software Foundation, Inc.
-
-timestamp='2021-01-25'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-#
-# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
-#
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
-#
-# Please send patches to <config-patches@gnu.org>.
-
-
-me=$(echo "$0" | sed -e 's,.*/,,')
-
-usage="\
-Usage: $0 [OPTION]
-
-Output the configuration name of the system \`$me' is run on.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.guess ($timestamp)
-
-Originally written by Per Bothner.
-Copyright 1992-2021 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-    * )
-       break ;;
-  esac
-done
-
-if test $# != 0; then
-  echo "$me: too many arguments$help" >&2
-  exit 1
-fi
-
-# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
-# compiler to aid in system detection is discouraged as it requires
-# temporary files to be created and, as you can see below, it is a
-# headache to deal with in a portable fashion.
-
-# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
-# use `HOST_CC' if defined, but it is deprecated.
-
-# Portable tmp directory creation inspired by the Autoconf team.
-
-tmp=
-# shellcheck disable=SC2172
-trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15
-
-set_cc_for_build() {
-    # prevent multiple calls if $tmp is already set
-    test "$tmp" && return 0
-    : "${TMPDIR=/tmp}"
-    # shellcheck disable=SC2039
-    { tmp=$( (umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null) && test -n "$tmp" && test -d "$tmp" ; } ||
-	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } ||
-	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } ||
-	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; }
-    dummy=$tmp/dummy
-    case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in
-	,,)    echo "int x;" > "$dummy.c"
-	       for driver in cc gcc c89 c99 ; do
-		   if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-		       CC_FOR_BUILD="$driver"
-		       break
-		   fi
-	       done
-	       if test x"$CC_FOR_BUILD" = x ; then
-		   CC_FOR_BUILD=no_compiler_found
-	       fi
-	       ;;
-	,,*)   CC_FOR_BUILD=$CC ;;
-	,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-    esac
-}
-
-# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 1994-08-24)
-if test -f /.attbin/uname ; then
-	PATH=$PATH:/.attbin ; export PATH
-fi
-
-UNAME_MACHINE=$( (uname -m) 2>/dev/null) || UNAME_MACHINE=unknown
-UNAME_RELEASE=$( (uname -r) 2>/dev/null) || UNAME_RELEASE=unknown
-UNAME_SYSTEM=$( (uname -s) 2>/dev/null) || UNAME_SYSTEM=unknown
-UNAME_VERSION=$( (uname -v) 2>/dev/null) || UNAME_VERSION=unknown
-
-case "$UNAME_SYSTEM" in
-Linux|GNU|GNU/*)
-	LIBC=unknown
-
-	set_cc_for_build
-	cat <<-EOF > "$dummy.c"
-	#include <features.h>
-	#if defined(__UCLIBC__)
-	LIBC=uclibc
-	#elif defined(__dietlibc__)
-	LIBC=dietlibc
-	#elif defined(__GLIBC__)
-	LIBC=gnu
-	#else
-	#include <stdarg.h>
-	/* First heuristic to detect musl libc.  */
-	#ifdef __DEFINED_va_list
-	LIBC=musl
-	#endif
-	#endif
-	EOF
-	eval "$($CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g')"
-
-	# Second heuristic to detect musl libc.
-	if [ "$LIBC" = unknown ] &&
-	   command -v ldd >/dev/null &&
-	   ldd --version 2>&1 | grep -q ^musl; then
-		LIBC=musl
-	fi
-
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	if [ "$LIBC" = unknown ]; then
-		LIBC=gnu
-	fi
-	;;
-esac
-
-# Note: order is significant - the case branches are not exclusive.
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
-    *:NetBSD:*:*)
-	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
-	# switched to ELF, *-*-netbsd* would select the old
-	# object file format.  This provides both forward
-	# compatibility and a consistent mechanism for selecting the
-	# object file format.
-	#
-	# Note: NetBSD doesn't particularly care about the vendor
-	# portion of the name.  We always set it to "unknown".
-	UNAME_MACHINE_ARCH=$( (uname -p 2>/dev/null || \
-	    /sbin/sysctl -n hw.machine_arch 2>/dev/null || \
-	    /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
-	    echo unknown))
-	case "$UNAME_MACHINE_ARCH" in
-	    aarch64eb) machine=aarch64_be-unknown ;;
-	    armeb) machine=armeb-unknown ;;
-	    arm*) machine=arm-unknown ;;
-	    sh3el) machine=shl-unknown ;;
-	    sh3eb) machine=sh-unknown ;;
-	    sh5el) machine=sh5le-unknown ;;
-	    earmv*)
-		arch=$(echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,')
-		endian=$(echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p')
-		machine="${arch}${endian}"-unknown
-		;;
-	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
-	esac
-	# The Operating System including object format, if it has switched
-	# to ELF recently (or will in the future) and ABI.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		os=netbsdelf
-		;;
-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		set_cc_for_build
-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep -q __ELF__
-		then
-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-		    # Return netbsd for either.  FIX?
-		    os=netbsd
-		else
-		    os=netbsdelf
-		fi
-		;;
-	    *)
-		os=netbsd
-		;;
-	esac
-	# Determine ABI tags.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=$(echo "$UNAME_MACHINE_ARCH" | sed -e "$expr")
-		;;
-	esac
-	# The OS release
-	# Debian GNU/NetBSD machines have a different userland, and
-	# thus, need a distinct triplet. However, they do not need
-	# kernel version information, so it can be replaced with a
-	# suitable tag, in the style of linux-gnu.
-	case "$UNAME_VERSION" in
-	    Debian*)
-		release='-gnu'
-		;;
-	    *)
-		release=$(echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2)
-		;;
-	esac
-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
-	# contains redundant information, the shorter form:
-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "$machine-${os}${release}${abi-}"
-	exit ;;
-    *:Bitrig:*:*)
-	UNAME_MACHINE_ARCH=$(arch | sed 's/Bitrig.//')
-	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
-	exit ;;
-    *:OpenBSD:*:*)
-	UNAME_MACHINE_ARCH=$(arch | sed 's/OpenBSD.//')
-	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
-	exit ;;
-    *:LibertyBSD:*:*)
-	UNAME_MACHINE_ARCH=$(arch | sed 's/^.*BSD\.//')
-	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
-	exit ;;
-    *:MidnightBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
-	exit ;;
-    *:ekkoBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
-	exit ;;
-    *:SolidBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
-	exit ;;
-    *:OS108:*:*)
-	echo "$UNAME_MACHINE"-unknown-os108_"$UNAME_RELEASE"
-	exit ;;
-    macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:MirBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:Sortix:*:*)
-	echo "$UNAME_MACHINE"-unknown-sortix
-	exit ;;
-    *:Twizzler:*:*)
-	echo "$UNAME_MACHINE"-unknown-twizzler
-	exit ;;
-    *:Redox:*:*)
-	echo "$UNAME_MACHINE"-unknown-redox
-	exit ;;
-    mips:OSF1:*.*)
-	echo mips-dec-osf1
-	exit ;;
-    alpha:OSF1:*:*)
-	case $UNAME_RELEASE in
-	*4.0)
-		UNAME_RELEASE=$(/usr/sbin/sizer -v | awk '{print $3}')
-		;;
-	*5.*)
-		UNAME_RELEASE=$(/usr/sbin/sizer -v | awk '{print $4}')
-		;;
-	esac
-	# According to Compaq, /usr/sbin/psrinfo has been available on
-	# OSF/1 and Tru64 systems produced since 1995.  I hope that
-	# covers most systems running today.  This code pipes the CPU
-	# types through head -n 1, so we only detect the type of CPU 0.
-	ALPHA_CPU_TYPE=$(/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1)
-	case "$ALPHA_CPU_TYPE" in
-	    "EV4 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "EV4.5 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "LCA4 (21066/21068)")
-		UNAME_MACHINE=alpha ;;
-	    "EV5 (21164)")
-		UNAME_MACHINE=alphaev5 ;;
-	    "EV5.6 (21164A)")
-		UNAME_MACHINE=alphaev56 ;;
-	    "EV5.6 (21164PC)")
-		UNAME_MACHINE=alphapca56 ;;
-	    "EV5.7 (21164PC)")
-		UNAME_MACHINE=alphapca57 ;;
-	    "EV6 (21264)")
-		UNAME_MACHINE=alphaev6 ;;
-	    "EV6.7 (21264A)")
-		UNAME_MACHINE=alphaev67 ;;
-	    "EV6.8CB (21264C)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8AL (21264B)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8CX (21264D)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE=alphaev69 ;;
-	    "EV7 (21364)")
-		UNAME_MACHINE=alphaev7 ;;
-	    "EV7.9 (21364A)")
-		UNAME_MACHINE=alphaev79 ;;
-	esac
-	# A Pn.n version is a patched version.
-	# A Vn.n version is a released version.
-	# A Tn.n version is a released field test version.
-	# A Xn.n version is an unreleased experimental baselevel.
-	# 1.2 uses "1.2" for uname -r.
-	echo "$UNAME_MACHINE"-dec-osf"$(echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz)"
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
-    Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
-    *:[Aa]miga[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-amigaos
-	exit ;;
-    *:[Mm]orph[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-morphos
-	exit ;;
-    *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
-    *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
-    *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix"$UNAME_RELEASE"
-	exit ;;
-    arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "$( (/bin/universe) 2>/dev/null)" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
-    NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
-    DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
-	case $(/usr/bin/uname -p) in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
-    s390x:SunOS:*:*)
-	echo "$UNAME_MACHINE"-ibm-solaris2"$(echo "$UNAME_RELEASE" | sed -e 's/[^.]*//')"
-	exit ;;
-    sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2"$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*//')"
-	exit ;;
-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2"$(echo "$UNAME_RELEASE" | sed -e 's/[^.]*//')"
-	exit ;;
-    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux"$UNAME_RELEASE"
-	exit ;;
-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	set_cc_for_build
-	SUN_ARCH=i386
-	# If there is a compiler, see if it is configured for 64-bit objects.
-	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
-	# This test works for both compilers.
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		SUN_ARCH=x86_64
-	    fi
-	fi
-	echo "$SUN_ARCH"-pc-solaris2"$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*//')"
-	exit ;;
-    sun4*:SunOS:6*:*)
-	# According to config.sub, this is the proper way to canonicalize
-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
-	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3"$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*//')"
-	exit ;;
-    sun4*:SunOS:*:*)
-	case "$(/usr/bin/arch -k)" in
-	    Series*|S4*)
-		UNAME_RELEASE=$(uname -v)
-		;;
-	esac
-	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos"$(echo "$UNAME_RELEASE"|sed -e 's/-/_/')"
-	exit ;;
-    sun3*:SunOS:*:*)
-	echo m68k-sun-sunos"$UNAME_RELEASE"
-	exit ;;
-    sun*:*:4.2BSD:*)
-	UNAME_RELEASE=$( (sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null)
-	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case "$(/bin/arch)" in
-	    sun3)
-		echo m68k-sun-sunos"$UNAME_RELEASE"
-		;;
-	    sun4)
-		echo sparc-sun-sunos"$UNAME_RELEASE"
-		;;
-	esac
-	exit ;;
-    aushp:SunOS:*:*)
-	echo sparc-auspex-sunos"$UNAME_RELEASE"
-	exit ;;
-    # The situation for MiNT is a little confusing.  The machine name
-    # can be virtually everything (everything which is not
-    # "atarist" or "atariste" at least should have a processor
-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
-    # to the lowercase version "mint" (or "freemint").  Finally
-    # the system name "TOS" denotes a system which is actually not
-    # MiNT.  But MiNT is downward compatible to TOS, so this should
-    # be no problem.
-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint"$UNAME_RELEASE"
-	exit ;;
-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint"$UNAME_RELEASE"
-	exit ;;
-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint"$UNAME_RELEASE"
-	exit ;;
-    m68k:machten:*:*)
-	echo m68k-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    powerpc:machten:*:*)
-	echo powerpc-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
-    RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix"$UNAME_RELEASE"
-	exit ;;
-    mips:*:*:UMIPS | mips:*:*:RISCos)
-	set_cc_for_build
-	sed 's/^	//' << EOF > "$dummy.c"
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-	#if defined (host_mips) && defined (MIPSEB)
-	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
-	#endif
-	#endif
-	  exit (-1);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
-	  dummyarg=$(echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p') &&
-	  SYSTEM_NAME=$("$dummy" "$dummyarg") &&
-	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos"$UNAME_RELEASE"
-	exit ;;
-    Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
-    Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
-    m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
-    m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
-    m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
-    AViiON:dgux:*:*)
-	# DG/UX returns AViiON for all architectures
-	UNAME_PROCESSOR=$(/usr/bin/uname -p)
-	if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110
-	then
-	    if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \
-	       test "$TARGET_BINARY_INTERFACE"x = x
-	    then
-		echo m88k-dg-dgux"$UNAME_RELEASE"
-	    else
-		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
-	    fi
-	else
-	    echo i586-dg-dgux"$UNAME_RELEASE"
-	fi
-	exit ;;
-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
-    M88*:*:R3*:*)
-	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
-    *:IRIX*:*:*)
-	echo mips-sgi-irix"$(echo "$UNAME_RELEASE"|sed -e 's/-/_/g')"
-	exit ;;
-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'$(uname -s)'" gives 'AIX '
-    i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
-    ia64:AIX:*:*)
-	if test -x /usr/bin/oslevel ; then
-		IBM_REV=$(/usr/bin/oslevel)
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:2:3)
-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		set_cc_for_build
-		sed 's/^		//' << EOF > "$dummy.c"
-		#include <sys/systemcfg.h>
-
-		main()
-			{
-			if (!__power_pc())
-				exit(1);
-			puts("powerpc-ibm-aix3.2.5");
-			exit(0);
-			}
-EOF
-		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=$("$dummy")
-		then
-			echo "$SYSTEM_NAME"
-		else
-			echo rs6000-ibm-aix3.2.5
-		fi
-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
-	else
-		echo rs6000-ibm-aix3.2
-	fi
-	exit ;;
-    *:AIX:*:[4567])
-	IBM_CPU_ID=$(/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }')
-	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
-		IBM_ARCH=rs6000
-	else
-		IBM_ARCH=powerpc
-	fi
-	if test -x /usr/bin/lslpp ; then
-		IBM_REV=$(/usr/bin/lslpp -Lqc bos.rte.libc |
-			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/)
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
-    *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
-    DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
-    9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
-    9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//')
-	case "$UNAME_MACHINE" in
-	    9000/31?)            HP_ARCH=m68000 ;;
-	    9000/[34]??)         HP_ARCH=m68k ;;
-	    9000/[678][0-9][0-9])
-		if test -x /usr/bin/getconf; then
-		    sc_cpu_version=$(/usr/bin/getconf SC_CPU_VERSION 2>/dev/null)
-		    sc_kernel_bits=$(/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null)
-		    case "$sc_cpu_version" in
-		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
-		      532)                      # CPU_PA_RISC2_0
-			case "$sc_kernel_bits" in
-			  32) HP_ARCH=hppa2.0n ;;
-			  64) HP_ARCH=hppa2.0w ;;
-			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
-			esac ;;
-		    esac
-		fi
-		if test "$HP_ARCH" = ""; then
-		    set_cc_for_build
-		    sed 's/^		//' << EOF > "$dummy.c"
-
-		#define _HPUX_SOURCE
-		#include <stdlib.h>
-		#include <unistd.h>
-
-		int main ()
-		{
-		#if defined(_SC_KERNEL_BITS)
-		    long bits = sysconf(_SC_KERNEL_BITS);
-		#endif
-		    long cpu  = sysconf (_SC_CPU_VERSION);
-
-		    switch (cpu)
-			{
-			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-			case CPU_PA_RISC2_0:
-		#if defined(_SC_KERNEL_BITS)
-			    switch (bits)
-				{
-				case 64: puts ("hppa2.0w"); break;
-				case 32: puts ("hppa2.0n"); break;
-				default: puts ("hppa2.0"); break;
-				} break;
-		#else  /* !defined(_SC_KERNEL_BITS) */
-			    puts ("hppa2.0"); break;
-		#endif
-			default: puts ("hppa1.0"); break;
-			}
-		    exit (0);
-		}
-EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=$("$dummy")
-		    test -z "$HP_ARCH" && HP_ARCH=hppa
-		fi ;;
-	esac
-	if test "$HP_ARCH" = hppa2.0w
-	then
-	    set_cc_for_build
-
-	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
-	    # generating 64-bit code.  GNU and HP use different nomenclature:
-	    #
-	    # $ CC_FOR_BUILD=cc ./config.guess
-	    # => hppa2.0w-hp-hpux11.23
-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
-	    # => hppa64-hp-hpux11.23
-
-	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep -q __LP64__
-	    then
-		HP_ARCH=hppa2.0w
-	    else
-		HP_ARCH=hppa64
-	    fi
-	fi
-	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
-	exit ;;
-    ia64:HP-UX:*:*)
-	HPUX_REV=$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//')
-	echo ia64-hp-hpux"$HPUX_REV"
-	exit ;;
-    3050*:HI-UX:*:*)
-	set_cc_for_build
-	sed 's/^	//' << EOF > "$dummy.c"
-	#include <unistd.h>
-	int
-	main ()
-	{
-	  long cpu = sysconf (_SC_CPU_VERSION);
-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
-	     results, however.  */
-	  if (CPU_IS_PA_RISC (cpu))
-	    {
-	      switch (cpu)
-		{
-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
-		  default: puts ("hppa-hitachi-hiuxwe2"); break;
-		}
-	    }
-	  else if (CPU_IS_HP_MC68K (cpu))
-	    puts ("m68k-hitachi-hiuxwe2");
-	  else puts ("unknown-hitachi-hiuxwe2");
-	  exit (0);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=$("$dummy") &&
-		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	echo hppa1.1-hp-bsd
-	exit ;;
-    9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	echo hppa1.1-hp-osf
-	exit ;;
-    hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
-    i*86:OSF1:*:*)
-	if test -x /usr/sbin/sysversion ; then
-	    echo "$UNAME_MACHINE"-unknown-osf1mk
-	else
-	    echo "$UNAME_MACHINE"-unknown-osf1
-	fi
-	exit ;;
-    parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
-    CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*[A-Z]90:*:*:*)
-	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-	      -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*TS:*:*:*)
-	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=$(uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz)
-	FUJITSU_SYS=$(uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///')
-	FUJITSU_REL=$(echo "$UNAME_RELEASE" | sed -e 's/ /_/')
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=$(uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///')
-	FUJITSU_REL=$(echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/')
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
-	exit ;;
-    sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:BSD/OS:*:*)
-	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    arm:FreeBSD:*:*)
-	UNAME_PROCESSOR=$(uname -p)
-	set_cc_for_build
-	if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_PCS_VFP
-	then
-	    echo "${UNAME_PROCESSOR}"-unknown-freebsd"$(echo ${UNAME_RELEASE}|sed -e 's/[-(].*//')"-gnueabi
-	else
-	    echo "${UNAME_PROCESSOR}"-unknown-freebsd"$(echo ${UNAME_RELEASE}|sed -e 's/[-(].*//')"-gnueabihf
-	fi
-	exit ;;
-    *:FreeBSD:*:*)
-	UNAME_PROCESSOR=$(/usr/bin/uname -p)
-	case "$UNAME_PROCESSOR" in
-	    amd64)
-		UNAME_PROCESSOR=x86_64 ;;
-	    i386)
-		UNAME_PROCESSOR=i586 ;;
-	esac
-	echo "$UNAME_PROCESSOR"-unknown-freebsd"$(echo "$UNAME_RELEASE"|sed -e 's/[-(].*//')"
-	exit ;;
-    i*:CYGWIN*:*)
-	echo "$UNAME_MACHINE"-pc-cygwin
-	exit ;;
-    *:MINGW64*:*)
-	echo "$UNAME_MACHINE"-pc-mingw64
-	exit ;;
-    *:MINGW*:*)
-	echo "$UNAME_MACHINE"-pc-mingw32
-	exit ;;
-    *:MSYS*:*)
-	echo "$UNAME_MACHINE"-pc-msys
-	exit ;;
-    i*:PW*:*)
-	echo "$UNAME_MACHINE"-pc-pw32
-	exit ;;
-    *:Interix*:*)
-	case "$UNAME_MACHINE" in
-	    x86)
-		echo i586-pc-interix"$UNAME_RELEASE"
-		exit ;;
-	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	    IA64)
-		echo ia64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	esac ;;
-    i*:UWIN*:*)
-	echo "$UNAME_MACHINE"-pc-uwin
-	exit ;;
-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-pc-cygwin
-	exit ;;
-    prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2"$(echo "$UNAME_RELEASE"|sed -e 's/[^.]*//')"
-	exit ;;
-    *:GNU:*:*)
-	# the GNU system
-	echo "$(echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,')-unknown-$LIBC$(echo "$UNAME_RELEASE"|sed -e 's,/.*$,,')"
-	exit ;;
-    *:GNU/*:*:*)
-	# other systems with GNU libc and userland
-	echo "$UNAME_MACHINE-unknown-$(echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]")$(echo "$UNAME_RELEASE"|sed -e 's/[-(].*//')-$LIBC"
-	exit ;;
-    *:Minix:*:*)
-	echo "$UNAME_MACHINE"-unknown-minix
-	exit ;;
-    aarch64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    aarch64_be:Linux:*:*)
-	UNAME_MACHINE=aarch64_be
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    alpha:Linux:*:*)
-	case $(sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null) in
-	  EV5)   UNAME_MACHINE=alphaev5 ;;
-	  EV56)  UNAME_MACHINE=alphaev56 ;;
-	  PCA56) UNAME_MACHINE=alphapca56 ;;
-	  PCA57) UNAME_MACHINE=alphapca56 ;;
-	  EV6)   UNAME_MACHINE=alphaev6 ;;
-	  EV67)  UNAME_MACHINE=alphaev67 ;;
-	  EV68*) UNAME_MACHINE=alphaev68 ;;
-	esac
-	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arm*:Linux:*:*)
-	set_cc_for_build
-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_EABI__
-	then
-	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	else
-	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep -q __ARM_PCS_VFP
-	    then
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
-	    else
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
-	    fi
-	fi
-	exit ;;
-    avr32*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    cris:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    crisv32:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    e2k:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    frv:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    hexagon:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:Linux:*:*)
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	exit ;;
-    ia64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    k1om:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m32r*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m68*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    mips:Linux:*:* | mips64:Linux:*:*)
-	set_cc_for_build
-	IS_GLIBC=0
-	test x"${LIBC}" = xgnu && IS_GLIBC=1
-	sed 's/^	//' << EOF > "$dummy.c"
-	#undef CPU
-	#undef mips
-	#undef mipsel
-	#undef mips64
-	#undef mips64el
-	#if ${IS_GLIBC} && defined(_ABI64)
-	LIBCABI=gnuabi64
-	#else
-	#if ${IS_GLIBC} && defined(_ABIN32)
-	LIBCABI=gnuabin32
-	#else
-	LIBCABI=${LIBC}
-	#endif
-	#endif
-
-	#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
-	CPU=mipsisa64r6
-	#else
-	#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
-	CPU=mipsisa32r6
-	#else
-	#if defined(__mips64)
-	CPU=mips64
-	#else
-	CPU=mips
-	#endif
-	#endif
-	#endif
-
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	MIPS_ENDIAN=el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	MIPS_ENDIAN=
-	#else
-	MIPS_ENDIAN=
-	#endif
-	#endif
-EOF
-	eval "$($CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI')"
-	test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; }
-	;;
-    mips64el:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-"$LIBC"
-	exit ;;
-    or32:Linux:*:* | or1k*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    padre:Linux:*:*)
-	echo sparc-unknown-linux-"$LIBC"
-	exit ;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-"$LIBC"
-	exit ;;
-    parisc:Linux:*:* | hppa:Linux:*:*)
-	# Look for CPU level
-	case $(grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2) in
-	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
-	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
-	  *)    echo hppa-unknown-linux-"$LIBC" ;;
-	esac
-	exit ;;
-    ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-"$LIBC"
-	exit ;;
-    ppc:Linux:*:*)
-	echo powerpc-unknown-linux-"$LIBC"
-	exit ;;
-    ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-"$LIBC"
-	exit ;;
-    ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-"$LIBC"
-	exit ;;
-    riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    s390:Linux:*:* | s390x:Linux:*:*)
-	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
-	exit ;;
-    sh64*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sh*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    tile*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    vax:Linux:*:*)
-	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
-	exit ;;
-    x86_64:Linux:*:*)
-	set_cc_for_build
-	LIBCABI=$LIBC
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_X32 >/dev/null
-	    then
-		LIBCABI="$LIBC"x32
-	    fi
-	fi
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBCABI"
-	exit ;;
-    xtensa*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:DYNIX/ptx:4*:*)
-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
-	# earlier versions are messed up and put the nodename in both
-	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
-    i*86:UNIX_SV:4.2MP:2.*)
-	# Unixware is an offshoot of SVR4, but it has its own version
-	# number series starting with 2...
-	# I am not positive that other SVR4 systems won't match this,
-	# I just have to hope.  -- rms.
-	# Use sysv4.2uw... so that sysv4* matches it.
-	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
-	exit ;;
-    i*86:OS/2:*:*)
-	# If we were able to find `uname', then EMX Unix compatibility
-	# is probably installed.
-	echo "$UNAME_MACHINE"-pc-os2-emx
-	exit ;;
-    i*86:XTS-300:*:STOP)
-	echo "$UNAME_MACHINE"-unknown-stop
-	exit ;;
-    i*86:atheos:*:*)
-	echo "$UNAME_MACHINE"-unknown-atheos
-	exit ;;
-    i*86:syllable:*:*)
-	echo "$UNAME_MACHINE"-pc-syllable
-	exit ;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    i*86:*DOS:*:*)
-	echo "$UNAME_MACHINE"-pc-msdosdjgpp
-	exit ;;
-    i*86:*:4.*:*)
-	UNAME_REL=$(echo "$UNAME_RELEASE" | sed 's/\/MP$//')
-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
-	fi
-	exit ;;
-    i*86:*:5:[678]*)
-	# UnixWare 7.x, OpenUNIX and OpenServer 6.
-	case $(/bin/uname -X | grep "^Machine") in
-	    *486*)	     UNAME_MACHINE=i486 ;;
-	    *Pentium)	     UNAME_MACHINE=i586 ;;
-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
-	esac
-	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}"
-	exit ;;
-    i*86:*:3.2:*)
-	if test -f /usr/options/cb.name; then
-		UNAME_REL=$(sed -n 's/.*Version //p' </usr/options/cb.name)
-		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
-	elif /bin/uname -X 2>/dev/null >/dev/null ; then
-		UNAME_REL=$( (/bin/uname -X|grep Release|sed -e 's/.*= //'))
-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
-			&& UNAME_MACHINE=i586
-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv32
-	fi
-	exit ;;
-    pc:*:*:*)
-	# Left here for compatibility:
-	# uname -m prints for DJGPP always 'pc', but it prints nothing about
-	# the processor, so we play safe by assuming i586.
-	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configure will decide that
-	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
-    Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
-    paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
-    i860:*:4.*:*) # i860-SVR4
-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
-	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
-	fi
-	exit ;;
-    mini*:CTIX:SYS*5:*)
-	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
-    mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
-    M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
-    M68*:*:R3V[5678]*:*)
-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
-	OS_REL=''
-	test -r /etc/.relid \
-	&& OS_REL=.$(sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4; exit; } ;;
-    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
-	OS_REL='.3'
-	test -r /etc/.relid \
-	    && OS_REL=.$(sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
-    TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv"$UNAME_RELEASE"
-	exit ;;
-    RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    *:SINIX-*:*:*)
-	if uname -p 2>/dev/null >/dev/null ; then
-		UNAME_MACHINE=$( (uname -p) 2>/dev/null)
-		echo "$UNAME_MACHINE"-sni-sysv4
-	else
-		echo ns32k-sni-sysv
-	fi
-	exit ;;
-    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
-    *:UNIX_System_V:4*:FTX*)
-	# From Gerald Hewes <hewes@openmarket.com>.
-	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
-    *:*:*:FTX*)
-	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
-    i*86:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo "$UNAME_MACHINE"-stratus-vos
-	exit ;;
-    *:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
-    mc68*:A/UX:*:*)
-	echo m68k-apple-aux"$UNAME_RELEASE"
-	exit ;;
-    news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if test -d /usr/nec; then
-		echo mips-nec-sysv"$UNAME_RELEASE"
-	else
-		echo mips-unknown-sysv"$UNAME_RELEASE"
-	fi
-	exit ;;
-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
-    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
-    x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
-    SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Rhapsody:*:*)
-	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    arm64:Darwin:*:*)
-	echo aarch64-apple-darwin"$UNAME_RELEASE"
-	exit ;;
-    *:Darwin:*:*)
-	UNAME_PROCESSOR=$(uname -p)
-	case $UNAME_PROCESSOR in
-	    unknown) UNAME_PROCESSOR=powerpc ;;
-	esac
-	if command -v xcode-select > /dev/null 2> /dev/null && \
-		! xcode-select --print-path > /dev/null 2> /dev/null ; then
-	    # Avoid executing cc if there is no toolchain installed as
-	    # cc will be a stub that puts up a graphical alert
-	    # prompting the user to install developer tools.
-	    CC_FOR_BUILD=no_compiler_found
-	else
-	    set_cc_for_build
-	fi
-	if test "$CC_FOR_BUILD" != no_compiler_found; then
-	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		   grep IS_64BIT_ARCH >/dev/null
-	    then
-		case $UNAME_PROCESSOR in
-		    i386) UNAME_PROCESSOR=x86_64 ;;
-		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		esac
-	    fi
-	    # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-	    if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		   grep IS_PPC >/dev/null
-	    then
-		UNAME_PROCESSOR=powerpc
-	    fi
-	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # uname -m returns i386 or x86_64
-	    UNAME_PROCESSOR=$UNAME_MACHINE
-	fi
-	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
-	exit ;;
-    *:procnto*:*:* | *:QNX:[0123456789]*:*)
-	UNAME_PROCESSOR=$(uname -p)
-	if test "$UNAME_PROCESSOR" = x86; then
-		UNAME_PROCESSOR=i386
-		UNAME_MACHINE=pc
-	fi
-	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
-	exit ;;
-    *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
-    NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSV-*:NONSTOP_KERNEL:*:*)
-	echo nsv-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
-    BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
-    DS/*:UNIX_System_V:*:*)
-	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
-	exit ;;
-    *:Plan9:*:*)
-	# "uname -m" is not consistent, so use $cputype instead. 386
-	# is converted to i386 for consistency with other x86
-	# operating systems.
-	# shellcheck disable=SC2154
-	if test "$cputype" = 386; then
-	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
-	fi
-	echo "$UNAME_MACHINE"-unknown-plan9
-	exit ;;
-    *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
-    *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
-    *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
-    *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
-    SEI:*:*:SEIUX)
-	echo mips-sei-seiux"$UNAME_RELEASE"
-	exit ;;
-    *:DragonFly:*:*)
-	echo "$UNAME_MACHINE"-unknown-dragonfly"$(echo "$UNAME_RELEASE"|sed -e 's/[-(].*//')"
-	exit ;;
-    *:*VMS:*:*)
-	UNAME_MACHINE=$( (uname -p) 2>/dev/null)
-	case "$UNAME_MACHINE" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
-	esac ;;
-    *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
-    i*86:skyos:*:*)
-	echo "$UNAME_MACHINE"-pc-skyos"$(echo "$UNAME_RELEASE" | sed -e 's/ .*$//')"
-	exit ;;
-    i*86:rdos:*:*)
-	echo "$UNAME_MACHINE"-pc-rdos
-	exit ;;
-    *:AROS:*:*)
-	echo "$UNAME_MACHINE"-unknown-aros
-	exit ;;
-    x86_64:VMkernel:*:*)
-	echo "$UNAME_MACHINE"-unknown-esx
-	exit ;;
-    amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
-    *:Unleashed:*:*)
-	echo "$UNAME_MACHINE"-unknown-unleashed"$UNAME_RELEASE"
-	exit ;;
-esac
-
-# No uname command or uname output not recognized.
-set_cc_for_build
-cat > "$dummy.c" <<EOF
-#ifdef _SEQUENT_
-#include <sys/types.h>
-#include <sys/utsname.h>
-#endif
-#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
-#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
-#include <signal.h>
-#if defined(_SIZE_T_) || defined(SIGLOST)
-#include <sys/utsname.h>
-#endif
-#endif
-#endif
-main ()
-{
-#if defined (sony)
-#if defined (MIPSEB)
-  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
-     I don't know....  */
-  printf ("mips-sony-bsd\n"); exit (0);
-#else
-#include <sys/param.h>
-  printf ("m68k-sony-newsos%s\n",
-#ifdef NEWSOS4
-  "4"
-#else
-  ""
-#endif
-  ); exit (0);
-#endif
-#endif
-
-#if defined (NeXT)
-#if !defined (__ARCHITECTURE__)
-#define __ARCHITECTURE__ "m68k"
-#endif
-  int version;
-  version=$( (hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null);
-  if (version < 4)
-    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
-  else
-    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
-  exit (0);
-#endif
-
-#if defined (MULTIMAX) || defined (n16)
-#if defined (UMAXV)
-  printf ("ns32k-encore-sysv\n"); exit (0);
-#else
-#if defined (CMU)
-  printf ("ns32k-encore-mach\n"); exit (0);
-#else
-  printf ("ns32k-encore-bsd\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (__386BSD__)
-  printf ("i386-pc-bsd\n"); exit (0);
-#endif
-
-#if defined (sequent)
-#if defined (i386)
-  printf ("i386-sequent-dynix\n"); exit (0);
-#endif
-#if defined (ns32000)
-  printf ("ns32k-sequent-dynix\n"); exit (0);
-#endif
-#endif
-
-#if defined (_SEQUENT_)
-  struct utsname un;
-
-  uname(&un);
-  if (strncmp(un.version, "V2", 2) == 0) {
-    printf ("i386-sequent-ptx2\n"); exit (0);
-  }
-  if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
-    printf ("i386-sequent-ptx1\n"); exit (0);
-  }
-  printf ("i386-sequent-ptx\n"); exit (0);
-#endif
-
-#if defined (vax)
-#if !defined (ultrix)
-#include <sys/param.h>
-#if defined (BSD)
-#if BSD == 43
-  printf ("vax-dec-bsd4.3\n"); exit (0);
-#else
-#if BSD == 199006
-  printf ("vax-dec-bsd4.3reno\n"); exit (0);
-#else
-  printf ("vax-dec-bsd\n"); exit (0);
-#endif
-#endif
-#else
-  printf ("vax-dec-bsd\n"); exit (0);
-#endif
-#else
-#if defined(_SIZE_T_) || defined(SIGLOST)
-  struct utsname un;
-  uname (&un);
-  printf ("vax-dec-ultrix%s\n", un.release); exit (0);
-#else
-  printf ("vax-dec-ultrix\n"); exit (0);
-#endif
-#endif
-#endif
-#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
-#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
-#if defined(_SIZE_T_) || defined(SIGLOST)
-  struct utsname *un;
-  uname (&un);
-  printf ("mips-dec-ultrix%s\n", un.release); exit (0);
-#else
-  printf ("mips-dec-ultrix\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (alliant) && defined (i860)
-  printf ("i860-alliant-bsd\n"); exit (0);
-#endif
-
-  exit (1);
-}
-EOF
-
-$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=$($dummy) &&
-	{ echo "$SYSTEM_NAME"; exit; }
-
-# Apollos put the system type in the environment.
-test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; }
-
-echo "$0: unable to guess system type" >&2
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM" in
-    mips:Linux | mips64:Linux)
-	# If we got here on MIPS GNU/Linux, output extra information.
-	cat >&2 <<EOF
-
-NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
-the system type. Please install a C compiler and try again.
-EOF
-	;;
-esac
-
-cat >&2 <<EOF
-
-This script (version $timestamp), has failed to recognize the
-operating system you are using. If your script is old, overwrite *all*
-copies of config.guess and config.sub with the latest versions from:
-
-  https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
-and
-  https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
-EOF
-
-year=$(echo $timestamp | sed 's,-.*,,')
-# shellcheck disable=SC2003
-if test "$(expr "$(date +%Y)" - "$year")" -lt 3 ; then
-   cat >&2 <<EOF
-
-If $0 has already been updated, send the following data and any
-information you think might be pertinent to config-patches@gnu.org to
-provide the necessary information to handle your system.
-
-config.guess timestamp = $timestamp
-
-uname -m = $( (uname -m) 2>/dev/null || echo unknown)
-uname -r = $( (uname -r) 2>/dev/null || echo unknown)
-uname -s = $( (uname -s) 2>/dev/null || echo unknown)
-uname -v = $( (uname -v) 2>/dev/null || echo unknown)
-
-/usr/bin/uname -p = $( (/usr/bin/uname -p) 2>/dev/null)
-/bin/uname -X     = $( (/bin/uname -X) 2>/dev/null)
-
-hostinfo               = $( (hostinfo) 2>/dev/null)
-/bin/universe          = $( (/bin/universe) 2>/dev/null)
-/usr/bin/arch -k       = $( (/usr/bin/arch -k) 2>/dev/null)
-/bin/arch              = $( (/bin/arch) 2>/dev/null)
-/usr/bin/oslevel       = $( (/usr/bin/oslevel) 2>/dev/null)
-/usr/convex/getsysinfo = $( (/usr/convex/getsysinfo) 2>/dev/null)
-
-UNAME_MACHINE = "$UNAME_MACHINE"
-UNAME_RELEASE = "$UNAME_RELEASE"
-UNAME_SYSTEM  = "$UNAME_SYSTEM"
-UNAME_VERSION = "$UNAME_VERSION"
-EOF
-fi
-
-exit 1
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/fake-enum/config.sub b/vendor/fake-enum/config.sub
deleted file mode 100755
index d52017ea..00000000
--- a/vendor/fake-enum/config.sub
+++ /dev/null
@@ -1,1879 +0,0 @@
-#! /bin/sh
-# Configuration validation subroutine script.
-#   Copyright 1992-2021 Free Software Foundation, Inc.
-
-timestamp='2021-05-03'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-
-
-# Please send patches to <config-patches@gnu.org>.
-#
-# Configuration subroutine to validate and canonicalize a configuration type.
-# Supply the specified configuration type as an argument.
-# If it is invalid, we print an error message on stderr and exit with code 1.
-# Otherwise, we print the canonical config type on stdout and succeed.
-
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
-
-# This file is supposed to be the same for all GNU packages
-# and recognize all the CPU types, system types and aliases
-# that are meaningful with *any* GNU software.
-# Each package is responsible for reporting which valid configurations
-# it does not support.  The user should be able to distinguish
-# a failure to support a valid configuration from a meaningless
-# configuration.
-
-# The goal of this file is to map all the various variations of a given
-# machine specification into a single specification in the form:
-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or in some cases, the newer four-part form:
-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# It is wrong to echo any other type of specification.
-
-me=$(echo "$0" | sed -e 's,.*/,,')
-
-usage="\
-Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
-
-Canonicalize a configuration name.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.sub ($timestamp)
-
-Copyright 1992-2021 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-
-    *local*)
-       # First pass through any local machine types.
-       echo "$1"
-       exit ;;
-
-    * )
-       break ;;
-  esac
-done
-
-case $# in
- 0) echo "$me: missing argument$help" >&2
-    exit 1;;
- 1) ;;
- *) echo "$me: too many arguments$help" >&2
-    exit 1;;
-esac
-
-# Split fields of configuration type
-# shellcheck disable=SC2162
-IFS="-" read field1 field2 field3 field4 <<EOF
-$1
-EOF
-
-# Separate into logical components for further validation
-case $1 in
-	*-*-*-*-*)
-		echo Invalid configuration \`"$1"\': more than four components >&2
-		exit 1
-		;;
-	*-*-*-*)
-		basic_machine=$field1-$field2
-		basic_os=$field3-$field4
-		;;
-	*-*-*)
-		# Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two
-		# parts
-		maybe_os=$field2-$field3
-		case $maybe_os in
-			nto-qnx* | linux-* | uclinux-uclibc* \
-			| uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \
-			| netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \
-			| storm-chaos* | os2-emx* | rtmk-nova* \
-			| phantom-kernel* | phantom-user* \
-			| snes*-elf* | snes*-xo65* | nes*-xo65* | snes*-coff*)
-				basic_machine=$field1
-				basic_os=$maybe_os
-				;;
-			android-linux)
-				basic_machine=$field1-unknown
-				basic_os=linux-android
-				;;
-			*)
-				basic_machine=$field1-$field2
-				basic_os=$field3
-				;;
-		esac
-		;;
-	*-*)
-		# A lone config we happen to match not fitting any pattern
-		case $field1-$field2 in
-			decstation-3100)
-				basic_machine=mips-dec
-				basic_os=
-				;;
-			*-*)
-				# Second component is usually, but not always the OS
-				case $field2 in
-					# Prevent following clause from handling this valid os
-					sun*os*)
-						basic_machine=$field1
-						basic_os=$field2
-						;;
-					# Manufacturers
-					dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \
-					| att* | 7300* | 3300* | delta* | motorola* | sun[234]* \
-					| unicom* | ibm* | next | hp | isi* | apollo | altos* \
-					| convergent* | ncr* | news | 32* | 3600* | 3100* \
-					| hitachi* | c[123]* | convex* | sun | crds | omron* | dg \
-					| ultra | tti* | harris | dolphin | highlevel | gould \
-					| cbm | ns | masscomp | apple | axis | knuth | cray \
-					| microblaze* | sim | cisco \
-					| oki | wec | wrs | winbond )
-						basic_machine=$field1-$field2
-						basic_os=
-						;;
-					*)
-						basic_machine=$field1
-						basic_os=$field2
-						;;
-				esac
-			;;
-		esac
-		;;
-	*)
-		# Convert single-component short-hands not valid as part of
-		# multi-component configurations.
-		case $field1 in
-			386bsd)
-				basic_machine=i386-pc
-				basic_os=bsd
-				;;
-			a29khif)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			adobe68k)
-				basic_machine=m68010-adobe
-				basic_os=scout
-				;;
-			alliant)
-				basic_machine=fx80-alliant
-				basic_os=
-				;;
-			altos | altos3068)
-				basic_machine=m68k-altos
-				basic_os=
-				;;
-			am29k)
-				basic_machine=a29k-none
-				basic_os=bsd
-				;;
-			amdahl)
-				basic_machine=580-amdahl
-				basic_os=sysv
-				;;
-			amiga)
-				basic_machine=m68k-unknown
-				basic_os=
-				;;
-			amigaos | amigados)
-				basic_machine=m68k-unknown
-				basic_os=amigaos
-				;;
-			amigaunix | amix)
-				basic_machine=m68k-unknown
-				basic_os=sysv4
-				;;
-			apollo68)
-				basic_machine=m68k-apollo
-				basic_os=sysv
-				;;
-			apollo68bsd)
-				basic_machine=m68k-apollo
-				basic_os=bsd
-				;;
-			aros)
-				basic_machine=i386-pc
-				basic_os=aros
-				;;
-			aux)
-				basic_machine=m68k-apple
-				basic_os=aux
-				;;
-			balance)
-				basic_machine=ns32k-sequent
-				basic_os=dynix
-				;;
-			blackfin)
-				basic_machine=bfin-unknown
-				basic_os=linux
-				;;
-			cegcc)
-				basic_machine=arm-unknown
-				basic_os=cegcc
-				;;
-			convex-c1)
-				basic_machine=c1-convex
-				basic_os=bsd
-				;;
-			convex-c2)
-				basic_machine=c2-convex
-				basic_os=bsd
-				;;
-			convex-c32)
-				basic_machine=c32-convex
-				basic_os=bsd
-				;;
-			convex-c34)
-				basic_machine=c34-convex
-				basic_os=bsd
-				;;
-			convex-c38)
-				basic_machine=c38-convex
-				basic_os=bsd
-				;;
-			cray)
-				basic_machine=j90-cray
-				basic_os=unicos
-				;;
-			crds | unos)
-				basic_machine=m68k-crds
-				basic_os=
-				;;
-			da30)
-				basic_machine=m68k-da30
-				basic_os=
-				;;
-			decstation | pmax | pmin | dec3100 | decstatn)
-				basic_machine=mips-dec
-				basic_os=
-				;;
-			delta88)
-				basic_machine=m88k-motorola
-				basic_os=sysv3
-				;;
-			dicos)
-				basic_machine=i686-pc
-				basic_os=dicos
-				;;
-			djgpp)
-				basic_machine=i586-pc
-				basic_os=msdosdjgpp
-				;;
-			ebmon29k)
-				basic_machine=a29k-amd
-				basic_os=ebmon
-				;;
-			es1800 | OSE68k | ose68k | ose | OSE)
-				basic_machine=m68k-ericsson
-				basic_os=ose
-				;;
-			gmicro)
-				basic_machine=tron-gmicro
-				basic_os=sysv
-				;;
-			go32)
-				basic_machine=i386-pc
-				basic_os=go32
-				;;
-			h8300hms)
-				basic_machine=h8300-hitachi
-				basic_os=hms
-				;;
-			h8300xray)
-				basic_machine=h8300-hitachi
-				basic_os=xray
-				;;
-			h8500hms)
-				basic_machine=h8500-hitachi
-				basic_os=hms
-				;;
-			harris)
-				basic_machine=m88k-harris
-				basic_os=sysv3
-				;;
-			hp300 | hp300hpux)
-				basic_machine=m68k-hp
-				basic_os=hpux
-				;;
-			hp300bsd)
-				basic_machine=m68k-hp
-				basic_os=bsd
-				;;
-			hppaosf)
-				basic_machine=hppa1.1-hp
-				basic_os=osf
-				;;
-			hppro)
-				basic_machine=hppa1.1-hp
-				basic_os=proelf
-				;;
-			i386mach)
-				basic_machine=i386-mach
-				basic_os=mach
-				;;
-			isi68 | isi)
-				basic_machine=m68k-isi
-				basic_os=sysv
-				;;
-			m68knommu)
-				basic_machine=m68k-unknown
-				basic_os=linux
-				;;
-			magnum | m3230)
-				basic_machine=mips-mips
-				basic_os=sysv
-				;;
-			merlin)
-				basic_machine=ns32k-utek
-				basic_os=sysv
-				;;
-			mingw64)
-				basic_machine=x86_64-pc
-				basic_os=mingw64
-				;;
-			mingw32)
-				basic_machine=i686-pc
-				basic_os=mingw32
-				;;
-			mingw32ce)
-				basic_machine=arm-unknown
-				basic_os=mingw32ce
-				;;
-			monitor)
-				basic_machine=m68k-rom68k
-				basic_os=coff
-				;;
-			morphos)
-				basic_machine=powerpc-unknown
-				basic_os=morphos
-				;;
-			moxiebox)
-				basic_machine=moxie-unknown
-				basic_os=moxiebox
-				;;
-			msdos)
-				basic_machine=i386-pc
-				basic_os=msdos
-				;;
-			msys)
-				basic_machine=i686-pc
-				basic_os=msys
-				;;
-			mvs)
-				basic_machine=i370-ibm
-				basic_os=mvs
-				;;
-			nacl)
-				basic_machine=le32-unknown
-				basic_os=nacl
-				;;
-			ncr3000)
-				basic_machine=i486-ncr
-				basic_os=sysv4
-				;;
-			netbsd386)
-				basic_machine=i386-pc
-				basic_os=netbsd
-				;;
-			netwinder)
-				basic_machine=armv4l-rebel
-				basic_os=linux
-				;;
-			news | news700 | news800 | news900)
-				basic_machine=m68k-sony
-				basic_os=newsos
-				;;
-			news1000)
-				basic_machine=m68030-sony
-				basic_os=newsos
-				;;
-			necv70)
-				basic_machine=v70-nec
-				basic_os=sysv
-				;;
-			nh3000)
-				basic_machine=m68k-harris
-				basic_os=cxux
-				;;
-			nh[45]000)
-				basic_machine=m88k-harris
-				basic_os=cxux
-				;;
-			nindy960)
-				basic_machine=i960-intel
-				basic_os=nindy
-				;;
-			mon960)
-				basic_machine=i960-intel
-				basic_os=mon960
-				;;
-			nonstopux)
-				basic_machine=mips-compaq
-				basic_os=nonstopux
-				;;
-			os400)
-				basic_machine=powerpc-ibm
-				basic_os=os400
-				;;
-			OSE68000 | ose68000)
-				basic_machine=m68000-ericsson
-				basic_os=ose
-				;;
-			os68k)
-				basic_machine=m68k-none
-				basic_os=os68k
-				;;
-			paragon)
-				basic_machine=i860-intel
-				basic_os=osf
-				;;
-			parisc)
-				basic_machine=hppa-unknown
-				basic_os=linux
-				;;
-			psp)
-				basic_machine=mipsallegrexel-sony
-				basic_os=psp
-				;;
-			pw32)
-				basic_machine=i586-unknown
-				basic_os=pw32
-				;;
-			rdos | rdos64)
-				basic_machine=x86_64-pc
-				basic_os=rdos
-				;;
-			rdos32)
-				basic_machine=i386-pc
-				basic_os=rdos
-				;;
-			rom68k)
-				basic_machine=m68k-rom68k
-				basic_os=coff
-				;;
-			sa29200)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			sei)
-				basic_machine=mips-sei
-				basic_os=seiux
-				;;
-			sequent)
-				basic_machine=i386-sequent
-				basic_os=
-				;;
-			snesdev)
-				basic_machine=wc65c816-snes
-				basic_os=elf
-				;;
-			sps7)
-				basic_machine=m68k-bull
-				basic_os=sysv2
-				;;
-			st2000)
-				basic_machine=m68k-tandem
-				basic_os=
-				;;
-			stratus)
-				basic_machine=i860-stratus
-				basic_os=sysv4
-				;;
-			sun2)
-				basic_machine=m68000-sun
-				basic_os=
-				;;
-			sun2os3)
-				basic_machine=m68000-sun
-				basic_os=sunos3
-				;;
-			sun2os4)
-				basic_machine=m68000-sun
-				basic_os=sunos4
-				;;
-			sun3)
-				basic_machine=m68k-sun
-				basic_os=
-				;;
-			sun3os3)
-				basic_machine=m68k-sun
-				basic_os=sunos3
-				;;
-			sun3os4)
-				basic_machine=m68k-sun
-				basic_os=sunos4
-				;;
-			sun4)
-				basic_machine=sparc-sun
-				basic_os=
-				;;
-			sun4os3)
-				basic_machine=sparc-sun
-				basic_os=sunos3
-				;;
-			sun4os4)
-				basic_machine=sparc-sun
-				basic_os=sunos4
-				;;
-			sun4sol2)
-				basic_machine=sparc-sun
-				basic_os=solaris2
-				;;
-			sun386 | sun386i | roadrunner)
-				basic_machine=i386-sun
-				basic_os=
-				;;
-			sv1)
-				basic_machine=sv1-cray
-				basic_os=unicos
-				;;
-			symmetry)
-				basic_machine=i386-sequent
-				basic_os=dynix
-				;;
-			t3e)
-				basic_machine=alphaev5-cray
-				basic_os=unicos
-				;;
-			t90)
-				basic_machine=t90-cray
-				basic_os=unicos
-				;;
-			toad1)
-				basic_machine=pdp10-xkl
-				basic_os=tops20
-				;;
-			tpf)
-				basic_machine=s390x-ibm
-				basic_os=tpf
-				;;
-			udi29k)
-				basic_machine=a29k-amd
-				basic_os=udi
-				;;
-			ultra3)
-				basic_machine=a29k-nyu
-				basic_os=sym1
-				;;
-			v810 | necv810)
-				basic_machine=v810-nec
-				basic_os=none
-				;;
-			vaxv)
-				basic_machine=vax-dec
-				basic_os=sysv
-				;;
-			vms)
-				basic_machine=vax-dec
-				basic_os=vms
-				;;
-			vsta)
-				basic_machine=i386-pc
-				basic_os=vsta
-				;;
-			vxworks960)
-				basic_machine=i960-wrs
-				basic_os=vxworks
-				;;
-			vxworks68)
-				basic_machine=m68k-wrs
-				basic_os=vxworks
-				;;
-			vxworks29k)
-				basic_machine=a29k-wrs
-				basic_os=vxworks
-				;;
-			xbox)
-				basic_machine=i686-pc
-				basic_os=mingw32
-				;;
-			ymp)
-				basic_machine=ymp-cray
-				basic_os=unicos
-				;;
-			*)
-				basic_machine=$1
-				basic_os=
-				;;
-		esac
-		;;
-esac
-
-# Decode 1-component or ad-hoc basic machines
-case $basic_machine in
-	# Here we handle the default manufacturer of certain CPU types.  It is in
-	# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		cpu=hppa1.1
-		vendor=winbond
-		;;
-	op50n)
-		cpu=hppa1.1
-		vendor=oki
-		;;
-	op60c)
-		cpu=hppa1.1
-		vendor=oki
-		;;
-	ibm*)
-		cpu=i370
-		vendor=ibm
-		;;
-	orion105)
-		cpu=clipper
-		vendor=highlevel
-		;;
-	mac | mpw | mac-mpw)
-		cpu=m68k
-		vendor=apple
-		;;
-	pmac | pmac-mpw)
-		cpu=powerpc
-		vendor=apple
-		;;
-
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		cpu=m68000
-		vendor=att
-		;;
-	3b*)
-		cpu=we32k
-		vendor=att
-		;;
-	bluegene*)
-		cpu=powerpc
-		vendor=ibm
-		basic_os=cnk
-		;;
-	decsystem10* | dec10*)
-		cpu=pdp10
-		vendor=dec
-		basic_os=tops10
-		;;
-	decsystem20* | dec20*)
-		cpu=pdp10
-		vendor=dec
-		basic_os=tops20
-		;;
-	delta | 3300 | motorola-3300 | motorola-delta \
-	      | 3300-motorola | delta-motorola)
-		cpu=m68k
-		vendor=motorola
-		;;
-	dpx2*)
-		cpu=m68k
-		vendor=bull
-		basic_os=sysv3
-		;;
-	encore | umax | mmax)
-		cpu=ns32k
-		vendor=encore
-		;;
-	elxsi)
-		cpu=elxsi
-		vendor=elxsi
-		basic_os=${basic_os:-bsd}
-		;;
-	fx2800)
-		cpu=i860
-		vendor=alliant
-		;;
-	genix)
-		cpu=ns32k
-		vendor=ns
-		;;
-	h3050r* | hiux*)
-		cpu=hppa1.1
-		vendor=hitachi
-		basic_os=hiuxwe2
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		cpu=m68000
-		vendor=hp
-		;;
-	hp9k3[2-9][0-9])
-		cpu=m68k
-		vendor=hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		cpu=hppa1.1
-		vendor=hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		cpu=hppa1.0
-		vendor=hp
-		;;
-	i*86v32)
-		cpu=$(echo "$1" | sed -e 's/86.*/86/')
-		vendor=pc
-		basic_os=sysv32
-		;;
-	i*86v4*)
-		cpu=$(echo "$1" | sed -e 's/86.*/86/')
-		vendor=pc
-		basic_os=sysv4
-		;;
-	i*86v)
-		cpu=$(echo "$1" | sed -e 's/86.*/86/')
-		vendor=pc
-		basic_os=sysv
-		;;
-	i*86sol2)
-		cpu=$(echo "$1" | sed -e 's/86.*/86/')
-		vendor=pc
-		basic_os=solaris2
-		;;
-	j90 | j90-cray)
-		cpu=j90
-		vendor=cray
-		basic_os=${basic_os:-unicos}
-		;;
-	iris | iris4d)
-		cpu=mips
-		vendor=sgi
-		case $basic_os in
-		    irix*)
-			;;
-		    *)
-			basic_os=irix4
-			;;
-		esac
-		;;
-	miniframe)
-		cpu=m68000
-		vendor=convergent
-		;;
-	*mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		cpu=m68k
-		vendor=atari
-		basic_os=mint
-		;;
-	news-3600 | risc-news)
-		cpu=mips
-		vendor=sony
-		basic_os=newsos
-		;;
-	next | m*-next)
-		cpu=m68k
-		vendor=next
-		case $basic_os in
-		    openstep*)
-		        ;;
-		    nextstep*)
-			;;
-		    ns2*)
-		      basic_os=nextstep2
-			;;
-		    *)
-		      basic_os=nextstep3
-			;;
-		esac
-		;;
-	np1)
-		cpu=np1
-		vendor=gould
-		;;
-	op50n-* | op60c-*)
-		cpu=hppa1.1
-		vendor=oki
-		basic_os=proelf
-		;;
-	pa-hitachi)
-		cpu=hppa1.1
-		vendor=hitachi
-		basic_os=hiuxwe2
-		;;
-	pbd)
-		cpu=sparc
-		vendor=tti
-		;;
-	pbb)
-		cpu=m68k
-		vendor=tti
-		;;
-	pc532)
-		cpu=ns32k
-		vendor=pc532
-		;;
-	pn)
-		cpu=pn
-		vendor=gould
-		;;
-	power)
-		cpu=power
-		vendor=ibm
-		;;
-	ps2)
-		cpu=i386
-		vendor=ibm
-		;;
-	rm[46]00)
-		cpu=mips
-		vendor=siemens
-		;;
-	rtpc | rtpc-*)
-		cpu=romp
-		vendor=ibm
-		;;
-	sde)
-		cpu=mipsisa32
-		vendor=sde
-		basic_os=${basic_os:-elf}
-		;;
-	simso-wrs)
-		cpu=sparclite
-		vendor=wrs
-		basic_os=vxworks
-		;;
-	tower | tower-32)
-		cpu=m68k
-		vendor=ncr
-		;;
-	vpp*|vx|vx-*)
-		cpu=f301
-		vendor=fujitsu
-		;;
-	w65 | 65816 | 65c816 | wdc65c816 | wc65c816 | wdc65816 | wc65816)
-		cpu=w65
-		vendor=wdc
-		;;
-	w89k-*)
-		cpu=hppa1.1
-		vendor=winbond
-		basic_os=proelf
-		;;
-	none)
-		cpu=none
-		vendor=none
-		;;
-	leon|leon[3-9])
-		cpu=sparc
-		vendor=$basic_machine
-		;;
-	leon-*|leon[3-9]-*)
-		cpu=sparc
-		vendor=$(echo "$basic_machine" | sed 's/-.*//')
-		;;
-	*-*)
-		# shellcheck disable=SC2162
-		IFS="-" read cpu vendor <<EOF
-$basic_machine
-EOF
-		;;
-	# We use `pc' rather than `unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-		cpu=$basic_machine
-		vendor=pc
-		;;
-	# These rules are duplicated from below for sake of the special case above;
-	# i.e. things that normalized to x86 arches should also default to "pc"
-	pc98)
-		cpu=i386
-		vendor=pc
-		;;
-	x64 | amd64)
-		cpu=x86_64
-		vendor=pc
-		;;
-	# Recognize the basic CPU types without company name.
-	*)
-		cpu=$basic_machine
-		vendor=unknown
-		;;
-esac
-
-unset -v basic_machine
-
-# Decode basic machines in the full and proper CPU-Company form.
-case $cpu-$vendor in
-	# Here we handle the default manufacturer of certain CPU types in canonical form. It is in
-	# some cases the only manufacturer, in others, it is the most popular.
-	craynv-unknown)
-		vendor=cray
-		basic_os=${basic_os:-unicosmp}
-		;;
-	c90-unknown | c90-cray)
-		vendor=cray
-		basic_os=${Basic_os:-unicos}
-		;;
-	fx80-unknown)
-		vendor=alliant
-		;;
-	romp-unknown)
-		vendor=ibm
-		;;
-	mmix-unknown)
-		vendor=knuth
-		;;
-	microblaze-unknown | microblazeel-unknown)
-		vendor=xilinx
-		;;
-	rs6000-unknown)
-		vendor=ibm
-		;;
-	vax-unknown)
-		vendor=dec
-		;;
-	pdp11-unknown)
-		vendor=dec
-		;;
-	we32k-unknown)
-		vendor=att
-		;;
-	cydra-unknown)
-		vendor=cydrome
-		;;
-	i370-ibm*)
-		vendor=ibm
-		;;
-	orion-unknown)
-		vendor=highlevel
-		;;
-	xps-unknown | xps100-unknown)
-		cpu=xps100
-		vendor=honeywell
-		;;
-
-	# Here we normalize CPU types with a missing or matching vendor
-	dpx20-unknown | dpx20-bull)
-		cpu=rs6000
-		vendor=bull
-		basic_os=${basic_os:-bosx}
-		;;
-	# Here we normalize CPU types irrespective of the vendor
-	amd64-*)
-		cpu=x86_64
-		;;
-	blackfin-*)
-		cpu=bfin
-		basic_os=linux
-		;;
-	c54x-*)
-		cpu=tic54x
-		;;
-	c55x-*)
-		cpu=tic55x
-		;;
-	c6x-*)
-		cpu=tic6x
-		;;
-	e500v[12]-*)
-		cpu=powerpc
-		basic_os=${basic_os}"spe"
-		;;
-	mips3*-*)
-		cpu=mips64
-		;;
-	ms1-*)
-		cpu=mt
-		;;
-	m68knommu-*)
-		cpu=m68k
-		basic_os=linux
-		;;
-	m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*)
-		cpu=s12z
-		;;
-	openrisc-*)
-		cpu=or32
-		;;
-	parisc-*)
-		cpu=hppa
-		basic_os=linux
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		cpu=i586
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-* | athalon_*-*)
-		cpu=i686
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		cpu=i686
-		;;
-	pentium4-*)
-		cpu=i786
-		;;
-	pc98-*)
-		cpu=i386
-		;;
-	ppc-* | ppcbe-*)
-		cpu=powerpc
-		;;
-	ppcle-* | powerpclittle-*)
-		cpu=powerpcle
-		;;
-	ppc64-*)
-		cpu=powerpc64
-		;;
-	ppc64le-* | powerpc64little-*)
-		cpu=powerpc64le
-		;;
-	sb1-*)
-		cpu=mipsisa64sb1
-		;;
-	sb1el-*)
-		cpu=mipsisa64sb1el
-		;;
-	sh5e[lb]-*)
-		cpu=$(echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/')
-		;;
-	spur-*)
-		cpu=spur
-		;;
-	strongarm-* | thumb-*)
-		cpu=arm
-		;;
-	tx39-*)
-		cpu=mipstx39
-		;;
-	tx39el-*)
-		cpu=mipstx39el
-		;;
-	x64-*)
-		cpu=x86_64
-		;;
-	xscale-* | xscalee[bl]-*)
-		cpu=$(echo "$cpu" | sed 's/^xscale/arm/')
-		;;
-	arm64-*)
-		cpu=aarch64
-		;;
-	# Recognize the canonical CPU Types that limit and/or modify the
-	# company names they are paired with.
-	cr16-*)
-		basic_os=${basic_os:-elf}
-		;;
-	crisv32-* | etraxfs*-*)
-		cpu=crisv32
-		vendor=axis
-		;;
-	cris-* | etrax*-*)
-		cpu=cris
-		vendor=axis
-		;;
-	crx-*)
-		basic_os=${basic_os:-elf}
-		;;
-	neo-tandem)
-		cpu=neo
-		vendor=tandem
-		;;
-	nse-tandem)
-		cpu=nse
-		vendor=tandem
-		;;
-	nsr-tandem)
-		cpu=nsr
-		vendor=tandem
-		;;
-	nsv-tandem)
-		cpu=nsv
-		vendor=tandem
-		;;
-	nsx-tandem)
-		cpu=nsx
-		vendor=tandem
-		;;
-	mipsallegrexel-sony)
-		cpu=mipsallegrexel
-		vendor=sony
-		;;
-	tile*-*)
-		basic_os=${basic_os:-linux-gnu}
-		;;
-		
-    65c816-* | wdc65c816-* | wc65c816-* | wdc65816-* | wc65816-* | 65816-*)
-       cpu=w65
-        ;;
-	*)
-		# Recognize the canonical CPU types that are allowed with any
-		# company name.
-		case $cpu in
-			1750a | 580 \
-			| a29k \
-			| aarch64 | aarch64_be \
-			| abacus \
-			| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] \
-			| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] \
-			| alphapca5[67] | alpha64pca5[67] \
-			| am33_2.0 \
-			| amdgcn \
-			| arc | arceb \
-			| arm | arm[lb]e | arme[lb] | armv* \
-			| avr | avr32 \
-			| asmjs \
-			| ba \
-			| be32 | be64 \
-			| bfin | bpf | bs2000 \
-			| c[123]* | c30 | [cjt]90 | c4x \
-			| c8051 | clipper | craynv | csky | cydra \
-			| d10v | d30v | dlx | dsp16xx \
-			| e2k | elxsi | epiphany \
-			| f30[01] | f700 | fido | fr30 | frv | ft32 | fx80 \
-			| h8300 | h8500 \
-			| hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-			| hexagon \
-			| i370 | i*86 | i860 | i960 | ia16 | ia64 \
-			| ip2k | iq2000 \
-			| k1om \
-			| le32 | le64 \
-			| lm32 \
-			| loongarch32 | loongarch64 | loongarchx32 \
-			| m32c | m32r | m32rle \
-			| m5200 | m68000 | m680[012346]0 | m68360 | m683?2 | m68k \
-			| m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x \
-			| m88110 | m88k | maxq | mb | mcore | mep | metag \
-			| microblaze | microblazeel \
-			| mips | mipsbe | mipseb | mipsel | mipsle \
-			| mips16 \
-			| mips64 | mips64eb | mips64el \
-			| mips64octeon | mips64octeonel \
-			| mips64orion | mips64orionel \
-			| mips64r5900 | mips64r5900el \
-			| mips64vr | mips64vrel \
-			| mips64vr4100 | mips64vr4100el \
-			| mips64vr4300 | mips64vr4300el \
-			| mips64vr5000 | mips64vr5000el \
-			| mips64vr5900 | mips64vr5900el \
-			| mipsisa32 | mipsisa32el \
-			| mipsisa32r2 | mipsisa32r2el \
-			| mipsisa32r6 | mipsisa32r6el \
-			| mipsisa64 | mipsisa64el \
-			| mipsisa64r2 | mipsisa64r2el \
-			| mipsisa64r6 | mipsisa64r6el \
-			| mipsisa64sb1 | mipsisa64sb1el \
-			| mipsisa64sr71k | mipsisa64sr71kel \
-			| mipsr5900 | mipsr5900el \
-			| mipstx39 | mipstx39el \
-			| mmix \
-			| mn10200 | mn10300 \
-			| moxie \
-			| mt \
-			| msp430 \
-			| nds32 | nds32le | nds32be \
-			| nfp \
-			| nios | nios2 | nios2eb | nios2el \
-			| none | np1 | ns16k | ns32k | nvptx \
-			| open8 \
-			| or1k* \
-			| or32 \
-			| orion \
-			| picochip \
-			| pdp10 | pdp11 | pj | pjl | pn | power \
-			| powerpc | powerpc64 | powerpc64le | powerpcle | powerpcspe \
-			| pru \
-			| pyramid \
-			| riscv | riscv32 | riscv32be | riscv64 | riscv64be \
-			| rl78 | romp | rs6000 | rx \
-			| s390 | s390x \
-			| score \
-			| sh | shl \
-			| sh[1234] | sh[24]a | sh[24]ae[lb] | sh[23]e | she[lb] | sh[lb]e \
-			| sh[1234]e[lb] |  sh[12345][lb]e | sh[23]ele | sh64 | sh64le \
-			| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet \
-			| sparclite \
-			| sparcv8 | sparcv9 | sparcv9b | sparcv9v | sv1 | sx* \
-			| spu \
-			| tahoe \
-			| thumbv7* \
-			| tic30 | tic4x | tic54x | tic55x | tic6x | tic80 \
-			| tron \
-			| ubicom32 \
-			| v70 | v850 | v850e | v850e1 | v850es | v850e2 | v850e2v3 \
-			| vax \
-			| visium \
-			| w65 | 65816 | 65c816 | w65c816 | wdc65c816 | wdc65816 \
-			| wasm32 | wasm64 \
-			| we32k \
-			| x86 | x86_64 | xc16x | xgate | xps100 \
-			| xstormy16 | xtensa* \
-			| ymp \
-			| z8k | z80)
-				;;
-
-			*)
-				echo Invalid configuration \`"$1"\': machine \`"$cpu-$vendor"\' not recognized 1>&2
-				exit 1
-				;;
-		esac
-		;;
-esac
-
-# Here we canonicalize certain aliases for manufacturers.
-case $vendor in
-	digital*)
-		vendor=dec
-		;;
-	commodore*)
-		vendor=cbm
-		;;
-	*)
-		;;
-esac
-
-# Decode manufacturer-specific aliases for certain operating systems.
-
-if test x$basic_os != x
-then
-
-# First recognize some ad-hoc caes, or perhaps split kernel-os, or else just
-# set os.
-case $basic_os in
-	gnu/linux*)
-		kernel=linux
-		os=$(echo $basic_os | sed -e 's|gnu/linux|gnu|')
-		;;
-	os2-emx)
-		kernel=os2
-		os=$(echo $basic_os | sed -e 's|os2-emx|emx|')
-		;;
-	nto-qnx*)
-		kernel=nto
-		os=$(echo $basic_os | sed -e 's|nto-qnx|qnx|')
-		;;
-	*-*)
-		# shellcheck disable=SC2162
-		IFS="-" read kernel os <<EOF
-$basic_os
-EOF
-		;;
-	# Default OS when just kernel was specified
-	nto*)
-		kernel=nto
-		os=$(echo $basic_os | sed -e 's|nto|qnx|')
-		;;
-	linux*)
-		kernel=linux
-		os=$(echo $basic_os | sed -e 's|linux|gnu|')
-		;;
-	phantom*)
-		kernel=phantom
-		os=$(echo $basic_os | sed -e 's|phantom|user|')
-		;;
-	snes*)
-		kernel=$basic_os
-		os=elf
-		;;
-	*)
-		kernel=
-		os=$basic_os
-		;;
-esac
-
-# Now, normalize the OS (knowing we just have one component, it's not a kernel,
-# etc.)
-case $os in
-	# First match some system type aliases that might get confused
-	# with valid system types.
-	# solaris* is a basic system type, with this one exception.
-	auroraux)
-		os=auroraux
-		;;
-	bluegene*)
-		os=cnk
-		;;
-	solaris1 | solaris1.*)
-		os=$(echo $os | sed -e 's|solaris1|sunos4|')
-		;;
-	solaris)
-		os=solaris2
-		;;
-	unixware*)
-		os=sysv4.2uw
-		;;
-	# es1800 is here to avoid being matched by es* (a different OS)
-	es1800*)
-		os=ose
-		;;
-	# Some version numbers need modification
-	chorusos*)
-		os=chorusos
-		;;
-	isc)
-		os=isc2.2
-		;;
-	sco6)
-		os=sco5v6
-		;;
-	sco5)
-		os=sco3.2v5
-		;;
-	sco4)
-		os=sco3.2v4
-		;;
-	sco3.2.[4-9]*)
-		os=$(echo $os | sed -e 's/sco3.2./sco3.2v/')
-		;;
-	sco*v* | scout)
-		# Don't match below
-		;;
-	sco*)
-		os=sco3.2v2
-		;;
-	psos*)
-		os=psos
-		;;
-	qnx*)
-		os=qnx
-		;;
-	hiux*)
-		os=hiuxwe2
-		;;
-	lynx*178)
-		os=lynxos178
-		;;
-	lynx*5)
-		os=lynxos5
-		;;
-	lynxos*)
-		# don't get caught up in next wildcard
-		;;
-	lynx*)
-		os=lynxos
-		;;
-	mac[0-9]*)
-		os=$(echo "$os" | sed -e 's|mac|macos|')
-		;;
-	opened*)
-		os=openedition
-		;;
-	os400*)
-		os=os400
-		;;
-	sunos5*)
-		os=$(echo "$os" | sed -e 's|sunos5|solaris2|')
-		;;
-	sunos6*)
-		os=$(echo "$os" | sed -e 's|sunos6|solaris3|')
-		;;
-	wince*)
-		os=wince
-		;;
-	utek*)
-		os=bsd
-		;;
-	dynix*)
-		os=bsd
-		;;
-	acis*)
-		os=aos
-		;;
-	atheos*)
-		os=atheos
-		;;
-	syllable*)
-		os=syllable
-		;;
-	386bsd)
-		os=bsd
-		;;
-	ctix* | uts*)
-		os=sysv
-		;;
-	nova*)
-		os=rtmk-nova
-		;;
-	ns2)
-		os=nextstep2
-		;;
-	# Preserve the version number of sinix5.
-	sinix5.*)
-		os=$(echo $os | sed -e 's|sinix|sysv|')
-		;;
-	sinix*)
-		os=sysv4
-		;;
-	tpf*)
-		os=tpf
-		;;
-	triton*)
-		os=sysv3
-		;;
-	oss*)
-		os=sysv3
-		;;
-	svr4*)
-		os=sysv4
-		;;
-	svr3)
-		os=sysv3
-		;;
-	sysvr4)
-		os=sysv4
-		;;
-	ose*)
-		os=ose
-		;;
-	*mint | mint[0-9]* | *MiNT | MiNT[0-9]*)
-		os=mint
-		;;
-	dicos*)
-		os=dicos
-		;;
-	pikeos*)
-		# Until real need of OS specific support for
-		# particular features comes up, bare metal
-		# configurations are quite functional.
-		case $cpu in
-		    arm*)
-			os=eabi
-			;;
-		    *)
-			os=elf
-			;;
-		esac
-		;;
-	*)
-		# No normalization, but not necessarily accepted, that comes below.
-		;;
-esac
-
-else
-
-# Here we handle the default operating systems that come with various machines.
-# The value should be what the vendor currently ships out the door with their
-# machine or put another way, the most popular os provided with the machine.
-
-# Note that if you're going to try to match "-MANUFACTURER" here (say,
-# "-sun"), then you have to tell the case statement up towards the top
-# that MANUFACTURER isn't an operating system.  Otherwise, code above
-# will signal an error saying that MANUFACTURER isn't an operating
-# system, and we'll never get to this point.
-
-kernel=
-case $cpu-$vendor in
-	score-*)
-		os=elf
-		;;
-	spu-*)
-		os=elf
-		;;
-	*-acorn)
-		os=riscix1.2
-		;;
-	arm*-rebel)
-		kernel=linux
-		os=gnu
-		;;
-	arm*-semi)
-		os=aout
-		;;
-	c4x-* | tic4x-*)
-		os=coff
-		;;
-	c8051-*)
-		os=elf
-		;;
-	clipper-intergraph)
-		os=clix
-		;;
-	hexagon-*)
-		os=elf
-		;;
-	tic54x-*)
-		os=coff
-		;;
-	tic55x-*)
-		os=coff
-		;;
-	tic6x-*)
-		os=coff
-		;;
-	# This must come before the *-dec entry.
-	pdp10-*)
-		os=tops20
-		;;
-	pdp11-*)
-		os=none
-		;;
-	*-dec | vax-*)
-		os=ultrix4.2
-		;;
-	m68*-apollo)
-		os=domain
-		;;
-	i386-sun)
-		os=sunos4.0.2
-		;;
-	m68000-sun)
-		os=sunos3
-		;;
-	m68*-cisco)
-		os=aout
-		;;
-	mep-*)
-		os=elf
-		;;
-	mips*-cisco)
-		os=elf
-		;;
-	mips*-*)
-		os=elf
-		;;
-	or32-*)
-		os=coff
-		;;
-	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=sysv3
-		;;
-	sparc-* | *-sun)
-		os=sunos4.1.1
-		;;
-	pru-*)
-		os=elf
-		;;
-	*-be)
-		os=beos
-		;;
-	*-ibm)
-		os=aix
-		;;
-	*-knuth)
-		os=mmixware
-		;;
-	*-wec)
-		os=proelf
-		;;
-	*-winbond)
-		os=proelf
-		;;
-	*-oki)
-		os=proelf
-		;;
-	*-hp)
-		os=hpux
-		;;
-	*-hitachi)
-		os=hiux
-		;;
-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=sysv
-		;;
-	*-cbm)
-		os=amigaos
-		;;
-	*-dg)
-		os=dgux
-		;;
-	*-dolphin)
-		os=sysv3
-		;;
-	m68k-ccur)
-		os=rtu
-		;;
-	m88k-omron*)
-		os=luna
-		;;
-	*-next)
-		os=nextstep
-		;;
-	*-sequent)
-		os=ptx
-		;;
-	*-crds)
-		os=unos
-		;;
-	*-ns)
-		os=genix
-		;;
-	i370-*)
-		os=mvs
-		;;
-	*-gould)
-		os=sysv
-		;;
-	*-highlevel)
-		os=bsd
-		;;
-	*-encore)
-		os=bsd
-		;;
-	*-sgi)
-		os=irix
-		;;
-	*-siemens)
-		os=sysv4
-		;;
-	*-masscomp)
-		os=rtu
-		;;
-	f30[01]-fujitsu | f700-fujitsu)
-		os=uxpv
-		;;
-	*-rom68k)
-		os=coff
-		;;
-	*-*bug)
-		os=coff
-		;;
-	*-apple)
-		os=macos
-		;;
-	*-atari*)
-		os=mint
-		;;
-	*-wrs)
-		os=vxworks
-		;;
-	*)
-		os=none
-		;;
-esac
-
-fi
-
-# Now, validate our (potentially fixed-up) OS.
-case $os in
-	# Sometimes we do "kernel-libc", so those need to count as OSes.
-	musl* | newlib* | uclibc*)
-		;;
-	# Likewise for "kernel-abi"
-	eabi* | gnueabi*)
-		;;
-	# VxWorks passes extra cpu info in the 4th filed.
-	simlinux | simwindows | spe)
-		;;
-	# Now accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST end in a * to match a version number.
-	gnu* | android* | bsd* | mach* | minix* | genix* | ultrix* | irix* \
-	     | *vms* | esix* | aix* | cnk* | sunos | sunos[34]* \
-	     | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \
-	     | sym* |  plan9* | psp* | sim* | xray* | os68k* | v88r* \
-	     | hiux* | abug | nacl* | netware* | windows* \
-	     | os9* | macos* | osx* | ios* \
-	     | mpw* | magic* | mmixware* | mon960* | lnews* \
-	     | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \
-	     | aos* | aros* | cloudabi* | sortix* | twizzler* \
-	     | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \
-	     | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \
-	     | mirbsd* | netbsd* | dicos* | openedition* | ose* \
-	     | bitrig* | openbsd* | solidbsd* | libertybsd* | os108* \
-	     | ekkobsd* | freebsd* | riscix* | lynxos* | os400* \
-	     | bosx* | nextstep* | cxux* | aout* | elf* | oabi* \
-	     | ptx* | coff* | ecoff* | winnt* | domain* | vsta* \
-	     | udi* | lites* | ieee* | go32* | aux* | hcos* \
-	     | chorusrdb* | cegcc* | glidix* | serenity* \
-	     | cygwin* | msys* | pe* | moss* | proelf* | rtems* \
-	     | midipix* | mingw32* | mingw64* | mint* \
-	     | uxpv* | beos* | mpeix* | udk* | moxiebox* \
-	     | interix* | uwin* | mks* | rhapsody* | darwin* \
-	     | openstep* | oskit* | conix* | pw32* | nonstopux* \
-	     | storm-chaos* | tops10* | tenex* | tops20* | its* \
-	     | os2* | vos* | palmos* | uclinux* | nucleus* | morphos* \
-	     | scout* | superux* | sysv* | rtmk* | tpf* | windiss* \
-	     | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \
-	     | skyos* | haiku* | rdos* | toppers* | drops* | es* \
-	     | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \
-	     | midnightbsd* | amdhsa* | unleashed* | emscripten* | wasi* \
-	     | nsk* | powerunix* | genode* | zvmoe* | qnx* | emx* \
-		 | user* | kernel* | xo65* )
-		;;
-	# This one is extra strict with allowed versions
-	sco3.2v2 | sco3.2v[4-9]* | sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		;;
-	none)
-		;;
-	*)
-		echo Invalid configuration \`"$1"\': OS \`"$os"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-
-# As a final step for OS-related things, validate the OS-kernel combination
-# (given a valid OS), if there is a kernel.
-case $kernel-$os in
-	linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* | linux-musl* | linux-uclibc* )
-		;;
-	uclinux-uclibc* )
-		;;
-	-dietlibc* | -newlib* | -musl* | -uclibc* )
-		# These are just libc implementations, not actual OSes, and thus
-		# require a kernel.
-		echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2
-		exit 1
-		;;
-	kfreebsd*-gnu* | kopensolaris*-gnu*)
-		;;
-	vxworks-simlinux | vxworks-simwindows | vxworks-spe)
-		;;
-	nto-qnx*)
-		;;
-	os2-emx)
-		;;
-	phantom-kernel* | phantom-user*)
-		;;
-	snes*-elf* | snes*-xo65* | nes*-xo65* | snes*-coff* )
-		;; 
-	*-eabi* | *-gnueabi*)
-		;;
-	-*)
-		# Blank kernel with real OS is always fine.
-		;;
-	*-*)
-		echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2
-		exit 1
-		;;
-esac
-
-# Here we handle the case where we know the os, and the CPU type, but not the
-# manufacturer.  We pick the logical manufacturer.
-case $vendor in
-	unknown)
-		case $cpu-$os in
-			*-riscix*)
-				vendor=acorn
-				;;
-			*-sunos*)
-				vendor=sun
-				;;
-			*-cnk* | *-aix*)
-				vendor=ibm
-				;;
-			*-beos*)
-				vendor=be
-				;;
-			*-hpux*)
-				vendor=hp
-				;;
-			*-mpeix*)
-				vendor=hp
-				;;
-			*-hiux*)
-				vendor=hitachi
-				;;
-			*-unos*)
-				vendor=crds
-				;;
-			*-dgux*)
-				vendor=dg
-				;;
-			*-luna*)
-				vendor=omron
-				;;
-			*-genix*)
-				vendor=ns
-				;;
-			*-clix*)
-				vendor=intergraph
-				;;
-			*-mvs* | *-opened*)
-				vendor=ibm
-				;;
-			*-os400*)
-				vendor=ibm
-				;;
-			s390-* | s390x-*)
-				vendor=ibm
-				;;
-			*-ptx*)
-				vendor=sequent
-				;;
-			*-tpf*)
-				vendor=ibm
-				;;
-			*-vxsim* | *-vxworks* | *-windiss*)
-				vendor=wrs
-				;;
-			*-aux*)
-				vendor=apple
-				;;
-			*-hms*)
-				vendor=hitachi
-				;;
-			*-mpw* | *-macos*)
-				vendor=apple
-				;;
-			*-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)
-				vendor=atari
-				;;
-			*-vos*)
-				vendor=stratus
-				;;
-		esac
-		;;
-esac
-
-echo "$cpu-$vendor-${kernel:+$kernel-}$os"
-exit
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/fake-enum/configure b/vendor/fake-enum/configure
deleted file mode 100755
index 9cd7e198..00000000
--- a/vendor/fake-enum/configure
+++ /dev/null
@@ -1,4207 +0,0 @@
-#! /bin/sh
-# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69.
-#
-#
-# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
-#
-#
-# This configure script is free software; the Free Software Foundation
-# gives unlimited permission to copy, distribute and modify it.
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-# Use a proper internal environment variable to ensure we don't fall
-  # into an infinite loop, continuously re-executing ourselves.
-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
-    _as_can_reexec=no; export _as_can_reexec;
-    # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-as_fn_exit 255
-  fi
-  # We don't want this to propagate to other subprocesses.
-          { _as_can_reexec=; unset _as_can_reexec;}
-if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-"
-  as_required="as_fn_return () { (exit \$1); }
-as_fn_success () { as_fn_return 0; }
-as_fn_failure () { as_fn_return 1; }
-as_fn_ret_success () { return 0; }
-as_fn_ret_failure () { return 1; }
-
-exitcode=0
-as_fn_success || { exitcode=1; echo as_fn_success failed.; }
-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
-
-else
-  exitcode=1; echo positional parameters were not saved.
-fi
-test x\$exitcode = x0 || exit 1
-test -x / || exit 1"
-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
-  if (eval "$as_required") 2>/dev/null; then :
-  as_have_required=yes
-else
-  as_have_required=no
-fi
-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
-
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  as_found=:
-  case $as_dir in #(
-	 /*)
-	   for as_base in sh bash ksh sh5; do
-	     # Try only shells that exist, to save several forks.
-	     as_shell=$as_dir/$as_base
-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  CONFIG_SHELL=$as_shell as_have_required=yes
-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  break 2
-fi
-fi
-	   done;;
-       esac
-  as_found=false
-done
-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
-  CONFIG_SHELL=$SHELL as_have_required=yes
-fi; }
-IFS=$as_save_IFS
-
-
-      if test "x$CONFIG_SHELL" != x; then :
-  export CONFIG_SHELL
-             # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-fi
-
-    if test x$as_have_required = xno; then :
-  $as_echo "$0: This script requires a shell more modern than all"
-  $as_echo "$0: the shells that I found on your system."
-  if test x${ZSH_VERSION+set} = xset ; then
-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
-  else
-    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
-$0: including any error possibly output before this
-$0: message. Then install a modern shell, or manually run
-$0: the script under such a shell if you do have one."
-  fi
-  exit 1
-fi
-fi
-fi
-SHELL=${CONFIG_SHELL-/bin/sh}
-export SHELL
-# Unset more variables known to interfere with behavior of common tools.
-CLICOLOR_FORCE= GREP_OPTIONS=
-unset CLICOLOR_FORCE GREP_OPTIONS
-
-## --------------------- ##
-## M4sh Shell Functions. ##
-## --------------------- ##
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-  as_lineno_1=$LINENO as_lineno_1a=$LINENO
-  as_lineno_2=$LINENO as_lineno_2a=$LINENO
-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
-  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
-  sed -n '
-    p
-    /[$]LINENO/=
-  ' <$as_myself |
-    sed '
-      s/[$]LINENO.*/&-/
-      t lineno
-      b
-      :lineno
-      N
-      :loop
-      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
-      t loop
-      s/-\n.*//
-    ' >$as_me.lineno &&
-  chmod +x "$as_me.lineno" ||
-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-
-  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-  # already done that, so ensure we don't try to do so again and fall
-  # in an infinite loop.  This has already happened in practice.
-  _as_can_reexec=no; export _as_can_reexec
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensitive to this).
-  . "./$as_me.lineno"
-  # Exit status is that of the last command.
-  exit
-}
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-test -n "$DJDIR" || exec 7<&0 </dev/null
-exec 6>&1
-
-# Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
-# so uname gets run too.
-ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
-
-#
-# Initializations.
-#
-ac_default_prefix=/usr/local
-ac_clean_files=
-ac_config_libobj_dir=.
-LIBOBJS=
-cross_compiling=no
-subdirs=
-MFLAGS=
-MAKEFLAGS=
-
-# Identity of this package.
-PACKAGE_NAME=
-PACKAGE_TARNAME=
-PACKAGE_VERSION=
-PACKAGE_STRING=
-PACKAGE_BUGREPORT=
-PACKAGE_URL=
-
-ac_subst_vars='LTLIBOBJS
-LIBOBJS
-rustc_has_std
-RUSTFLAGS
-RUSTC
-INSTALL_DATA
-INSTALL_SCRIPT
-INSTALL_PROGRAM
-OBJEXT
-EXEEXT
-ac_ct_CC
-CPPFLAGS
-LDFLAGS
-CFLAGS
-CC
-host_os
-host_vendor
-host_cpu
-host
-build_os
-build_vendor
-build_cpu
-build
-target_alias
-host_alias
-build_alias
-LIBS
-ECHO_T
-ECHO_N
-ECHO_C
-DEFS
-mandir
-localedir
-libdir
-psdir
-pdfdir
-dvidir
-htmldir
-infodir
-docdir
-oldincludedir
-includedir
-runstatedir
-localstatedir
-sharedstatedir
-sysconfdir
-datadir
-datarootdir
-libexecdir
-sbindir
-bindir
-program_transform_name
-prefix
-exec_prefix
-PACKAGE_URL
-PACKAGE_BUGREPORT
-PACKAGE_STRING
-PACKAGE_VERSION
-PACKAGE_TARNAME
-PACKAGE_NAME
-PATH_SEPARATOR
-SHELL'
-ac_subst_files=''
-ac_user_opts='
-enable_option_checking
-'
-      ac_precious_vars='build_alias
-host_alias
-target_alias
-CC
-CFLAGS
-LDFLAGS
-LIBS
-CPPFLAGS
-RUSTC
-RUSTFLAGS'
-
-
-# Initialize some variables set by options.
-ac_init_help=
-ac_init_version=false
-ac_unrecognized_opts=
-ac_unrecognized_sep=
-# The variables have the same names as the options, with
-# dashes changed to underlines.
-cache_file=/dev/null
-exec_prefix=NONE
-no_create=
-no_recursion=
-prefix=NONE
-program_prefix=NONE
-program_suffix=NONE
-program_transform_name=s,x,x,
-silent=
-site=
-srcdir=
-verbose=
-x_includes=NONE
-x_libraries=NONE
-
-# Installation directory options.
-# These are left unexpanded so users can "make install exec_prefix=/foo"
-# and all the variables that are supposed to be based on exec_prefix
-# by default will actually change.
-# Use braces instead of parens because sh, perl, etc. also accept them.
-# (The list follows the same order as the GNU Coding Standards.)
-bindir='${exec_prefix}/bin'
-sbindir='${exec_prefix}/sbin'
-libexecdir='${exec_prefix}/libexec'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}'
-sysconfdir='${prefix}/etc'
-sharedstatedir='${prefix}/com'
-localstatedir='${prefix}/var'
-runstatedir='${localstatedir}/run'
-includedir='${prefix}/include'
-oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE}'
-infodir='${datarootdir}/info'
-htmldir='${docdir}'
-dvidir='${docdir}'
-pdfdir='${docdir}'
-psdir='${docdir}'
-libdir='${exec_prefix}/lib'
-localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
-ac_prev=
-ac_dashdash=
-for ac_option
-do
-  # If the previous option needs an argument, assign it.
-  if test -n "$ac_prev"; then
-    eval $ac_prev=\$ac_option
-    ac_prev=
-    continue
-  fi
-
-  case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
-  esac
-
-  # Accept the important Cygnus configure options, so we can diagnose typos.
-
-  case $ac_dashdash$ac_option in
-  --)
-    ac_dashdash=yes ;;
-
-  -bindir | --bindir | --bindi | --bind | --bin | --bi)
-    ac_prev=bindir ;;
-  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
-    bindir=$ac_optarg ;;
-
-  -build | --build | --buil | --bui | --bu)
-    ac_prev=build_alias ;;
-  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
-    build_alias=$ac_optarg ;;
-
-  -cache-file | --cache-file | --cache-fil | --cache-fi \
-  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
-    ac_prev=cache_file ;;
-  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
-  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
-    cache_file=$ac_optarg ;;
-
-  --config-cache | -C)
-    cache_file=config.cache ;;
-
-  -datadir | --datadir | --datadi | --datad)
-    ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=*)
-    datadir=$ac_optarg ;;
-
-  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
-  | --dataroo | --dataro | --datar)
-    ac_prev=datarootdir ;;
-  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
-  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
-    datarootdir=$ac_optarg ;;
-
-  -disable-* | --disable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=no ;;
-
-  -docdir | --docdir | --docdi | --doc | --do)
-    ac_prev=docdir ;;
-  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
-    docdir=$ac_optarg ;;
-
-  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
-    ac_prev=dvidir ;;
-  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
-    dvidir=$ac_optarg ;;
-
-  -enable-* | --enable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=\$ac_optarg ;;
-
-  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
-  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
-  | --exec | --exe | --ex)
-    ac_prev=exec_prefix ;;
-  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
-  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
-  | --exec=* | --exe=* | --ex=*)
-    exec_prefix=$ac_optarg ;;
-
-  -gas | --gas | --ga | --g)
-    # Obsolete; use --with-gas.
-    with_gas=yes ;;
-
-  -help | --help | --hel | --he | -h)
-    ac_init_help=long ;;
-  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
-    ac_init_help=recursive ;;
-  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
-    ac_init_help=short ;;
-
-  -host | --host | --hos | --ho)
-    ac_prev=host_alias ;;
-  -host=* | --host=* | --hos=* | --ho=*)
-    host_alias=$ac_optarg ;;
-
-  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
-    ac_prev=htmldir ;;
-  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
-  | --ht=*)
-    htmldir=$ac_optarg ;;
-
-  -includedir | --includedir | --includedi | --included | --include \
-  | --includ | --inclu | --incl | --inc)
-    ac_prev=includedir ;;
-  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
-  | --includ=* | --inclu=* | --incl=* | --inc=*)
-    includedir=$ac_optarg ;;
-
-  -infodir | --infodir | --infodi | --infod | --info | --inf)
-    ac_prev=infodir ;;
-  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
-    infodir=$ac_optarg ;;
-
-  -libdir | --libdir | --libdi | --libd)
-    ac_prev=libdir ;;
-  -libdir=* | --libdir=* | --libdi=* | --libd=*)
-    libdir=$ac_optarg ;;
-
-  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
-  | --libexe | --libex | --libe)
-    ac_prev=libexecdir ;;
-  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
-  | --libexe=* | --libex=* | --libe=*)
-    libexecdir=$ac_optarg ;;
-
-  -localedir | --localedir | --localedi | --localed | --locale)
-    ac_prev=localedir ;;
-  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
-    localedir=$ac_optarg ;;
-
-  -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst | --locals)
-    ac_prev=localstatedir ;;
-  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
-    localstatedir=$ac_optarg ;;
-
-  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
-    ac_prev=mandir ;;
-  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
-    mandir=$ac_optarg ;;
-
-  -nfp | --nfp | --nf)
-    # Obsolete; use --without-fp.
-    with_fp=no ;;
-
-  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c | -n)
-    no_create=yes ;;
-
-  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
-    no_recursion=yes ;;
-
-  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
-  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
-  | --oldin | --oldi | --old | --ol | --o)
-    ac_prev=oldincludedir ;;
-  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
-  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
-  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
-    oldincludedir=$ac_optarg ;;
-
-  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
-    ac_prev=prefix ;;
-  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
-    prefix=$ac_optarg ;;
-
-  -program-prefix | --program-prefix | --program-prefi | --program-pref \
-  | --program-pre | --program-pr | --program-p)
-    ac_prev=program_prefix ;;
-  -program-prefix=* | --program-prefix=* | --program-prefi=* \
-  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
-    program_prefix=$ac_optarg ;;
-
-  -program-suffix | --program-suffix | --program-suffi | --program-suff \
-  | --program-suf | --program-su | --program-s)
-    ac_prev=program_suffix ;;
-  -program-suffix=* | --program-suffix=* | --program-suffi=* \
-  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
-    program_suffix=$ac_optarg ;;
-
-  -program-transform-name | --program-transform-name \
-  | --program-transform-nam | --program-transform-na \
-  | --program-transform-n | --program-transform- \
-  | --program-transform | --program-transfor \
-  | --program-transfo | --program-transf \
-  | --program-trans | --program-tran \
-  | --progr-tra | --program-tr | --program-t)
-    ac_prev=program_transform_name ;;
-  -program-transform-name=* | --program-transform-name=* \
-  | --program-transform-nam=* | --program-transform-na=* \
-  | --program-transform-n=* | --program-transform-=* \
-  | --program-transform=* | --program-transfor=* \
-  | --program-transfo=* | --program-transf=* \
-  | --program-trans=* | --program-tran=* \
-  | --progr-tra=* | --program-tr=* | --program-t=*)
-    program_transform_name=$ac_optarg ;;
-
-  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
-    ac_prev=pdfdir ;;
-  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
-    pdfdir=$ac_optarg ;;
-
-  -psdir | --psdir | --psdi | --psd | --ps)
-    ac_prev=psdir ;;
-  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
-    psdir=$ac_optarg ;;
-
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil)
-    silent=yes ;;
-
-  -runstatedir | --runstatedir | --runstatedi | --runstated \
-  | --runstate | --runstat | --runsta | --runst | --runs \
-  | --run | --ru | --r)
-    ac_prev=runstatedir ;;
-  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-  | --run=* | --ru=* | --r=*)
-    runstatedir=$ac_optarg ;;
-
-  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-    ac_prev=sbindir ;;
-  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-  | --sbi=* | --sb=*)
-    sbindir=$ac_optarg ;;
-
-  -sharedstatedir | --sharedstatedir | --sharedstatedi \
-  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
-  | --sharedst | --shareds | --shared | --share | --shar \
-  | --sha | --sh)
-    ac_prev=sharedstatedir ;;
-  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
-  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
-  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
-  | --sha=* | --sh=*)
-    sharedstatedir=$ac_optarg ;;
-
-  -site | --site | --sit)
-    ac_prev=site ;;
-  -site=* | --site=* | --sit=*)
-    site=$ac_optarg ;;
-
-  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
-    ac_prev=srcdir ;;
-  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
-    srcdir=$ac_optarg ;;
-
-  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
-  | --syscon | --sysco | --sysc | --sys | --sy)
-    ac_prev=sysconfdir ;;
-  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
-  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
-    sysconfdir=$ac_optarg ;;
-
-  -target | --target | --targe | --targ | --tar | --ta | --t)
-    ac_prev=target_alias ;;
-  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
-    target_alias=$ac_optarg ;;
-
-  -v | -verbose | --verbose | --verbos | --verbo | --verb)
-    verbose=yes ;;
-
-  -version | --version | --versio | --versi | --vers | -V)
-    ac_init_version=: ;;
-
-  -with-* | --with-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=\$ac_optarg ;;
-
-  -without-* | --without-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=no ;;
-
-  --x)
-    # Obsolete; use --with-x.
-    with_x=yes ;;
-
-  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
-  | --x-incl | --x-inc | --x-in | --x-i)
-    ac_prev=x_includes ;;
-  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
-  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
-    x_includes=$ac_optarg ;;
-
-  -x-libraries | --x-libraries | --x-librarie | --x-librari \
-  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
-    ac_prev=x_libraries ;;
-  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
-  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-    x_libraries=$ac_optarg ;;
-
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
-    ;;
-
-  *=*)
-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
-    # Reject names that are not valid shell variable names.
-    case $ac_envvar in #(
-      '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-    esac
-    eval $ac_envvar=\$ac_optarg
-    export $ac_envvar ;;
-
-  *)
-    # FIXME: should be removed in autoconf 3.0.
-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-    ;;
-
-  esac
-done
-
-if test -n "$ac_prev"; then
-  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
-fi
-
-if test -n "$ac_unrecognized_opts"; then
-  case $enable_option_checking in
-    no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-  esac
-fi
-
-# Check all directory arguments for consistency.
-for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
-		datadir sysconfdir sharedstatedir localstatedir includedir \
-		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir runstatedir
-do
-  eval ac_val=\$$ac_var
-  # Remove trailing slashes.
-  case $ac_val in
-    */ )
-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
-      eval $ac_var=\$ac_val;;
-  esac
-  # Be sure to have absolute directory names.
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* )  continue;;
-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
-  esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
-done
-
-# There might be people who depend on the old broken behavior: `$host'
-# used to hold the argument of --host etc.
-# FIXME: To remove some day.
-build=$build_alias
-host=$host_alias
-target=$target_alias
-
-# FIXME: To remove some day.
-if test "x$host_alias" != x; then
-  if test "x$build_alias" = x; then
-    cross_compiling=maybe
-  elif test "x$build_alias" != "x$host_alias"; then
-    cross_compiling=yes
-  fi
-fi
-
-ac_tool_prefix=
-test -n "$host_alias" && ac_tool_prefix=$host_alias-
-
-test "$silent" = yes && exec 6>/dev/null
-
-
-ac_pwd=`pwd` && test -n "$ac_pwd" &&
-ac_ls_di=`ls -di .` &&
-ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
-
-
-# Find the source files, if location was not specified.
-if test -z "$srcdir"; then
-  ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then the parent directory.
-  ac_confdir=`$as_dirname -- "$as_myself" ||
-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_myself" : 'X\(//\)[^/]' \| \
-	 X"$as_myself" : 'X\(//\)$' \| \
-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_myself" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  srcdir=$ac_confdir
-  if test ! -r "$srcdir/$ac_unique_file"; then
-    srcdir=..
-  fi
-else
-  ac_srcdir_defaulted=no
-fi
-if test ! -r "$srcdir/$ac_unique_file"; then
-  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
-fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-ac_abs_confdir=`(
-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
-	pwd)`
-# When building in place, set srcdir=.
-if test "$ac_abs_confdir" = "$ac_pwd"; then
-  srcdir=.
-fi
-# Remove unnecessary trailing slashes from srcdir.
-# Double slashes in file names in object file debugging info
-# mess up M-x gdb in Emacs.
-case $srcdir in
-*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
-esac
-for ac_var in $ac_precious_vars; do
-  eval ac_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_env_${ac_var}_value=\$${ac_var}
-  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_cv_env_${ac_var}_value=\$${ac_var}
-done
-
-#
-# Report the --help message.
-#
-if test "$ac_init_help" = "long"; then
-  # Omit some internal or obsolete options to make the list less imposing.
-  # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<_ACEOF
-\`configure' configures this package to adapt to many kinds of systems.
-
-Usage: $0 [OPTION]... [VAR=VALUE]...
-
-To assign environment variables (e.g., CC, CFLAGS...), specify them as
-VAR=VALUE.  See below for descriptions of some of the useful variables.
-
-Defaults for the options are specified in brackets.
-
-Configuration:
-  -h, --help              display this help and exit
-      --help=short        display options specific to this package
-      --help=recursive    display the short help of all the included packages
-  -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
-      --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
-  -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-
-Installation directories:
-  --prefix=PREFIX         install architecture-independent files in PREFIX
-                          [$ac_default_prefix]
-  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                          [PREFIX]
-
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
-
-For better control, use the options below.
-
-Fine tuning of the installation directories:
-  --bindir=DIR            user executables [EPREFIX/bin]
-  --sbindir=DIR           system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR        program executables [EPREFIX/libexec]
-  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-  --libdir=DIR            object code libraries [EPREFIX/lib]
-  --includedir=DIR        C header files [PREFIX/include]
-  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
-  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
-  --infodir=DIR           info documentation [DATAROOTDIR/info]
-  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
-  --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
-  --htmldir=DIR           html documentation [DOCDIR]
-  --dvidir=DIR            dvi documentation [DOCDIR]
-  --pdfdir=DIR            pdf documentation [DOCDIR]
-  --psdir=DIR             ps documentation [DOCDIR]
-_ACEOF
-
-  cat <<\_ACEOF
-
-System types:
-  --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
-_ACEOF
-fi
-
-if test -n "$ac_init_help"; then
-
-  cat <<\_ACEOF
-
-Some influential environment variables:
-  CC          C compiler command
-  CFLAGS      C compiler flags
-  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
-              nonstandard directory <lib dir>
-  LIBS        libraries to pass to the linker, e.g. -l<library>
-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
-              you have headers in a nonstandard directory <include dir>
-  RUSTC       Rust compiler to use
-  RUSTFLAGS   Flags to pass to the rust compiler
-
-Use these variables to override the choices made by `configure' or to help
-it to find libraries and programs with nonstandard names/locations.
-
-Report bugs to the package provider.
-_ACEOF
-ac_status=$?
-fi
-
-if test "$ac_init_help" = "recursive"; then
-  # If there are subdirs, report their specific --help.
-  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d "$ac_dir" ||
-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
-      continue
-    ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-    cd "$ac_dir" || { ac_status=$?; continue; }
-    # Check for guested configure.
-    if test -f "$ac_srcdir/configure.gnu"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-    elif test -f "$ac_srcdir/configure"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure" --help=recursive
-    else
-      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi || ac_status=$?
-    cd "$ac_pwd" || { ac_status=$?; break; }
-  done
-fi
-
-test -n "$ac_init_help" && exit $ac_status
-if $ac_init_version; then
-  cat <<\_ACEOF
-configure
-generated by GNU Autoconf 2.69
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This configure script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it.
-_ACEOF
-  exit
-fi
-
-## ------------------------ ##
-## Autoconf initialization. ##
-## ------------------------ ##
-
-# ac_fn_c_try_compile LINENO
-# --------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_compile
-cat >config.log <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  $ $0 $@
-
-_ACEOF
-exec 5>>config.log
-{
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
-
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
-
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
-
-_ASUNAME
-
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    $as_echo "PATH: $as_dir"
-  done
-IFS=$as_save_IFS
-
-} >&5
-
-cat >&5 <<_ACEOF
-
-
-## ----------- ##
-## Core tests. ##
-## ----------- ##
-
-_ACEOF
-
-
-# Keep a trace of the command line.
-# Strip out --no-create and --no-recursion so they do not pile up.
-# Strip out --silent because we don't want to record it for future runs.
-# Also quote any args containing shell meta-characters.
-# Make two passes to allow for proper duplicate-argument suppression.
-ac_configure_args=
-ac_configure_args0=
-ac_configure_args1=
-ac_must_keep_next=false
-for ac_pass in 1 2
-do
-  for ac_arg
-  do
-    case $ac_arg in
-    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-    | -silent | --silent | --silen | --sile | --sil)
-      continue ;;
-    *\'*)
-      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    case $ac_pass in
-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-    2)
-      as_fn_append ac_configure_args1 " '$ac_arg'"
-      if test $ac_must_keep_next = true; then
-	ac_must_keep_next=false # Got value, back to normal.
-      else
-	case $ac_arg in
-	  *=* | --config-cache | -C | -disable-* | --disable-* \
-	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
-	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
-	  | -with-* | --with-* | -without-* | --without-* | --x)
-	    case "$ac_configure_args0 " in
-	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
-	    esac
-	    ;;
-	  -* ) ac_must_keep_next=true ;;
-	esac
-      fi
-      as_fn_append ac_configure_args " '$ac_arg'"
-      ;;
-    esac
-  done
-done
-{ ac_configure_args0=; unset ac_configure_args0;}
-{ ac_configure_args1=; unset ac_configure_args1;}
-
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log.  We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
-  # Save into config.log some information that might help in debugging.
-  {
-    echo
-
-    $as_echo "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
-    echo
-    # The following way of writing the cache mishandles newlines in values,
-(
-  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-  (set) 2>&1 |
-    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      sed -n \
-	"s/'\''/'\''\\\\'\'''\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
-      ;; #(
-    *)
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-)
-    echo
-
-    $as_echo "## ----------------- ##
-## Output variables. ##
-## ----------------- ##"
-    echo
-    for ac_var in $ac_subst_vars
-    do
-      eval ac_val=\$$ac_var
-      case $ac_val in
-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-      esac
-      $as_echo "$ac_var='\''$ac_val'\''"
-    done | sort
-    echo
-
-    if test -n "$ac_subst_files"; then
-      $as_echo "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
-      echo
-      for ac_var in $ac_subst_files
-      do
-	eval ac_val=\$$ac_var
-	case $ac_val in
-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-	esac
-	$as_echo "$ac_var='\''$ac_val'\''"
-      done | sort
-      echo
-    fi
-
-    if test -s confdefs.h; then
-      $as_echo "## ----------- ##
-## confdefs.h. ##
-## ----------- ##"
-      echo
-      cat confdefs.h
-      echo
-    fi
-    test "$ac_signal" != 0 &&
-      $as_echo "$as_me: caught signal $ac_signal"
-    $as_echo "$as_me: exit $exit_status"
-  } >&5
-  rm -f core *.core core.conftest.* &&
-    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-    exit $exit_status
-' 0
-for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
-done
-ac_signal=0
-
-# confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -f -r conftest* confdefs.h
-
-$as_echo "/* confdefs.h */" > confdefs.h
-
-# Predefined preprocessor variables.
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_NAME "$PACKAGE_NAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_VERSION "$PACKAGE_VERSION"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_STRING "$PACKAGE_STRING"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_URL "$PACKAGE_URL"
-_ACEOF
-
-
-# Let the site file select an alternate cache file if it wants to.
-# Prefer an explicitly selected file to automatically selected ones.
-ac_site_file1=NONE
-ac_site_file2=NONE
-if test -n "$CONFIG_SITE"; then
-  # We do not want a PATH search for config.site.
-  case $CONFIG_SITE in #((
-    -*)  ac_site_file1=./$CONFIG_SITE;;
-    */*) ac_site_file1=$CONFIG_SITE;;
-    *)   ac_site_file1=./$CONFIG_SITE;;
-  esac
-elif test "x$prefix" != xNONE; then
-  ac_site_file1=$prefix/share/config.site
-  ac_site_file2=$prefix/etc/config.site
-else
-  ac_site_file1=$ac_default_prefix/share/config.site
-  ac_site_file2=$ac_default_prefix/etc/config.site
-fi
-for ac_site_file in "$ac_site_file1" "$ac_site_file2"
-do
-  test "x$ac_site_file" = xNONE && continue
-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-$as_echo "$as_me: loading site script $ac_site_file" >&6;}
-    sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-done
-
-if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special files
-  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-$as_echo "$as_me: loading cache $cache_file" >&6;}
-    case $cache_file in
-      [\\/]* | ?:[\\/]* ) . "$cache_file";;
-      *)                      . "./$cache_file";;
-    esac
-  fi
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-$as_echo "$as_me: creating cache $cache_file" >&6;}
-  >$cache_file
-fi
-
-# Check that the precious variables saved in the cache have kept the same
-# value.
-ac_cache_corrupted=false
-for ac_var in $ac_precious_vars; do
-  eval ac_old_set=\$ac_cv_env_${ac_var}_set
-  eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val=\$ac_cv_env_${ac_var}_value
-  eval ac_new_val=\$ac_env_${ac_var}_value
-  case $ac_old_set,$ac_new_set in
-    set,)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,set)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,);;
-    *)
-      if test "x$ac_old_val" != "x$ac_new_val"; then
-	# differences in whitespace do not lead to failure.
-	ac_old_val_w=`echo x $ac_old_val`
-	ac_new_val_w=`echo x $ac_new_val`
-	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	  ac_cache_corrupted=:
-	else
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-	  eval $ac_var=\$ac_old_val
-	fi
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-      fi;;
-  esac
-  # Pass precious variables to config.status.
-  if test "$ac_new_set" = set; then
-    case $ac_new_val in
-    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-    *) ac_arg=$ac_var=$ac_new_val ;;
-    esac
-    case " $ac_configure_args " in
-      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
-    esac
-  fi
-done
-if $ac_cache_corrupted; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
-fi
-## -------------------- ##
-## Main body of script. ##
-## -------------------- ##
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-
-ac_aux_dir=
-for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
-  if test -f "$ac_dir/install-sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install-sh -c"
-    break
-  elif test -f "$ac_dir/install.sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install.sh -c"
-    break
-  elif test -f "$ac_dir/shtool"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/shtool install -c"
-    break
-  fi
-done
-if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
-fi
-
-# These three variables are undocumented and unsupported,
-# and are intended to be withdrawn in a future Autoconf release.
-# They can cause serious problems if a builder's source tree is in a directory
-# whose full name contains unusual characters.
-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
-
-
-# Make sure we can run config.sub.
-$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
-  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
-$as_echo_n "checking build system type... " >&6; }
-if ${ac_cv_build+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_build_alias=$build_alias
-test "x$ac_build_alias" = x &&
-  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
-test "x$ac_build_alias" = x &&
-  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
-ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
-  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-$as_echo "$ac_cv_build" >&6; }
-case $ac_cv_build in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
-esac
-build=$ac_cv_build
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_build
-shift
-build_cpu=$1
-build_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-build_os=$*
-IFS=$ac_save_IFS
-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
-$as_echo_n "checking host system type... " >&6; }
-if ${ac_cv_host+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test "x$host_alias" = x; then
-  ac_cv_host=$ac_cv_build
-else
-  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-$as_echo "$ac_cv_host" >&6; }
-case $ac_cv_host in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
-esac
-host=$ac_cv_host
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_host
-shift
-host_cpu=$1
-host_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-host_os=$*
-IFS=$ac_save_IFS
-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
-
-
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-
-
-test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
-# Try to create an executable without -o first, disregard a.out.
-# It will help us diagnose broken compilers, and finding out an intuition
-# of exeext.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-$as_echo_n "checking whether the C compiler works... " >&6; }
-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-
-# The possible output files:
-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-
-ac_rmfiles=
-for ac_file in $ac_files
-do
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
-  esac
-done
-rm -f $ac_rmfiles
-
-if { { ac_try="$ac_link_default"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link_default") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-# in a Makefile.  We should not override ac_cv_exeext if it was cached,
-# so that the user can short-circuit this test for compilers unknown to
-# Autoconf.
-for ac_file in $ac_files ''
-do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
-	;;
-    [ab].out )
-	# We found the default executable, but exeext='' is most
-	# certainly right.
-	break;;
-    *.* )
-	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
-	then :; else
-	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	fi
-	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
-	# argument, so we may need to know it at that point already.
-	# Even if this section looks crufty: it has the advantage of
-	# actually working.
-	break;;
-    * )
-	break;;
-  esac
-done
-test "$ac_cv_exeext" = no && ac_cv_exeext=
-
-else
-  ac_file=''
-fi
-if test -z "$ac_file"; then :
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-$as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-$as_echo_n "checking for C compiler default output file name... " >&6; }
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-$as_echo "$ac_file" >&6; }
-ac_exeext=$ac_cv_exeext
-
-rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-$as_echo_n "checking for suffix of executables... " >&6; }
-if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
-for ac_file in conftest.exe conftest conftest.*; do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  break;;
-    * ) break;;
-  esac
-done
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest conftest$ac_cv_exeext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-$as_echo "$ac_cv_exeext" >&6; }
-
-rm -f conftest.$ac_ext
-EXEEXT=$ac_cv_exeext
-ac_exeext=$EXEEXT
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdio.h>
-int
-main ()
-{
-FILE *f = fopen ("conftest.out", "w");
- return ferror (f) || fclose (f) != 0;
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files="$ac_clean_files conftest.out"
-# Check that the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-$as_echo_n "checking whether we are cross compiling... " >&6; }
-if test "$cross_compiling" != yes; then
-  { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-  if { ac_try='./conftest$ac_cv_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
-    fi
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-$as_echo "$cross_compiling" >&6; }
-
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-$as_echo_n "checking for suffix of object files... " >&6; }
-if ${ac_cv_objext+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.o conftest.obj
-if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  for ac_file in conftest.o conftest.obj conftest.*; do
-  test -f "$ac_file" || continue;
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
-       break;;
-  esac
-done
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-$as_echo "$ac_cv_objext" >&6; }
-OBJEXT=$ac_cv_objext
-ac_objext=$OBJEXT
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
-if ${ac_cv_c_compiler_gnu+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_compiler_gnu=yes
-else
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-$as_echo "$ac_cv_c_compiler_gnu" >&6; }
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+set}
-ac_save_CFLAGS=$CFLAGS
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-$as_echo_n "checking whether $CC accepts -g... " >&6; }
-if ${ac_cv_prog_cc_g+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-else
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-else
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-$as_echo "$ac_cv_prog_cc_g" >&6; }
-if test "$ac_test_CFLAGS" = set; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
-if ${ac_cv_prog_cc_c89+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdio.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;
-int
-main ()
-{
-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c89" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c89"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c89" != xno; then :
-
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-# Find a good install program.  We prefer a C program (faster),
-# so one script is as good as another.  But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-$as_echo_n "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if ${ac_cv_path_install+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    # Account for people who put trailing slashes in PATH elements.
-case $as_dir/ in #((
-  ./ | .// | /[cC]/* | \
-  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
-  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
-  /usr/ucb/* ) ;;
-  *)
-    # OSF1 and SCO ODT 3.0 have their own names for install.
-    # Don't use installbsd from OSF since it installs stuff as root
-    # by default.
-    for ac_prog in ginstall scoinst install; do
-      for ac_exec_ext in '' $ac_executable_extensions; do
-	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
-	  if test $ac_prog = install &&
-	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    rm -rf conftest.one conftest.two conftest.dir
-	    echo one > conftest.one
-	    echo two > conftest.two
-	    mkdir conftest.dir
-	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
-	      test -s conftest.one && test -s conftest.two &&
-	      test -s conftest.dir/conftest.one &&
-	      test -s conftest.dir/conftest.two
-	    then
-	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
-	      break 3
-	    fi
-	  fi
-	fi
-      done
-    done
-    ;;
-esac
-
-  done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
-  if test "${ac_cv_path_install+set}" = set; then
-    INSTALL=$ac_cv_path_install
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for INSTALL within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    INSTALL=$ac_install_sh
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-$as_echo "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-
-
-
-
-
-
-
-    if test "$RUSTFLAGS" \= ""
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x
-    then
-        for ac_prog in rustc lcrustc $host-gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    else
-        for ac_prog in rustc lcrustc $host-gccrs gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        as_fn_error $? "Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler" "$LINENO" 5
-    fi
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to compile for $host with $RUSTC" >&5
-$as_echo_n "checking how to compile for $host with $RUSTC... " >&6; }
-    case x$RUSTC in
-        x${host_alias}-* | x*\\/${host_alias}-* )
-            rustc_host_target=${host_alias}
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not needed" >&5
-$as_echo "Not needed" >&6; }
-            ;;
-        x${host}-* | x*\\/${host}-* )
-            rustc_host_target=${host}
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: Not needed" >&5
-$as_echo "Not needed" >&6; }
-            ;;
-
-        x* )
-            SAVE_RUSTFLAGS="$RUSTFLAGS"
-            if test x$host_alias != x
-            then
-                RUSTFLAGS="$RUSTFLAGS --target $host_alias"
-                echo '#![no_std]' > comptest.rs
-                echo Trying target $host_alias >> config.log
-                echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$host_alias
-                else
-                    echo Using target $host_alias failed >> config.log
-                fi
-            fi
-
-            if test x$rustc_host_target \= x
-            then
-                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host"
-                echo '#![no_std]' > comptest.rs
-                echo Trying target $host >> config.log
-                echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$host
-                else
-                    echo Using target $host failed >> config.log
-                fi
-            fi
-
-            if test x$rustc_host_target \= x
-            then
-                case $host in
-                x86_64-*-mingw32 | i*86-*-mingw32 )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-pc-windows-gnu"
-                    echo '#![no_std]' > comptest.rs
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-pc-windows-gnu
-                    fi
-                    ;;
-                x86_64-*-*-* | i*86-*-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_os rustc_host_env <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-unknown-${rustc_host_os}-${rustc_host_env}"
-                    echo '#![no_std]' > comptest.rs
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-unknown-${rustc_host_os}-${rustc_host_env}
-                    fi
-                    ;;
-                x86_64-*-* | i*86-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-unknown-${rustc_host_sys}"
-                    echo '#![no_std]' > comptest.rs
-
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-unknown-${rustc_host_sys}
-                    fi
-                    ;;
-                *-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-${rustc_host_sys}"
-                    echo '#![no_std]' > comptest.rs
-
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-${rustc_host_sys}
-                    fi
-                    ;;
-                esac
-            fi
-            if test x$rustc_host_target \= x
-            then
-                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-$as_echo "not found" >&6; }
-                as_fn_error $? "Cannot compile to $host with $RUSTC" "$LINENO" 5
-            else
-                { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $rustc_host_target" >&5
-$as_echo "--target $rustc_host_target" >&6; }
-            fi
-        ;;
-    esac
-    rm -f comptest.rs libcomptest.rlib
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $RUSTC works" >&5
-$as_echo_n "checking whether $RUSTC works... " >&6; }
-    echo 'fn main(){}' > comptest.rs
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name comptest comptest.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        echo '#![no_std]' > comptest.rs
-        $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest --emit link=libcomptest.rlib comptest.rs 2>> config.log > /dev/null
-        if test $? -ne 0
-        then
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-            as_fn_error $? "Cannot compile a simple program with $RUSTC" "$LINENO" 5
-        else
-            rustc_has_std=no
-        fi
-    else
-        rustc_has_std=yes
-    fi
-
-    if test x$host_alias \= x
-    then
-        ./comptest${EXEEXT}
-        if test $? -ne 0
-        then
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-            as_fn_error $? "Cannot run executables compiled by $RUSTC" "$LINENO" 5
-        fi
-    fi
-
-    rm -f comptest.rs comptest${EXEEXT}
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-
-
-
-
-
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $RUSTC supports edition 2018" >&5
-$as_echo_n "checking if $RUSTC supports edition 2018... " >&6; }
-
-    SAVE_RUSTFLAGS="$RUSTFLAGS"
-    RUSTFLAGS="$RUSTFLAGS --edition 2018"
-
-    echo "" >> test.rs
-    ${RUSTC} ${RUSTFLAGS} --crate-type rlib --crate-name test --emit link=libtest.rlib test.rs
-
-    if test $? -eq 0
-    then
-        rm -f test.rs libtest.rlib
-
-        rust_edition=2018
-
-    else
-        rm -f test.rs libtest.rlib
-        RUSTFLAGS="$SAVE_RUSTFLAGS"
-        rust_edition=no
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-    as_fn_error $? "Cannot target --edition 2018 with $RUSTC" "$LINENO" 5
-
-
-    fi
-
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-
-
-ac_config_files="$ac_config_files Makefile"
-
-
-cat >confcache <<\_ACEOF
-# This file is a shell script that caches the results of configure
-# tests run on this system so they can be shared between configure
-# scripts and configure runs, see configure's option --config-cache.
-# It is not useful on other systems.  If it contains results you don't
-# want to keep, you may remove or edit it.
-#
-# config.status only pays attention to the cache file if you give it
-# the --recheck option to rerun configure.
-#
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
-# following values.
-
-_ACEOF
-
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
-  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-
-  (set) 2>&1 |
-    case $as_nl`(ac_space=' '; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \.
-      sed -n \
-	"s/'/'\\\\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;; #(
-    *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-) |
-  sed '
-     /^ac_cv_env_/b end
-     t clear
-     :clear
-     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
-     t end
-     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     :end' >>confcache
-if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-  if test -w "$cache_file"; then
-    if test "x$cache_file" != "x/dev/null"; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-$as_echo "$as_me: updating cache $cache_file" >&6;}
-      if test ! -f "$cache_file" || test -h "$cache_file"; then
-	cat confcache >"$cache_file"
-      else
-        case $cache_file in #(
-        */* | ?:*)
-	  mv -f confcache "$cache_file"$$ &&
-	  mv -f "$cache_file"$$ "$cache_file" ;; #(
-        *)
-	  mv -f confcache "$cache_file" ;;
-	esac
-      fi
-    fi
-  else
-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
-  fi
-fi
-rm -f confcache
-
-test "x$prefix" = xNONE && prefix=$ac_default_prefix
-# Let make expand exec_prefix.
-test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
-
-# Transform confdefs.h into DEFS.
-# Protect against shell expansion while executing Makefile rules.
-# Protect against Makefile macro expansion.
-#
-# If the first sed substitution is executed (which looks for macros that
-# take arguments), then branch to the quote section.  Otherwise,
-# look for a macro that doesn't take arguments.
-ac_script='
-:mline
-/\\$/{
- N
- s,\\\n,,
- b mline
-}
-t clear
-:clear
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-b any
-:quote
-s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
-s/\[/\\&/g
-s/\]/\\&/g
-s/\$/$$/g
-H
-:any
-${
-	g
-	s/^\n//
-	s/\n/ /g
-	p
-}
-'
-DEFS=`sed -n "$ac_script" confdefs.h`
-
-
-ac_libobjs=
-ac_ltlibobjs=
-U=
-for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-  # 1. Remove the extension, and $U if already installed.
-  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
-  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
-  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-  #    will be set to the directory where LIBOBJS objects are built.
-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
-done
-LIBOBJS=$ac_libobjs
-
-LTLIBOBJS=$ac_ltlibobjs
-
-
-
-: "${CONFIG_STATUS=./config.status}"
-ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
-as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-# Run this file to recreate the current configuration.
-# Compiler output produced by configure, useful for debugging
-# configure, is in config.log if it exists.
-
-debug=false
-ac_cs_recheck=false
-ac_cs_silent=false
-
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
-_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# Save the log message, to keep $0 and so on meaningful, and to
-# report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.
-ac_log="
-This file was extended by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  $ $0 $@
-
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
-"
-
-_ACEOF
-
-case $ac_config_files in *"
-"*) set x $ac_config_files; shift; ac_config_files=$*;;
-esac
-
-
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-# Files that config.status was made for.
-config_files="$ac_config_files"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
-from templates according to the current configuration.  Unless the files
-and actions are specified as TAGs, all are instantiated by default.
-
-Usage: $0 [OPTION]... [TAG]...
-
-  -h, --help       print this help, then exit
-  -V, --version    print version number and configuration settings, then exit
-      --config     print configuration, then exit
-  -q, --quiet, --silent
-                   do not print progress messages
-  -d, --debug      don't remove temporary files
-      --recheck    update $as_me by reconfiguring in the same conditions
-      --file=FILE[:TEMPLATE]
-                   instantiate the configuration file FILE
-
-Configuration files:
-$config_files
-
-Report bugs to the package provider."
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
-ac_cs_version="\\
-config.status
-configured by $0, generated by GNU Autoconf 2.69,
-  with options \\"\$ac_cs_config\\"
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This config.status script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it."
-
-ac_pwd='$ac_pwd'
-srcdir='$srcdir'
-INSTALL='$INSTALL'
-test -n "\$AWK" || AWK=awk
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# The default lists apply if the user does not specify any file.
-ac_need_defaults=:
-while test $# != 0
-do
-  case $1 in
-  --*=?*)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
-    ac_shift=:
-    ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
-  *)
-    ac_option=$1
-    ac_optarg=$2
-    ac_shift=shift
-    ;;
-  esac
-
-  case $ac_option in
-  # Handling of the options.
-  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-    ac_cs_recheck=: ;;
-  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
-    $as_echo "$ac_cs_version"; exit ;;
-  --config | --confi | --conf | --con | --co | --c )
-    $as_echo "$ac_cs_config"; exit ;;
-  --debug | --debu | --deb | --de | --d | -d )
-    debug=: ;;
-  --file | --fil | --fi | --f )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
-    esac
-    as_fn_append CONFIG_FILES " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h |  --help | --hel | -h )
-    $as_echo "$ac_cs_usage"; exit ;;
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil | --si | --s)
-    ac_cs_silent=: ;;
-
-  # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
-
-  *) as_fn_append ac_config_targets " $1"
-     ac_need_defaults=false ;;
-
-  esac
-  shift
-done
-
-ac_configure_extra_args=
-
-if $ac_cs_silent; then
-  exec 6>/dev/null
-  ac_configure_extra_args="$ac_configure_extra_args --silent"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-if \$ac_cs_recheck; then
-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-  shift
-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
-  CONFIG_SHELL='$SHELL'
-  export CONFIG_SHELL
-  exec "\$@"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-  $as_echo "$ac_log"
-} >&5
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-
-# Handling of arguments.
-for ac_config_target in $ac_config_targets
-do
-  case $ac_config_target in
-    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
-
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-  esac
-done
-
-
-# If the user did not use the arguments to specify the items to instantiate,
-# then the envvar interface is used.  Set only those that are not.
-# We use the long form for the default assignment because of an extremely
-# bizarre bug on SunOS 4.1.3.
-if $ac_need_defaults; then
-  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
-fi
-
-# Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason against having it here, and in addition,
-# creating and moving files from /tmp can sometimes cause problems.
-# Hook for its removal unless debugging.
-# Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
-$debug ||
-{
-  tmp= ac_tmp=
-  trap 'exit_status=$?
-  : "${ac_tmp:=$tmp}"
-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
-' 0
-  trap 'as_fn_exit 1' 1 2 13 15
-}
-# Create a (secure) tmp directory for tmp files.
-
-{
-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -d "$tmp"
-}  ||
-{
-  tmp=./conf$$-$RANDOM
-  (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
-ac_tmp=$tmp
-
-# Set up the scripts for CONFIG_FILES section.
-# No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
-if test -n "$CONFIG_FILES"; then
-
-
-ac_cr=`echo X | tr X '\015'`
-# On cygwin, bash can eat \r inside `` if the user requested igncr.
-# But we know of no other shell where ac_cr would be empty at this
-# point, so we can use a bashism as a fallback.
-if test "x$ac_cr" = x; then
-  eval ac_cr=\$\'\\r\'
-fi
-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
-else
-  ac_cs_awk_cr=$ac_cr
-fi
-
-echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
-_ACEOF
-
-
-{
-  echo "cat >conf$$subs.awk <<_ACEOF" &&
-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
-  echo "_ACEOF"
-} >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
-ac_delim='%!_!# '
-for ac_last_try in false false false false false :; do
-  . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-
-  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
-  if test $ac_delim_n = $ac_delim_num; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-rm -f conf$$subs.sh
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
-_ACEOF
-sed -n '
-h
-s/^/S["/; s/!.*/"]=/
-p
-g
-s/^[^!]*!//
-:repl
-t repl
-s/'"$ac_delim"'$//
-t delim
-:nl
-h
-s/\(.\{148\}\)..*/\1/
-t more1
-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
-p
-n
-b repl
-:more1
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t nl
-:delim
-h
-s/\(.\{148\}\)..*/\1/
-t more2
-s/["\\]/\\&/g; s/^/"/; s/$/"/
-p
-b
-:more2
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t delim
-' <conf$$subs.awk | sed '
-/^[^""]/{
-  N
-  s/\n//
-}
-' >>$CONFIG_STATUS || ac_write_fail=1
-rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACAWK
-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
-  for (key in S) S_is_set[key] = 1
-  FS = ""
-
-}
-{
-  line = $ 0
-  nfields = split(line, field, "@")
-  substed = 0
-  len = length(field[1])
-  for (i = 2; i < nfields; i++) {
-    key = field[i]
-    keylen = length(key)
-    if (S_is_set[key]) {
-      value = S[key]
-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
-      len += length(value) + length(field[++i])
-      substed = 1
-    } else
-      len += 1 + keylen
-  }
-
-  print line
-}
-
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
-else
-  cat
-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
-_ACEOF
-
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
-h
-s///
-s/^/:/
-s/[	 ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
-s/:*$//
-x
-s/\(=[	 ]*\).*/\1/
-G
-s/\n//
-s/^[^=]*=[	 ]*$//
-}'
-fi
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-fi # test -n "$CONFIG_FILES"
-
-
-eval set X "  :F $CONFIG_FILES      "
-shift
-for ac_tag
-do
-  case $ac_tag in
-  :[FHLC]) ac_mode=$ac_tag; continue;;
-  esac
-  case $ac_mode$ac_tag in
-  :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-  :[FH]-) ac_tag=-:-;;
-  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-  esac
-  ac_save_IFS=$IFS
-  IFS=:
-  set x $ac_tag
-  IFS=$ac_save_IFS
-  shift
-  ac_file=$1
-  shift
-
-  case $ac_mode in
-  :L) ac_source=$1;;
-  :[FH])
-    ac_file_inputs=
-    for ac_f
-    do
-      case $ac_f in
-      -) ac_f="$ac_tmp/stdin";;
-      *) # Look for the file first in the build tree, then in the source tree
-	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
-	 test -f "$ac_f" ||
-	   case $ac_f in
-	   [\\/$]*) false;;
-	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
-	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-      esac
-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-      as_fn_append ac_file_inputs " '$ac_f'"
-    done
-
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
-    # use $as_me), people would be surprised to read:
-    #    /* config.h.  Generated by config.status.  */
-    configure_input='Generated from '`
-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-	`' by configure.'
-    if test x"$ac_file" != x-; then
-      configure_input="$ac_file.  $configure_input"
-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-$as_echo "$as_me: creating $ac_file" >&6;}
-    fi
-    # Neutralize special characters interpreted by sed in replacement strings.
-    case $configure_input in #(
-    *\&* | *\|* | *\\* )
-       ac_sed_conf_input=`$as_echo "$configure_input" |
-       sed 's/[\\\\&|]/\\\\&/g'`;; #(
-    *) ac_sed_conf_input=$configure_input;;
-    esac
-
-    case $ac_tag in
-    *:-:* | *:-) cat >"$ac_tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
-    esac
-    ;;
-  esac
-
-  ac_dir=`$as_dirname -- "$ac_file" ||
-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_file" : 'X\(//\)[^/]' \| \
-	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  as_dir="$ac_dir"; as_fn_mkdir_p
-  ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-
-  case $ac_mode in
-  :F)
-  #
-  # CONFIG_FILE
-  #
-
-  case $INSTALL in
-  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
-  esac
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# If the template does not know about datarootdir, expand it.
-# FIXME: This hack should be removed a few years after 2.60.
-ac_datarootdir_hack=; ac_datarootdir_seen=
-ac_sed_dataroot='
-/datarootdir/ {
-  p
-  q
-}
-/@datadir@/p
-/@docdir@/p
-/@infodir@/p
-/@localedir@/p
-/@mandir@/p'
-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
-*datarootdir*) ac_datarootdir_seen=yes;;
-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  ac_datarootdir_hack='
-  s&@datadir@&$datadir&g
-  s&@docdir@&$docdir&g
-  s&@infodir@&$infodir&g
-  s&@localedir@&$localedir&g
-  s&@mandir@&$mandir&g
-  s&\\\${datarootdir}&$datarootdir&g' ;;
-esac
-_ACEOF
-
-# Neutralize VPATH when `$srcdir' = `.'.
-# Shell code in configure.ac might set extrasub.
-# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_sed_extra="$ac_vpsub
-$extrasub
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-:t
-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s|@configure_input@|$ac_sed_conf_input|;t t
-s&@top_builddir@&$ac_top_builddir_sub&;t t
-s&@top_build_prefix@&$ac_top_build_prefix&;t t
-s&@srcdir@&$ac_srcdir&;t t
-s&@abs_srcdir@&$ac_abs_srcdir&;t t
-s&@top_srcdir@&$ac_top_srcdir&;t t
-s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
-s&@builddir@&$ac_builddir&;t t
-s&@abs_builddir@&$ac_abs_builddir&;t t
-s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
-s&@INSTALL@&$ac_INSTALL&;t t
-$ac_datarootdir_hack
-"
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-
-test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-      "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
-$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
-
-  rm -f "$ac_tmp/stdin"
-  case $ac_file in
-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
-  esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
- ;;
-
-
-
-  esac
-
-done # for ac_tag
-
-
-as_fn_exit 0
-_ACEOF
-ac_clean_files=$ac_clean_files_save
-
-test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
-
-
-# configure is writing to config.log, and then calls config.status.
-# config.status does its own redirection, appending to config.log.
-# Unfortunately, on DOS this fails, as config.log is still kept open
-# by configure, so config.status won't be able to write to it; its
-# output is simply discarded.  So we exec the FD to /dev/null,
-# effectively closing config.log, so it can be properly (re)opened and
-# appended to by config.status.  When coming back to configure, we
-# need to make the FD available again.
-if test "$no_create" != yes; then
-  ac_cs_success=:
-  ac_config_status_args=
-  test "$silent" = yes &&
-    ac_config_status_args="$ac_config_status_args --quiet"
-  exec 5>/dev/null
-  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
-  exec 5>>config.log
-  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
-  # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
-fi
-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-fi
diff --git a/vendor/fake-enum/configure.ac b/vendor/fake-enum/configure.ac
deleted file mode 100644
index 714b1749..00000000
--- a/vendor/fake-enum/configure.ac
+++ /dev/null
@@ -1,23 +0,0 @@
-AC_INIT()
-
-AC_CONFIG_MACRO_DIRS([m4/])
-
-AC_CANONICAL_HOST
-
-AC_PROG_CC
-AC_PROG_INSTALL
-LCRUST_PROG_RUSTC
-
-
-AC_MSG_CHECKING([if $RUSTC supports edition 2018])
-LCRUST_CHECK_EDITION([2018],[
-    AC_MSG_RESULT([no])
-    AC_MSG_ERROR([Cannot target --edition 2018 with $RUSTC])
-])
-
-AC_MSG_RESULT([yes])
-
-
-AC_CONFIG_FILES([Makefile])
-
-AC_OUTPUT
\ No newline at end of file
diff --git a/vendor/fake-enum/install-sh b/vendor/fake-enum/install-sh
deleted file mode 100755
index ec298b53..00000000
--- a/vendor/fake-enum/install-sh
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2020-11-14.01; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-        shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -p) cpprog="$cpprog -p";;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call 'install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-    dst=$dst_arg
-
-    # If destination is a directory, append the input filename.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
-
-        posix_mkdir=false
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
-	then
-	  if test -z "$dir_arg" || {
-	       # Check for POSIX incompatibilities with -m.
-	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-	       # other-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
-	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
-	fi
-	trap '' 0;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
-      esac
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && continue
-
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask $mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
-
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/vendor/fake-enum/m4/ax_prog_cc_for_build.m4 b/vendor/fake-enum/m4/ax_prog_cc_for_build.m4
deleted file mode 100644
index d53e4f94..00000000
--- a/vendor/fake-enum/m4/ax_prog_cc_for_build.m4
+++ /dev/null
@@ -1,139 +0,0 @@
-# ===========================================================================
-#   https://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_PROG_CC_FOR_BUILD
-#
-# DESCRIPTION
-#
-#   This macro searches for a C compiler that generates native executables,
-#   that is a C compiler that surely is not a cross-compiler. This can be
-#   useful if you have to generate source code at compile-time like for
-#   example GCC does.
-#
-#   The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything
-#   needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD).
-#   The value of these variables can be overridden by the user by specifying
-#   a compiler with an environment variable (like you do for standard CC).
-#
-#   It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object
-#   file extensions for the build platform, and GCC_FOR_BUILD to `yes' if
-#   the compiler we found is GCC. All these variables but GCC_FOR_BUILD are
-#   substituted in the Makefile.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 18
-
-AU_ALIAS([AC_PROG_CC_FOR_BUILD], [AX_PROG_CC_FOR_BUILD])
-AC_DEFUN([AX_PROG_CC_FOR_BUILD], [dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_PROG_CPP])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-
-dnl Use the standard macros, but make them use other variable names
-dnl
-pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP)dnl
-pushdef([ac_cv_prog_cc_c89], ac_cv_build_prog_cc_c89)dnl
-pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc)dnl
-pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works)dnl
-pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross)dnl
-pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g)dnl
-pushdef([ac_cv_c_compiler_gnu], ac_cv_build_c_compiler_gnu)dnl
-pushdef([ac_cv_exeext], ac_cv_build_exeext)dnl
-pushdef([ac_cv_objext], ac_cv_build_objext)dnl
-pushdef([ac_exeext], ac_build_exeext)dnl
-pushdef([ac_objext], ac_build_objext)dnl
-pushdef([CC], CC_FOR_BUILD)dnl
-pushdef([CPP], CPP_FOR_BUILD)dnl
-pushdef([GCC], GCC_FOR_BUILD)dnl
-pushdef([CFLAGS], CFLAGS_FOR_BUILD)dnl
-pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl
-pushdef([EXEEXT], BUILD_EXEEXT)dnl
-pushdef([LDFLAGS], LDFLAGS_FOR_BUILD)dnl
-pushdef([OBJEXT], BUILD_OBJEXT)dnl
-pushdef([host], build)dnl
-pushdef([host_alias], build_alias)dnl
-pushdef([host_cpu], build_cpu)dnl
-pushdef([host_vendor], build_vendor)dnl
-pushdef([host_os], build_os)dnl
-pushdef([ac_cv_host], ac_cv_build)dnl
-pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl
-pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl
-pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl
-pushdef([ac_cv_host_os], ac_cv_build_os)dnl
-pushdef([ac_tool_prefix], ac_build_tool_prefix)dnl
-pushdef([am_cv_CC_dependencies_compiler_type], am_cv_build_CC_dependencies_compiler_type)dnl
-pushdef([am_cv_prog_cc_c_o], am_cv_build_prog_cc_c_o)dnl
-pushdef([cross_compiling], cross_compiling_build)dnl
-
-cross_compiling_build=no
-
-ac_build_tool_prefix=
-AS_IF([test -n "$build"],      [ac_build_tool_prefix="$build-"],
-      [test -n "$build_alias"],[ac_build_tool_prefix="$build_alias-"])
-
-AC_LANG_PUSH([C])
-AC_PROG_CC
-_AC_COMPILER_EXEEXT
-_AC_COMPILER_OBJEXT
-AC_PROG_CPP
-
-dnl Restore the old definitions
-dnl
-popdef([cross_compiling])dnl
-popdef([am_cv_prog_cc_c_o])dnl
-popdef([am_cv_CC_dependencies_compiler_type])dnl
-popdef([ac_tool_prefix])dnl
-popdef([ac_cv_host_os])dnl
-popdef([ac_cv_host_vendor])dnl
-popdef([ac_cv_host_cpu])dnl
-popdef([ac_cv_host_alias])dnl
-popdef([ac_cv_host])dnl
-popdef([host_os])dnl
-popdef([host_vendor])dnl
-popdef([host_cpu])dnl
-popdef([host_alias])dnl
-popdef([host])dnl
-popdef([OBJEXT])dnl
-popdef([LDFLAGS])dnl
-popdef([EXEEXT])dnl
-popdef([CPPFLAGS])dnl
-popdef([CFLAGS])dnl
-popdef([GCC])dnl
-popdef([CPP])dnl
-popdef([CC])dnl
-popdef([ac_objext])dnl
-popdef([ac_exeext])dnl
-popdef([ac_cv_objext])dnl
-popdef([ac_cv_exeext])dnl
-popdef([ac_cv_c_compiler_gnu])dnl
-popdef([ac_cv_prog_cc_g])dnl
-popdef([ac_cv_prog_cc_cross])dnl
-popdef([ac_cv_prog_cc_works])dnl
-popdef([ac_cv_prog_cc_c89])dnl
-popdef([ac_cv_prog_gcc])dnl
-popdef([ac_cv_prog_CPP])dnl
-
-dnl restore global variables ac_ext, ac_cpp, ac_compile,
-dnl ac_link, ac_compiler_gnu (dependant on the current
-dnl language after popping):
-AC_LANG_POP([C])
-
-dnl Finally, set Makefile variables
-dnl
-AC_SUBST(BUILD_EXEEXT)dnl
-AC_SUBST(BUILD_OBJEXT)dnl
-AC_SUBST([CFLAGS_FOR_BUILD])dnl
-AC_SUBST([CPPFLAGS_FOR_BUILD])dnl
-AC_SUBST([LDFLAGS_FOR_BUILD])dnl
-])
\ No newline at end of file
diff --git a/vendor/fake-enum/m4/bindgen.m4 b/vendor/fake-enum/m4/bindgen.m4
deleted file mode 100644
index c9b43fbe..00000000
--- a/vendor/fake-enum/m4/bindgen.m4
+++ /dev/null
@@ -1,5 +0,0 @@
-AC_DEFUN([LCRUST_PROG_BINDGEN],[
-    AC_REQUIRE([AC_PROG_CC])
-    AC_ARG_VAR([BINDGEN])
-    AC_PATH_PROG([BINDGEN],[bindgen])
-])
\ No newline at end of file
diff --git a/vendor/fake-enum/m4/build_std.m4 b/vendor/fake-enum/m4/build_std.m4
deleted file mode 100644
index c75b6e41..00000000
--- a/vendor/fake-enum/m4/build_std.m4
+++ /dev/null
@@ -1,38 +0,0 @@
-
-AC_DEFUN([LCRUST_ENABLE_BUILD_STD],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-    AC_REQUIRE([LCRUST_RUSTC_VERSION])
-
-    AC_ARG_ENABLE([build-std],[
-        build_std=$enableval
-    ],[
-        build_std=no
-    ])
-    
-    if test x$build_std != xno
-    then
-        AC_MSG_NOTICE([Checking how to build-std with $RUSTC... ])
-        if x$rustc_is_lccc != xno
-            then 
-                # $RUSTC is lccc, do what we want.
-                _buildstd_workspace_path="$($RUSTC -Z autotools-hacks --print build-std-workspace-path)"
-                _buildstd_features=""
-                _buildstd_env=""
-            else
-                _rustc_sysroot="$($RUSTC --print sysroot || echo no)"
-                if test "$_rustc_sysroot" != "no"
-                then 
-                    _buildstd_workspace_path="$_rustc_sysroot/lib/rustlib/src/rust"
-                    if test -d "$_buildstd_workspace_path"
-                    then
-                        _buildstd_features="backtrace"
-                        _buildstd_env="RUSTC_BOOTSTRAP=1"
-                    else
-                        _buildstd_output="$($RUSTC --print build-std-info || echo no)"
-
-                    fi
-                fi
-            fi
-    fi
-
-])
\ No newline at end of file
diff --git a/vendor/fake-enum/m4/lcrust_checks.m4 b/vendor/fake-enum/m4/lcrust_checks.m4
deleted file mode 100644
index 25e46850..00000000
--- a/vendor/fake-enum/m4/lcrust_checks.m4
+++ /dev/null
@@ -1,48 +0,0 @@
-
-AC_DEFUN([LCRUST_CHECK_EDITION],[
-    SAVE_RUSTFLAGS="$RUSTFLAGS"
-    RUSTFLAGS="$RUSTFLAGS --edition $1"
-    LCRUST_TRY_COMPILE([],[
-        rust_edition=$1
-    ],
-        RUSTFLAGS="$SAVE_RUSTFLAGS"
-        rust_edition=no
-        $2
-    )
-])
-
-AC_DEFUN([LCRUST_TRY_COMPILE_WITH_FEATURES],[
-    LCRUST_TRY_COMPILE([$1],
-        $3
-    ,
-        [for feature in $2 do
-        do
-            LCRUST_TRY_COMPILE([#![feature($feature)] $1],[
-                try_compile_result=$feature
-                feature_$feature=yes
-                RUSTFLAGS="$RUSTFLAGS --cfg feature_$feature"
-                $3
-            ])
-            if test x$try_compile_result != xno
-            then
-                break
-            fi
-        done
-        if test x$try_compile_result \= xno 
-        then
-            $4
-        fi
-        ]
-    )
-])
-
-AC_DEFUN([LCRUST_CHECK_TOOL],[
-    LCRUST_TRY_COMPILE([#![$1 :: $2]],[
-        tool_$1=yes
-        $4
-    ],[
-        LCRUST_TRY_COMPILE([#![register_tool($1)] $![$1 :: $2]],[
-            tool_$1=register
-        ])
-    ])
-])
\ No newline at end of file
diff --git a/vendor/fake-enum/m4/lcrust_prog_rustc.m4 b/vendor/fake-enum/m4/lcrust_prog_rustc.m4
deleted file mode 100644
index cca98645..00000000
--- a/vendor/fake-enum/m4/lcrust_prog_rustc.m4
+++ /dev/null
@@ -1,585 +0,0 @@
-# Copyright 2021 Connor Horman
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-AC_DEFUN([LCRUST_PROG_RUSTC],[
-    AC_REQUIRE([AC_PROG_CC])
-    AC_REQUIRE([AC_CANONICAL_HOST])
-    AC_ARG_VAR(RUSTC,[Rust compiler to use])
-    AC_ARG_VAR(RUSTFLAGS,[Flags to pass to the rust compiler])
-    
-
-    if test "$RUSTFLAGS" \= "" 
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x 
-    then
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs])
-    else 
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs gccrs])
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler])
-    fi
-    AC_MSG_CHECKING([how to compile for $host with $RUSTC])
-    case x$RUSTC in 
-        x${host_alias}-* | x*[\\/]${host_alias}-* )
-            rustc_host_target=${host_alias}
-            AC_MSG_RESULT([Not needed])
-            ;;
-        x${host}-* | x*[\\/]${host}-* )
-            rustc_host_target=${host}
-            AC_MSG_RESULT([Not needed])
-            ;;
-
-        x* )
-            SAVE_RUSTFLAGS="$RUSTFLAGS"
-            if test x$host_alias != x 
-            then
-                RUSTFLAGS="$RUSTFLAGS --target $host_alias"
-                echo '#![no_std]' > comptest.rs 
-                echo Trying target $host_alias >> config.log
-                echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$host_alias
-                else
-                    echo Using target $host_alias failed >> config.log
-                fi 
-            fi
-            
-            if test x$rustc_host_target \= x
-            then 
-                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host"
-                echo '#![no_std]' > comptest.rs 
-                echo Trying target $host >> config.log
-                echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$host
-                else
-                    echo Using target $host failed >> config.log
-                fi 
-            fi
-
-            if test x$rustc_host_target \= x
-            then
-                case $host in
-                x86_64-*-mingw32 | i*86-*-mingw32 )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-pc-windows-gnu"
-                    echo '#![no_std]' > comptest.rs 
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-pc-windows-gnu
-                    fi
-                    ;;
-                x86_64-*-*-* | i*86-*-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_os rustc_host_env <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-unknown-${rustc_host_os}-${rustc_host_env}"
-                    echo '#![no_std]' > comptest.rs 
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-unknown-${rustc_host_os}-${rustc_host_env}
-                    fi 
-                    ;;
-                x86_64-*-* | i*86-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-unknown-${rustc_host_sys}"
-                    echo '#![no_std]' > comptest.rs 
-
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-unknown-${rustc_host_sys}
-                    fi 
-                    ;;
-                *-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-${rustc_host_sys}"
-                    echo '#![no_std]' > comptest.rs 
-
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-${rustc_host_sys}
-                    fi
-                    ;;
-                esac
-            fi
-            if test x$rustc_host_target \= x
-            then
-                AC_MSG_RESULT([not found])
-                AC_MSG_ERROR([Cannot compile to $host with $RUSTC])
-            else
-                AC_MSG_RESULT([--target $rustc_host_target])
-            fi
-        ;;
-    esac
-    rm -f comptest.rs libcomptest.rlib
-    AC_MSG_CHECKING([whether $RUSTC works])
-    echo 'fn main(){}' > comptest.rs 
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name comptest comptest.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        echo '#![no_std]' > comptest.rs
-        $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest --emit link=libcomptest.rlib comptest.rs 2>> config.log > /dev/null
-        if test $? -ne 0
-        then
-            AC_MSG_RESULT([no])
-            AC_MSG_ERROR([Cannot compile a simple program with $RUSTC])
-        else
-            rustc_has_std=no
-        fi
-    else
-        rustc_has_std=yes
-    fi
-
-    if test x$host_alias \= x 
-    then
-        ./comptest${EXEEXT}
-        if test $? -ne 0
-        then
-            AC_MSG_RESULT([no])
-            AC_MSG_ERROR([Cannot run executables compiled by $RUSTC])
-        fi
-    fi
-
-    rm -f comptest.rs comptest${EXEEXT}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(rustc_has_std)
-    AC_SUBST(RUSTC)
-    AC_SUBST(RUSTFLAGS)
-])
-
-AC_DEFUN([LCRUST_RUSTC_VERSION],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-
-    version_output="`${RUSTC} --version`"
-
-    AC_MSG_CHECKING(the rust version supported by ${RUSTC})
-    
-    read rustc_name rust_version <<< ${version_output}
-
-    AC_MSG_RESULT(${rust_version})
-
-    case $rust_version in
-        *.*.*-beta.* )
-            rust_channel=beta
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${rust_version}
-            IFS="-" read rust_patch <<< ${_lcrust_rest}
-            ;;
-        *.*.*-* )
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${rust_version}
-            IFS="-" read rust_patch rust_channel <<< ${_lcrust_rest}
-            ;;
-        *.*.* )
-            rust_channel=stable
-            IFS="." read rust_major rust_minor rust_patch <<< ${rust_version}
-            ;;
-    esac
-    AC_MSG_CHECKING(whether $RUSTC is lccc)
-    case $rustc_name in
-        lcrust* | lccc* ) dnl lccc doesn't distinguish between stable and unstable compiler, 
-            rustc_is_lccc=yes
-            ;;
-        * )
-            rustc_is_lccc=no
-            ;;
-    esac
-    AC_MSG_RESULT([$rustc_is_lccc])
-    
-    AC_SUBST(rustc_name)
-    AC_SUBST(rust_version)
-    AC_SUBST(rust_channel)
-    AC_SUBST(rust_major)
-    AC_SUBST(rust_minor)
-    AC_SUBST(rust_patch)
-])
-
-AC_DEFUN([LCRUST_PROG_RUSTC_FOR_BUILD],[
-    AC_REQUIRE([AX_PROG_CC_FOR_BUILD])
-    AC_REQUIRE([AC_CANONICAL_BUILD])
-    AC_ARG_VAR(RUSTC_FOR_BUILD,[Rust compiler to use on the build system])
-    AC_ARG_VAR(RUSTFLAGS_FOR_BUILD,[Flags to pass to the rust compiler for the build system])
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build...])
-
-    AC_PATH_PROGS(RUSTC_FOR_BUILD,[rustc lcrustc $build-gccrs gccrs])
-
-    if test "$RUSTC_FOR_BUILD" \= ""
-    then
-        AC_MSG_NOTICE([checking for the compiler to use for $build... not found])
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC_FOR_BUILD to a suitable compiler])
-    fi
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build... $RUSTC_FOR_BUILD])
-
-   AC_MSG_CHECKING([how to compile for $build with $RUSTC_FOR_BUILD])
-    case x$RUSTC_FOR_BUILD in 
-        x${build_alias}-* | x*[\\/]${build_alias}-* )
-            rustc_build_target=${build_alias}
-            AC_MSG_RESULT([Not needed])
-            ;;
-        x${build}-* | x*[\\/]${build}-* )
-            rustc_build_target=${build}
-            AC_MSG_RESULT([Not needed])
-            ;;
-
-        x* )
-            SAVE_RUSTFLAGS_FOR_BUILD="$RUSTFLAGS_FOR_BUILD"
-            if test x$build_alias != x 
-            then
-                RUSTFLAGS_FOR_BUILD="$RUSTFLAGS_FOR_BUILD --target $build_alias"
-                echo 'fn main(){}' > comptest.rs 
-                echo Trying target $build_alias >> config.log
-                echo "$RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$build_alias
-                else
-                    echo Using target $build_alias failed >> config.log
-                fi 
-            fi
-            
-            if test x$rustc_build_target \= x
-            then 
-                RUSTFLAGS_FOR_BUILD="$SAVE_RUSTFLAGS_FOR_BUILD --target $build"
-                echo 'fn main(){}' > comptest.rs 
-                echo Trying target $build >> config.log
-                echo "$RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    rustc_host_target=$build
-                else
-                    echo Using target $build failed >> config.log
-                fi 
-            fi
-
-            if test x$rustc_build_target \= x
-            then
-                case $build in                
-                x86_64-*-mingw32 | i*86-*-mingw32 )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-pc-windows-gnu"
-                    echo '#![no_std]' > comptest.rs 
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-pc-windows-gnu
-                    fi
-                    ;;
-                x86_64-*-*-* | i*86-*-*-* )
-                    IFS="-" read rustc_build_arch rustc_build_vendor rustc_build_os rustc_build_env <<< "$build"
-                    RUSTFLAGS_FOR_BUILD="$SAVE_RUSTFLAGS_FOR_BUILD --target ${rustc_build_arch}-unknown-${rustc_build_os}-${rustc_build_env}"
-                    echo 'fn main(){}' > comptest.rs 
-                    echo "$RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_build_target=${rustc_build_arch}-unknown-${rustc_build_os}-${rustc_build_env}
-                    fi 
-                    ;;
-                x86_64-*-* | i*86-*-* )
-                    IFS="-" read rustc_build_arch rustc_build_vendor rustc_build_sys <<< "$build"
-                    RUSTFLAGS_FOR_BUILD="$SAVE_RUSTFLAGS_FOR_BUILD --target ${rustc_build_arch}-unknown-${rustc_build_sys}"
-                    echo 'fn main(){}' > comptest.rs 
-                    echo "$RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_build_arch}-unknown-${rustc_build_sys}
-                    fi 
-                    ;;
-
-                *-*-* )
-                    IFS="-" read rustc_host_arch rustc_host_vendor rustc_host_sys <<< "$host"
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target ${rustc_host_arch}-${rustc_host_sys}"
-                    echo 'fn main(){}' > comptest.rs 
-
-                    echo "$RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs" >> config.log
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name comptest comptest.rs 2>> config.log > /dev/null
-
-                    if test $? -eq 0
-                    then
-                        rustc_host_target=${rustc_host_arch}-${rustc_host_sys}
-                    fi
-                    ;;
-                esac
-            fi
-            if test x$rustc_build_target \= x
-            then
-                AC_MSG_RESULT([not found])
-                AC_MSG_ERROR([Cannot compile to $build with $RUSTC])
-            else
-                AC_MSG_RESULT([--target $rustc_build_target])
-            fi
-        ;;
-    esac
-
-    rm -f comptest.rs libcomptest.rlib
-    AC_MSG_CHECKING([whether $RUSTC_FOR_BUILD works])
-    echo 'fn main(){}' > test.rs 
-    $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot compile a simple program with $RUSTC_FOR_BUILD])
-    fi
-    
-    ./test${EXEEXT_FOR_BUILD}
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot run executables compiled by $RUSTC_FOR_BUILD])
-    fi
-
-    rm -rf test.rs test${EXEEXT_FOR_BUILD}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(RUSTC_FOR_BUILD)
-    AC_SUBST(RUSTFLAGS_FOR_BUILD)
-])
-
-AC_DEFUN([LCRUST_RUSTC_VERSION_FOR_BUILD],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC_FOR_BUILD])
-
-    version_output="`${RUSTC_FOR_BUILD} --version`"
-
-    AC_MSG_CHECKING(the rust version supported by ${RUSTC_FOR_BUILD})
-    
-    read build_rustc_name build_rust_version <<< ${version_output}
-
-    AC_MSG_RESULT(${build_rust_version})
-
-    case $build_rust_version in
-        *.*.*-beta.* )
-            rust_channel=beta
-            IFS="." read build_rust_major build_rust_minor _lcrust_rest <<< ${build_rust_version}
-            IFS="-" read build_rust_patch <<< ${_lcrust_rest}
-            ;;
-        *.*.*-* )
-            IFS="." read build_rust_major build_rust_minor _lcrust_rest <<< ${build_rust_version}
-            IFS="-" read build_rust_patch build_rust_channel <<< ${_lcrust_rest}
-            ;;
-        *.*.* )
-            rust_channel=stable
-            IFS="." read build_rust_major build_rust_minor build_rust_patch <<< ${build_rust_version}
-            ;;
-    esac
-    AC_MSG_CHECKING(whether $RUSTC_FOR_BUILD is lccc)
-    case $build_rustc_name in
-        lcrust* | lccc* ) dnl lccc doesn't distinguish between stable and unstable compiler, 
-            build_rustc_is_lccc=yes
-            ;;
-        * )
-            build_rustc_is_lccc=no
-            ;;
-    esac
-    AC_MSG_RESULT([$build_rustc_is_lccc])
-    
-    AC_SUBST(build_rustc_name)
-    AC_SUBST(build_rust_version)
-    AC_SUBST(build_rust_channel)
-    AC_SUBST(build_rust_major)
-    AC_SUBST(build_rust_minor)
-    AC_SUBST(build_rust_patch)
-])
-
-
-AC_DEFUN([LCRUST_TRY_COMPILE],[
-    echo ["$1"] >> test.rs
-    ${RUSTC} ${RUSTFLAGS} --crate-type rlib --crate-name test --emit link=libtest.rlib test.rs
-
-    if test $? -eq 0 
-    then
-        rm -f test.rs libtest.rlib
-        $2
-    else
-        rm -f test.rs libtest.rlib
-        $3
-    fi
-])
-
-AC_DEFUN([LCRUST_TRY_COMPILE_FOR_BUILD],[
-    echo ["$1"] >> test.rs
-    ${RUSTC_FOR_BUILD} ${RUSTFLAGS_FOR_BUILD} --crate-type rlib --crate-name test --emit link=libtest.rlib test.rs
-
-    if test $? -eq 0 
-    then
-        rm -f test.rs libtest.rlib
-        try_compile_result=yes
-        $2
-    else
-        rm -f test.rs libtest.rlib
-        try_compile_result=no
-        $3
-    fi
-])
-
-AC_DEFUN([LCRUST_PROG_CARGO],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-    AC_ARG_VAR([CARGO])
-    AC_ARG_VAR([CARGOFLAGS])
-
-    AC_PATH_PROG([CARGO],[cargo])
-
-
-    CARGOFLAGS="$CARGOFLAGS --target $rustc_host_target"
-
-    AC_MSG_CHECKING([whether $CARGO works])
-    mkdir -m700 tmp
-    cat > tmp/Cargo.toml << "EOF"
-[package]
-name = "cargotest"
-version = "0.1.0"
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-
-EOF
-    mkdir tmp/src
-    echo '#![no_std]' > tmp/src/lib.rs
-    CARGO_RUSTFLAGS="`sed -e 's/--target [[[:graph:]]]*//'<<<"$RUSTFLAGS"`"
-    AC_MSG_CHECKING([whether $CARGO works])
-    echo "RUSTC=\"$RUSTC\" RUSTFLAGS=\"$CARGO_RUSTFLAGS\" $CARGO build $CARGOFLAGS --lib --manifest-path tmp/Cargo.toml --target-dir tmp/target/" >> config.log
-    RUSTC="$RUSTC" RUSTFLAGS="$CARGO_RUSTFLAGS" $CARGO build $CARGOFLAGS --lib --manifest-path tmp/Cargo.toml --target-dir tmp/target/ 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        echo "RUSTC=\"$RUSTC\" RUSTFLAGS=\"$CARGO_RUSTFLAGS\" $CARGO gccrs $CARGOFLAGS --lib --manifest-path tmp/Cargo.toml --target-dir tmp/target/" >> config.log
-        RUSTC="$RUSTC" RUSTFLAGS="$CARGO_RUSTFLAGS" $CARGO gccrs $CARGOFLAGS --lib --manifest-path tmp/Cargo.toml --target-dir tmp/target/ 2>> config.log > /dev/null
-        if test $? -ne 0
-        then
-            AC_MSG_RESULT([no])
-            rm -rf tmp/
-            AC_MSG_ERROR([Cannot build a simple workspace with $CARGO])
-        fi
-        cargo_build_command=gccrs
-    else
-        cargo_build_command=build
-    fi
-    rm -rf tmp/
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST([CARGO])
-    AC_SUBST([CARGOFLAGS])
-    AC_SUBST([CARGO_RUSTFLAGS])
-    AC_SUBST([cargo_build_command])
-])
-
-
-AC_DEFUN([LCRUST_PROG_RUSTDOC],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-    AC_ARG_VAR([RUSTDOC])
-    AC_ARG_VAR([RUSTDOCFLAGS])
-
-    AC_PATH_PROG([RUSTDOC],[rustdoc])
-
-    RUSTDOCFLAGS="$RUSTDOCFLAGS --target $rustc_host_target"
-
-    AC_MSG_CHECKING([whether $RUSTDOC works])
-    
-    cat > comptest.rs << EOF
-#![no_std]
-#![doc = r"#
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
-Vivamus quis porttitor tortor, gravida pharetra mi. 
-Cras eu est nec massa faucibus efficitur. 
-Cras congue ultrices efficitur. 
-Cras non auctor augue. 
-Mauris faucibus purus ac dui dictum fermentum. 
-Suspendisse dapibus elementum justo non consequat. 
-Ut sit amet massa vel justo auctor euismod non rutrum justo. 
-Fusce sed porttitor lectus. Sed semper enim eu nunc cursus elementum.
-#"]
-EOF
-
-    echo "$RUSTDOC $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs" >> config.log
-    $RUSTDOC $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs 2> config.log > /dev/null
-
-    if test $? -ne 0
-    then 
-        rm -rf tmp/
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([$RUSTDOC cannot build documentation for a simple program])
-    fi
-
-    if test ! -f tmp/comptest/index.html
-    then
-        rm -rf tmp/
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([$RUSTDOC did not produce output in the expected format])
-    fi
-
-    if test "`grep 'Lorem ipsum dolor sit amet' tmp/comptest/index.html`" \= ""
-    then
-        rm -rf tmp/
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([$RUSTDOC did not produce the expected output])
-    fi
-    rm -rf tmp/
-    AC_MSG_RESULT([yes])
-])
-
-# Separate macro because `--test-builder` is unstable
-AC_DEFUN([LCRUST_RUSTDOC_USE_RUSTC],[
-    AC_REQUIRE([LCRUST_PROG_RUSTDOC])
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-
-    AC_MSG_CHECKING([how to pass --test-builder to $RUSTDOC])
-    echo "$RUSTDOC --test-builder \"$RUSTC\" $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs" >> config.log
-    $RUSTDOC --test-builder "$RUSTC" $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs  2> config.log > /dev/null
-
-    if test $? -eq 0
-    then
-        rustdoc_use_rustc=yes
-        RUSTDOCFLAGS="--test-builder \"$RUSTC\" $RUSTDOCFLAGS"
-        AC_MSG_RESULT([--test-builder \"$RUSTC\"])
-    else 
-        echo "$RUSTDOC -Z unstable-options --test-builder \"$RUSTC\" $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs" >> config.log
-        $RUSTDOC -Z unstable-options --test-builder "$RUSTC" $RUSTDOCFLAGS --crate-type rlib --crate-name comptest --output tmp/ comptest.rs 2> config.log > /dev/null
-        if test $? -eq 0
-            rustdoc_use_rustc=unstable
-            RUSTDOCFLAGS="-Z unstable-options --test-builder \"$RUSTC\" $RUSTDOCFLAGS"
-            AC_MSG_RESULT([-Z unstable-options --test-builder \"$RUSTC\"])
-        else
-            rustdoc_use_rustc=no
-            AC_MSG_RESULT([not found])
-        fi
-    fi
-])
diff --git a/vendor/fake-enum/run-tests.sh b/vendor/fake-enum/run-tests.sh
deleted file mode 100755
index 16d10aff..00000000
--- a/vendor/fake-enum/run-tests.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-for s in $*
-do
-    $s
-done
\ No newline at end of file
diff --git a/vendor/fake-enum/src/lib.rs b/vendor/fake-enum/src/lib.rs
deleted file mode 100644
index 18ac5032..00000000
--- a/vendor/fake-enum/src/lib.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-#![cfg_attr(not(test), no_std)]
-
-//!
-//! Support for fake enum types, that act like rust enums, but all values of the underlying type
-//!  are accepted as values.
-//! See the macro [`fake_enum`] for details.
-
-///
-/// Constructs a "Fake Enum", that acts like a rust enum with unit variants,
-///  but can accept invalid (undefined) variants without undefined behaviour.
-/// The enum derives Copy, Clone, Eq, and PartialEq. Additionally, it implements Debug, where all valid variants are printed as defined,
-///  and invalid variants are formatted as name(value).
-/// Any other derives can be added following the repr.
-/// Two forms of this macro is provided. `enum name` declares an enum named "name". All the variants are declared with the same visibility as the type in the enclosing module.
-/// `enum struct name` declares an scoped enum named "name". The variants are declared `pub` within "name".
-///
-/// In Both cases, it is valid to transmute the declared type to and from the repr type (note that no from implementation is provided)
-///
-/// ```rust
-/// use fake_enum::fake_enum;
-/// fake_enum!{
-///    #[repr(u8)] pub enum Foo{
-///        Bar = 0,
-///        Baz = 1,
-///    }  
-/// };
-/// let x = Bar;
-/// assert_eq!(format!("{:?}",x),"Bar");
-/// assert_eq!(unsafe{std::mem::transmute::<_,Foo>(1u8)},Baz)
-/// ```
-///
-/// The underlying type may be given
-
-#[macro_export]
-macro_rules! fake_enum{
-    {#[repr($tvis:vis $t:ty)] $(#[$meta:meta])* $vis:vis enum $name:ident {
-        $(#![$meta1:meta])*
-        $($(#[$r:meta])* $item:ident = $expr:literal),*$(,)?
-    }} => {
-
-        #[derive(Copy,Clone,Eq,PartialEq)]
-        #[repr(transparent)]
-        $(#[$meta])*
-        $(#[$meta1])*
-        $vis struct $name($tvis $t);
-
-        $(#[allow(non_upper_case_globals)] #[allow(dead_code)] $(#[$r])* $vis const $item: $name = $name($expr as $t);)*
-
-        impl ::core::fmt::Debug for $name{
-            #[allow(unreachable_patterns)]
-            fn fmt(&self,f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result{
-                match self{
-                    $(Self($expr) => f.write_str(::core::stringify!($item)),)*
-                    e => f.write_fmt(::core::format_args!("{}({})",::core::stringify!($name),e.0))
-                }
-            }
-        }
-    };
-    {#[repr($tvis:vis $t:ty)] $(#[$meta:meta])* $vis:vis enum struct $name:ident {
-        $(#![$meta1:meta])*
-        $($(#[$r:meta])* $item:ident = $expr:literal),*$(,)?
-    }} => {
-        #[derive(Copy,Clone,Eq,PartialEq)]
-        #[repr(transparent)]
-        $(#[$meta])*
-        $(#[$meta1])*
-        $vis struct $name($tvis $t);
-        impl $name{
-            $(#[allow(non_upper_case_globals)] #[allow(dead_code)] $(#[$r])* pub const $item: $name = $name($expr as $t);)*
-        }
-        impl ::core::fmt::Debug for $name{
-            #[allow(unreachable_patterns)]
-            fn fmt(&self,f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result{
-                match self{
-                    $(Self($expr) => f.write_str(::core::stringify!($item)),)*
-                    e => f.write_fmt(::core::format_args!("{}({})",::core::stringify!($name),e.0))
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    fake_enum! {
-        #[repr(u16)] pub enum ElfType{
-            //! The type of an elf file
-
-            /// No Elf Type/Invalid Elf File
-            ET_NONE = 0,
-            /// Relocatable file
-            ET_REL = 1,
-            /// Executable file
-            ET_EXEC = 2,
-            /// Dynamic Library/Shared Object
-            ET_DYN = 3,
-            /// Core Dump
-            ET_CORE = 4
-        }
-    }
-
-    #[test]
-    pub fn fake_enum_elf_type_name() {
-        assert_eq!(format!("{:?}", ET_NONE), "ET_NONE");
-        assert_eq!(format!("{:?}", ET_REL), "ET_REL");
-        assert_eq!(format!("{:?}", ET_EXEC), "ET_EXEC");
-        assert_eq!(format!("{:?}", ET_DYN), "ET_DYN");
-        assert_eq!(format!("{:?}", ET_CORE), "ET_CORE");
-    }
-
-    #[test]
-    pub fn fake_enum_partial_eq_impl() {
-        assert_eq!(ET_NONE, ET_NONE);
-        assert_ne!(ET_NONE, ET_REL);
-        assert_ne!(ET_NONE, ET_EXEC);
-        assert_ne!(ET_NONE, ET_DYN);
-        assert_ne!(ET_NONE, ET_CORE);
-        assert_eq!(ET_REL, ET_REL);
-        assert_ne!(ET_REL, ET_EXEC);
-        assert_ne!(ET_REL, ET_DYN);
-        assert_ne!(ET_REL, ET_CORE);
-        assert_eq!(ET_EXEC, ET_EXEC);
-        assert_ne!(ET_EXEC, ET_DYN);
-        assert_ne!(ET_EXEC, ET_CORE);
-        assert_eq!(ET_DYN, ET_DYN);
-        assert_ne!(ET_DYN, ET_CORE);
-        assert_eq!(ET_CORE, ET_CORE);
-    }
-
-    #[test]
-    pub fn fake_enum_transmute_test() {
-        assert_eq!(unsafe { std::mem::transmute::<u16, ElfType>(0) }, ET_NONE);
-        assert_eq!(unsafe { std::mem::transmute::<u16, ElfType>(1) }, ET_REL);
-        assert_eq!(unsafe { std::mem::transmute::<u16, ElfType>(2) }, ET_EXEC);
-        assert_eq!(unsafe { std::mem::transmute::<u16, ElfType>(3) }, ET_DYN);
-        assert_eq!(unsafe { std::mem::transmute::<u16, ElfType>(4) }, ET_CORE);
-    }
-
-    fake_enum! {
-        #[repr(u8)]
-        #[derive(Hash,Default)]
-        pub enum struct NbtTagType{
-            //! The type of an Nbt Tag
-
-            /// An End Tag
-            End = 0,
-            /// A byte
-            Byte = 1,
-            /// A Short
-            Short = 2,
-            /// An Int
-            Int = 3,
-            /// A Long
-            Long = 4,
-            /// A Float
-            Float = 5,
-            Double = 6,
-            ByteArray = 7,
-            String = 8,
-            List = 9,
-            Compound = 10,
-            IntArray = 11,
-            LongArray = 12,
-            FloatArray = 13,
-            DoubleArray = 14,
-            Uuid = 15
-        }
-    }
-
-    fake_enum! {
-        #[repr(pub u8)]
-        pub enum struct Test{
-            Foo = 0
-        }
-    }
-
-    #[test]
-    fn pub_repr_test() {
-        let foo = Test(0);
-        assert_eq!(foo, Test::Foo);
-    }
-}
diff --git a/vendor/install-dirs/.cargo-checksum.json b/vendor/install-dirs/.cargo-checksum.json
deleted file mode 100644
index 64050e6c..00000000
--- a/vendor/install-dirs/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"8ac7cacaf3d7694b4a13007540feb371f08b190a498e559656623e06695b30cc","README.md":"26343ad61987a46f73f3d04661ba54f22e058b0eb64a25ac4b16dcf1c474272c","src/dirs.rs":"d0a2297e819302ece4be5392cd5942b73b42e9bf4adbdc6645c14d121a01e3f1","src/lib.rs":"c56af2f365dd169526767020eaf925873ac8c0237b73364c7076bd80e9ca406f"},"package":"41efed366b6d617c339c0920deaf114b9df08febf66df9810fc97f46e1bb36c4"}
\ No newline at end of file
diff --git a/vendor/install-dirs/Cargo.toml b/vendor/install-dirs/Cargo.toml
deleted file mode 100644
index f96f08dd..00000000
--- a/vendor/install-dirs/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "install-dirs"
-version = "0.2.1"
-authors = ["Connor Horman <chorman64@gmail.com>"]
-description = "Library for handling gnu install directories in rust\n"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/chorman0773/Install-Dirs.git"
-[dependencies.serde]
-version = "1.0.123"
-features = ["derive"]
-optional = true
diff --git a/vendor/install-dirs/README.md b/vendor/install-dirs/README.md
deleted file mode 100644
index a89f6f04..00000000
--- a/vendor/install-dirs/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Rust Install Dirs
-
-A library for handling install directories, similar to gnu autoconf and cmake. 
diff --git a/vendor/install-dirs/src/dirs.rs b/vendor/install-dirs/src/dirs.rs
deleted file mode 100644
index ad44fcd1..00000000
--- a/vendor/install-dirs/src/dirs.rs
+++ /dev/null
@@ -1,632 +0,0 @@
-use std::{
-    collections::HashMap,
-    error::Error,
-    ffi::OsStr,
-    fmt::Display,
-    path::{Path, PathBuf},
-};
-
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(default = "InstallDirs::defaults"))]
-pub struct InstallDirs {
-    pub prefix: PathBuf,
-    pub exec_prefix: PathBuf,
-    pub bindir: PathBuf,
-    pub sbindir: PathBuf,
-    pub libdir: PathBuf,
-    pub libexecdir: PathBuf,
-    pub includedir: PathBuf,
-    pub datarootdir: PathBuf,
-    pub datadir: PathBuf,
-    pub mandir: PathBuf,
-    pub docdir: PathBuf,
-    pub infodir: PathBuf,
-    pub localedir: PathBuf,
-    pub localstatedir: PathBuf,
-    pub runstatedir: PathBuf,
-    pub sharedstatedir: PathBuf,
-    pub sysconfdir: PathBuf,
-}
-
-#[derive(Debug)]
-pub struct CanonicalizationError {
-    prefix: PathBuf,
-}
-
-impl Display for CanonicalizationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("Failed to canonicalize Install Dirs ")?;
-        f.write_fmt(format_args!(
-            "(prefix {} is not an absolute path)",
-            self.prefix.to_str().unwrap_or("(<non-unicode>)")
-        ))
-    }
-}
-
-impl Error for CanonicalizationError {}
-
-impl InstallDirs {
-    ///
-    ///
-    pub fn defaults() -> Self {
-        Self {
-            prefix: if cfg!(windows) {
-                "C:\\Program Files\\"
-            } else {
-                "/usr/local"
-            }
-            .into(),
-            exec_prefix: "".into(),
-            bindir: "bin".into(),
-            sbindir: "sbin".into(),
-            libdir: "lib".into(),
-            libexecdir: "libexec".into(),
-            includedir: "include".into(),
-            datarootdir: "share".into(),
-            datadir: "".into(),
-            mandir: "man".into(),
-            docdir: "doc".into(),
-            infodir: "info".into(),
-            localedir: "locale".into(),
-            localstatedir: "var".into(),
-            runstatedir: "run".into(),
-            sharedstatedir: "com".into(),
-            sysconfdir: "var".into(),
-        }
-    }
-
-    pub fn with_project_name<S: AsRef<OsStr>+?Sized>(name: &S) -> Self {
-        Self {
-            prefix: if cfg!(windows) {
-                let mut buf = PathBuf::new();
-                buf.push("C:\\Program Files");
-                buf.push(name.as_ref());
-                buf
-            } else {
-                "/usr/local".into()
-            },
-            exec_prefix: "".into(),
-            bindir: "bin".into(),
-            sbindir: "sbin".into(),
-            libdir: "lib".into(),
-            libexecdir: "libexec".into(),
-            includedir: "include".into(),
-            datarootdir: "share".into(),
-            datadir: "".into(),
-            mandir: "man".into(),
-            docdir: {
-                let mut path = PathBuf::new();
-                path.push("doc");
-                path.push(name.as_ref());
-                path
-            },
-            infodir: "info".into(),
-            localedir: "locale".into(),
-            localstatedir: "var".into(),
-            runstatedir: "run".into(),
-            sharedstatedir: "com".into(),
-            sysconfdir: "var".into(),
-        }
-    }
-
-    pub fn with_exec_target<S: AsRef<OsStr>>(target: &S) -> Self {
-        Self {
-            prefix: if cfg!(windows) {
-                "C:\\Program Files\\"
-            } else {
-                "/usr/local"
-            }
-            .into(),
-            exec_prefix: target.as_ref().into(),
-            bindir: "bin".into(),
-            sbindir: "sbin".into(),
-            libdir: "lib".into(),
-            libexecdir: "libexec".into(),
-            includedir: "include".into(),
-            datarootdir: "share".into(),
-            datadir: "".into(),
-            mandir: "man".into(),
-            docdir: "doc".into(),
-            infodir: "info".into(),
-            localedir: "locale".into(),
-            localstatedir: "var".into(),
-            runstatedir: "run".into(),
-            sharedstatedir: "com".into(),
-            sysconfdir: "var".into(),
-        }
-    }
-
-    pub fn with_project_name_and_target<S: AsRef<OsStr>, T: AsRef<OsStr>>(
-        name: &S,
-        target: &T,
-    ) -> Self {
-        Self {
-            prefix: if cfg!(windows) {
-                let mut buf = PathBuf::new();
-                buf.push("C:\\Program Files");
-                buf.push(name.as_ref());
-                buf
-            } else {
-                "/usr/local".into()
-            },
-            exec_prefix: target.as_ref().into(),
-            bindir: "bin".into(),
-            sbindir: "sbin".into(),
-            libdir: "lib".into(),
-            libexecdir: "libexec".into(),
-            includedir: "include".into(),
-            datarootdir: "share".into(),
-            datadir: "".into(),
-            mandir: "man".into(),
-            docdir: {
-                let mut path = PathBuf::new();
-                path.push("doc");
-                path.push(name.as_ref());
-                path
-            },
-            infodir: "info".into(),
-            localedir: "locale".into(),
-            localstatedir: "var".into(),
-            runstatedir: "run".into(),
-            sharedstatedir: "com".into(),
-            sysconfdir: "var".into(),
-        }
-    }
-
-    pub fn canonicalize(mut self) -> Result<Self, CanonicalizationError> {
-        if !self.prefix.has_root() {
-            Err(CanonicalizationError {
-                prefix: self.prefix,
-            })
-        } else {
-            if !self.exec_prefix.has_root() {
-                self.exec_prefix = {
-                    let mut path = PathBuf::new();
-                    path.push(self.prefix.clone());
-                    path.push(self.exec_prefix);
-                    path
-                }
-            }
-
-            let exec_prefix = if (&*self.exec_prefix) == Path::new("/") {
-                let mut exec_prefix = PathBuf::new();
-                exec_prefix.push("/usr");
-                exec_prefix
-            } else {
-                self.exec_prefix.clone()
-            };
-            let data_prefix = if (&*self.prefix) == Path::new("/") {
-                let mut exec_prefix = PathBuf::new();
-                exec_prefix.push("/usr");
-                exec_prefix
-            } else {
-                self.prefix.clone()
-            };
-            let state_prefix = if self.prefix.starts_with("/usr") {
-                let mut prefix = PathBuf::new();
-                prefix.push("/");
-                prefix
-            } else {
-                self.prefix.clone()
-            };
-            if !self.bindir.has_root() {
-                self.bindir = {
-                    let mut path = exec_prefix.clone();
-                    path.push(self.bindir);
-                    path
-                };
-            }
-
-            if !self.sbindir.has_root() {
-                self.sbindir = {
-                    let mut path = exec_prefix.clone();
-                    path.push(self.sbindir);
-                    path
-                };
-            }
-
-            if !self.libdir.has_root() {
-                self.libdir = {
-                    let mut path = exec_prefix.clone();
-                    path.push(self.libdir);
-                    path
-                };
-            }
-
-            if !self.libexecdir.has_root() {
-                self.libexecdir = {
-                    let mut path = exec_prefix.clone();
-                    path.push(self.libexecdir);
-                    path
-                };
-            }
-
-            if !self.includedir.has_root() {
-                self.includedir = {
-                    let mut path = exec_prefix.clone();
-                    path.push(self.includedir);
-                    path
-                };
-            }
-
-            if !self.datarootdir.has_root() {
-                self.datarootdir = {
-                    let mut path = data_prefix.clone();
-                    path.push(self.datarootdir);
-                    path
-                };
-            }
-
-            if !self.datadir.has_root() {
-                self.datadir = {
-                    let mut path = self.datarootdir.clone();
-                    path.push(self.datadir);
-                    path
-                };
-            }
-
-            if !self.mandir.has_root() {
-                self.mandir = {
-                    let mut path = self.datarootdir.clone();
-                    path.push(self.mandir);
-                    path
-                };
-            }
-
-            if !self.infodir.has_root() {
-                self.infodir = {
-                    let mut path = self.datarootdir.clone();
-                    path.push(self.infodir);
-                    path
-                };
-            }
-            if !self.docdir.has_root() {
-                self.docdir = {
-                    let mut path = self.datarootdir.clone();
-                    path.push(self.docdir);
-                    path
-                };
-            }
-
-            if !self.localedir.has_root() {
-                self.localedir = {
-                    let mut path = self.datarootdir.clone();
-                    path.push(self.localedir);
-                    path
-                };
-            }
-
-            if !self.sharedstatedir.has_root() {
-                self.sharedstatedir = {
-                    let mut path = data_prefix.clone();
-                    path.push(self.sharedstatedir);
-                    path
-                };
-            }
-
-            if !self.sysconfdir.has_root() {
-                self.sysconfdir = if state_prefix.starts_with("/opt") {
-                    let mut path = PathBuf::new();
-                    path.push("/");
-                    path.push(self.sysconfdir);
-                    path.push(state_prefix.clone());
-                    path
-                } else {
-                    let mut path = state_prefix.clone();
-                    path.push(self.sysconfdir);
-                    path
-                }
-            }
-
-            if !self.localstatedir.has_root() {
-                self.localstatedir = if state_prefix.starts_with("/opt") {
-                    let mut path = PathBuf::new();
-                    path.push("/");
-                    path.push(self.localstatedir);
-                    path.push(state_prefix.clone());
-                    path
-                } else {
-                    let mut path = state_prefix.clone();
-                    path.push(self.localstatedir);
-                    path
-                }
-            }
-
-            if !self.sharedstatedir.has_root() {
-                self.sharedstatedir = {
-                    let mut path = self.localstatedir.clone();
-                    path.push(self.sharedstatedir);
-                    path
-                };
-            }
-
-            Ok(self)
-        }
-    }
-
-    pub fn canonicalize_dir<S: AsRef<OsStr>+?Sized,T: Into<PathBuf>>(base: &S,dir: T)->PathBuf{
-        let mut dir = dir.into();
-        if !dir.has_root(){
-             dir = {
-                let mut path = PathBuf::from(base);
-                path.push(dir);
-                path
-             }
-        }
-        dir
-    }
-
-    pub fn read_env(&mut self) {
-        if let Ok(dir) = std::env::var("prefix") {
-            self.prefix = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("exec_prefix") {
-            self.exec_prefix = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("bindir") {
-            self.bindir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("libdir") {
-            self.libdir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("sbindir") {
-            self.sbindir = dir.into()
-        }
-        if let Ok(dir) = std::env::var("libexecdir") {
-            self.libexecdir = dir.into()
-        }
-        if let Ok(dir) = std::env::var("includedir") {
-            self.includedir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("datarootdir") {
-            self.datarootdir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("datadir") {
-            self.datadir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("mandir") {
-            self.mandir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("docdir") {
-            self.docdir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("infodir") {
-            self.infodir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("localedir") {
-            self.localedir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("sharedstatedir") {
-            self.sharedstatedir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("localstatedir") {
-            self.localstatedir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("runstatedir") {
-            self.runstatedir = dir.into()
-        }
-
-        if let Ok(dir) = std::env::var("sysconfdir") {
-            self.sysconfdir = dir.into()
-        }
-    }
-
-    ///
-    /// Obtains an iterator suitable for passing to [`std::process::Command::envs`].
-    /// The resulting iterator contains each field and the value of that field.
-    /// The order which the Items are encounted is unspecified
-    ///
-    /// ## Example
-    ///
-    /// ```
-    /// use install_dirs::dirs::InstallDirs;
-    /// use std::process::{Command, Stdio};
-    /// let dirs = InstallDirs::defaults();
-    /// let cmd = Command::new("printenv")
-    ///     .stdin(Stdio::null())
-    ///     .stdout(Stdio::inherit())
-    ///     .stderr(Stdio::null())
-    ///     .env_clear()
-    ///     .envs(dirs.as_env())
-    ///     .spawn()
-    ///     .expect("printenv failed to start");
-    /// ```
-    pub fn as_env(&self) -> impl IntoIterator<Item = (&str, &Path)> {
-        let mut map = HashMap::new();
-        map.insert("prefix", &*self.prefix);
-        map.insert("exec_prefix", &*self.exec_prefix);
-        map.insert("bindir", &*self.bindir);
-        map.insert("sbindir", &*self.sbindir);
-        map.insert("libdir", &*self.libdir);
-        map.insert("libexecdir", &*self.libexecdir);
-        map.insert("datarootdir", &*self.datarootdir);
-        map.insert("datadir", &*self.datadir);
-        map.insert("docdir", &*self.docdir);
-        map.insert("mandir", &*self.mandir);
-        map.insert("infodir", &*self.infodir);
-        map.insert("localedir", &*self.localedir);
-        map.insert("sharedstatedir", &*self.sharedstatedir);
-        map.insert("localstatedir", &*self.localstatedir);
-        map.insert("runstatedir", &*self.runstatedir);
-        map.insert("sysconfdir", &*self.sysconfdir);
-        map
-    }
-}
-
-///
-/// Parses the compile-time environment into an instance of InstallDirs.
-/// Note: This returns an owning structure and is not const.
-/// Likely you will want to either store this, or it's canonical representation,
-/// Inside a lazy_static!.
-///
-/// This uses the default installation configuration, see [`InstallDirs::defaults()`]
-/// If a package name is specified as an expression, it uses the defaults for that package name, [`InstallDirs::with_project_name()`].
-#[macro_export]
-macro_rules! parse_env {
-    () => {{
-        let mut dirs = InstallDirs::defaults();
-        if let Some(dir) = std::option_env!("prefix") {
-            dirs.prefix = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("exec_prefix") {
-            dirs.exec_prefix = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("bindir") {
-            dirs.bindir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sbindir") {
-            dirs.sbindir = dir.into();
-        }
-        if let Some(dir) = std::option_env!("libdir") {
-            dirs.libdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("libexecdir") {
-            dirs.libexecdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("includedir") {
-            dirs.includedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("datarootdir") {
-            dirs.datarootdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("datadir") {
-            dirs.datadir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("mandir") {
-            dirs.mandir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("docdir") {
-            dirs.docdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("infodir") {
-            dirs.infodir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("localedir") {
-            dirs.localedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sharedstatedir") {
-            dirs.sharedstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("localstatedir") {
-            dirs.localstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("runstatedir") {
-            dirs.runstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sysconfdir") {
-            dirs.sysconfdir = dir.into();
-        }
-
-        dirs
-    }};
-    ($project:expr) => {{
-        let mut dirs = InstallDirs::with_project_name($project);
-        if let Some(dir) = std::option_env!("prefix") {
-            dirs.prefix = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("exec_prefix") {
-            dirs.exec_prefix = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("bindir") {
-            dirs.bindir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sbindir") {
-            dirs.sbindir = dir.into();
-        }
-        if let Some(dir) = std::option_env!("libdir") {
-            dirs.libdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("libexecdir") {
-            dirs.libexecdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("includedir") {
-            dirs.includedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("datarootdir") {
-            dirs.datarootdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("datadir") {
-            dirs.datadir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("mandir") {
-            dirs.mandir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("docdir") {
-            dirs.docdir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("infodir") {
-            dirs.infodir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("localedir") {
-            dirs.localedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sharedstatedir") {
-            dirs.sharedstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("localstatedir") {
-            dirs.localstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("runstatedir") {
-            dirs.runstatedir = dir.into();
-        }
-
-        if let Some(dir) = std::option_env!("sysconfdir") {
-            dirs.sysconfdir = dir.into();
-        }
-
-        dirs
-    }};
-}
-
-pub fn from_env() -> InstallDirs {
-    let mut dirs = InstallDirs::defaults();
-    dirs.read_env();
-    dirs
-}
diff --git a/vendor/install-dirs/src/lib.rs b/vendor/install-dirs/src/lib.rs
deleted file mode 100644
index 16ec3672..00000000
--- a/vendor/install-dirs/src/lib.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod dirs;
diff --git a/vendor/lazy_static/.cargo-checksum.json b/vendor/lazy_static/.cargo-checksum.json
deleted file mode 100644
index fa241ed8..00000000
--- a/vendor/lazy_static/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"05e37a4e63dc4a495998bb5133252a51d671c4e99061a6342089ed6eab43978a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"e2effacb5bbd7c01523f9a9e4a6a59c0f9b8698753b210fec5742408498197df","src/core_lazy.rs":"6b9fb6a4f553058e240756125b6b9ca43a83ed1fb72964343038ea0ea2e1af10","src/inline_lazy.rs":"f6184afbca4b477616f270790edc180263be806aa92ef0a9de681b4aac9e88c4","src/lib.rs":"99096a5d3089c0d86646f0805d1455befe2cb09683704af29c5c9d99ecab2683","tests/no_std.rs":"d68b149ee51ef5ae2b2906c0c94f5a9812d3b02811b13365c5a35e2ef90d25cf","tests/test.rs":"b3f7d805375dc5af7a2aa4b869944ad2ab4fc982b35ad718ea58f6914dc0a698"},"package":"e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"}
\ No newline at end of file
diff --git a/vendor/lazy_static/Cargo.toml b/vendor/lazy_static/Cargo.toml
deleted file mode 100644
index 7f930c5e..00000000
--- a/vendor/lazy_static/Cargo.toml
+++ /dev/null
@@ -1,46 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "lazy_static"
-version = "1.4.0"
-authors = ["Marvin Löbel <loebel.marvin@gmail.com>"]
-exclude = ["/.travis.yml", "/appveyor.yml"]
-description = "A macro for declaring lazily evaluated statics in Rust."
-documentation = "https://docs.rs/lazy_static"
-readme = "README.md"
-keywords = ["macro", "lazy", "static"]
-categories = ["no-std", "rust-patterns", "memory-management"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-lang-nursery/lazy-static.rs"
-[dependencies.spin]
-version = "0.5.0"
-optional = true
-[dev-dependencies.doc-comment]
-version = "0.3.1"
-
-[features]
-spin_no_std = ["spin"]
-[badges.appveyor]
-repository = "rust-lang-nursery/lazy-static.rs"
-
-[badges.is-it-maintained-issue-resolution]
-repository = "rust-lang-nursery/lazy-static.rs"
-
-[badges.is-it-maintained-open-issues]
-repository = "rust-lang-nursery/lazy-static.rs"
-
-[badges.maintenance]
-status = "passively-maintained"
-
-[badges.travis-ci]
-repository = "rust-lang-nursery/lazy-static.rs"
diff --git a/vendor/lazy_static/LICENSE-APACHE b/vendor/lazy_static/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/lazy_static/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/lazy_static/LICENSE-MIT b/vendor/lazy_static/LICENSE-MIT
deleted file mode 100644
index 25597d58..00000000
--- a/vendor/lazy_static/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2010 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/lazy_static/README.md b/vendor/lazy_static/README.md
deleted file mode 100644
index aa9f8283..00000000
--- a/vendor/lazy_static/README.md
+++ /dev/null
@@ -1,79 +0,0 @@
-lazy-static.rs
-==============
-
-A macro for declaring lazily evaluated statics in Rust.
-
-Using this macro, it is possible to have `static`s that require code to be
-executed at runtime in order to be initialized.
-This includes anything requiring heap allocations, like vectors or hash maps,
-as well as anything that requires non-const function calls to be computed.
-
-[![Travis-CI Status](https://travis-ci.com/rust-lang-nursery/lazy-static.rs.svg?branch=master)](https://travis-ci.com/rust-lang-nursery/lazy-static.rs)
-[![Latest version](https://img.shields.io/crates/v/lazy_static.svg)](https://crates.io/crates/lazy_static)
-[![Documentation](https://docs.rs/lazy_static/badge.svg)](https://docs.rs/lazy_static)
-[![License](https://img.shields.io/crates/l/lazy_static.svg)](https://github.com/rust-lang-nursery/lazy-static.rs#license)
-
-## Minimum supported `rustc`
-
-`1.27.2+`
-
-This version is explicitly tested in CI and may only be bumped in new minor versions. Any changes to the supported minimum version will be called out in the release notes.
-
-
-# Getting Started
-
-[lazy-static.rs is available on crates.io](https://crates.io/crates/lazy_static).
-It is recommended to look there for the newest released version, as well as links to the newest builds of the docs.
-
-At the point of the last update of this README, the latest published version could be used like this:
-
-Add the following dependency to your Cargo manifest...
-
-```toml
-[dependencies]
-lazy_static = "1.4.0"
-```
-
-...and see the [docs](https://docs.rs/lazy_static) for how to use it.
-
-# Example
-
-```rust
-#[macro_use]
-extern crate lazy_static;
-
-use std::collections::HashMap;
-
-lazy_static! {
-    static ref HASHMAP: HashMap<u32, &'static str> = {
-        let mut m = HashMap::new();
-        m.insert(0, "foo");
-        m.insert(1, "bar");
-        m.insert(2, "baz");
-        m
-    };
-}
-
-fn main() {
-    // First access to `HASHMAP` initializes it
-    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
-
-    // Any further access to `HASHMAP` just returns the computed value
-    println!("The entry for `1` is \"{}\".", HASHMAP.get(&1).unwrap());
-}
-```
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
-additional terms or conditions.
diff --git a/vendor/lazy_static/src/core_lazy.rs b/vendor/lazy_static/src/core_lazy.rs
deleted file mode 100644
index b66c3e0d..00000000
--- a/vendor/lazy_static/src/core_lazy.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2016 lazy-static.rs Developers
-//
-// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
-// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
-// http://opensource.org/licenses/MIT>, at your option. This file may not be
-// copied, modified, or distributed except according to those terms.
-
-extern crate spin;
-
-use self::spin::Once;
-
-pub struct Lazy<T: Sync>(Once<T>);
-
-impl<T: Sync> Lazy<T> {
-    pub const INIT: Self = Lazy(Once::INIT);
-
-    #[inline(always)]
-    pub fn get<F>(&'static self, builder: F) -> &T
-        where F: FnOnce() -> T
-    {
-        self.0.call_once(builder)
-    }
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __lazy_static_create {
-    ($NAME:ident, $T:ty) => {
-        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::INIT;
-    }
-}
diff --git a/vendor/lazy_static/src/inline_lazy.rs b/vendor/lazy_static/src/inline_lazy.rs
deleted file mode 100644
index 219ce9c6..00000000
--- a/vendor/lazy_static/src/inline_lazy.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2016 lazy-static.rs Developers
-//
-// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
-// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
-// http://opensource.org/licenses/MIT>, at your option. This file may not be
-// copied, modified, or distributed except according to those terms.
-
-extern crate core;
-extern crate std;
-
-use self::std::prelude::v1::*;
-use self::std::cell::Cell;
-use self::std::hint::unreachable_unchecked;
-use self::std::sync::Once;
-#[allow(deprecated)]
-pub use self::std::sync::ONCE_INIT;
-
-// FIXME: Replace Option<T> with MaybeUninit<T> (stable since 1.36.0)
-pub struct Lazy<T: Sync>(Cell<Option<T>>, Once);
-
-impl<T: Sync> Lazy<T> {
-    #[allow(deprecated)]
-    pub const INIT: Self = Lazy(Cell::new(None), ONCE_INIT);
-
-    #[inline(always)]
-    pub fn get<F>(&'static self, f: F) -> &T
-    where
-        F: FnOnce() -> T,
-    {
-        self.1.call_once(|| {
-            self.0.set(Some(f()));
-        });
-
-        // `self.0` is guaranteed to be `Some` by this point
-        // The `Once` will catch and propagate panics
-        unsafe {
-            match *self.0.as_ptr() {
-                Some(ref x) => x,
-                None => {
-                    debug_assert!(false, "attempted to derefence an uninitialized lazy static. This is a bug");
-
-                    unreachable_unchecked()
-                },
-            }
-        }
-    }
-}
-
-unsafe impl<T: Sync> Sync for Lazy<T> {}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __lazy_static_create {
-    ($NAME:ident, $T:ty) => {
-        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::INIT;
-    };
-}
diff --git a/vendor/lazy_static/src/lib.rs b/vendor/lazy_static/src/lib.rs
deleted file mode 100644
index cada0dc6..00000000
--- a/vendor/lazy_static/src/lib.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2016 lazy-static.rs Developers
-//
-// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
-// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
-// http://opensource.org/licenses/MIT>, at your option. This file may not be
-// copied, modified, or distributed except according to those terms.
-
-/*!
-A macro for declaring lazily evaluated statics.
-
-Using this macro, it is possible to have `static`s that require code to be
-executed at runtime in order to be initialized.
-This includes anything requiring heap allocations, like vectors or hash maps,
-as well as anything that requires function calls to be computed.
-
-# Syntax
-
-```ignore
-lazy_static! {
-    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
-    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
-    ...
-    [pub] static ref NAME_N: TYPE_N = EXPR_N;
-}
-```
-
-Attributes (including doc comments) are supported as well:
-
-```rust
-# #[macro_use]
-# extern crate lazy_static;
-# fn main() {
-lazy_static! {
-    /// This is an example for using doc comment attributes
-    static ref EXAMPLE: u8 = 42;
-}
-# }
-```
-
-# Semantics
-
-For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
-implements `Deref<TYPE>` and stores it in a static with name `NAME`. (Attributes end up
-attaching to this type.)
-
-On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
-can return a reference to the same object. Note that this can lead to deadlocks
-if you have multiple lazy statics that depend on each other in their initialization.
-
-Apart from the lazy initialization, the resulting "static ref" variables
-have generally the same properties as regular "static" variables:
-
-- Any type in them needs to fulfill the `Sync` trait.
-- If the type has a destructor, then it will not run when the process exits.
-
-# Example
-
-Using the macro:
-
-```rust
-#[macro_use]
-extern crate lazy_static;
-
-use std::collections::HashMap;
-
-lazy_static! {
-    static ref HASHMAP: HashMap<u32, &'static str> = {
-        let mut m = HashMap::new();
-        m.insert(0, "foo");
-        m.insert(1, "bar");
-        m.insert(2, "baz");
-        m
-    };
-    static ref COUNT: usize = HASHMAP.len();
-    static ref NUMBER: u32 = times_two(21);
-}
-
-fn times_two(n: u32) -> u32 { n * 2 }
-
-fn main() {
-    println!("The map has {} entries.", *COUNT);
-    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
-    println!("A expensive calculation on a static results in: {}.", *NUMBER);
-}
-```
-
-# Implementation details
-
-The `Deref` implementation uses a hidden static variable that is guarded by an atomic check on each access.
-
-# Cargo features
-
-This crate provides one cargo feature:
-
-- `spin_no_std`: This allows using this crate in a no-std environment, by depending on the standalone `spin` crate.
-
-*/
-
-#![doc(html_root_url = "https://docs.rs/lazy_static/1.4.0")]
-#![no_std]
-
-#[cfg(not(feature = "spin_no_std"))]
-#[path="inline_lazy.rs"]
-#[doc(hidden)]
-pub mod lazy;
-
-#[cfg(test)]
-#[macro_use]
-extern crate doc_comment;
-
-#[cfg(test)]
-doctest!("../README.md");
-
-#[cfg(feature = "spin_no_std")]
-#[path="core_lazy.rs"]
-#[doc(hidden)]
-pub mod lazy;
-
-#[doc(hidden)]
-pub use core::ops::Deref as __Deref;
-
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! __lazy_static_internal {
-    // optional visibility restrictions are wrapped in `()` to allow for
-    // explicitly passing otherwise implicit information about private items
-    ($(#[$attr:meta])* ($($vis:tt)*) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
-        __lazy_static_internal!(@MAKE TY, $(#[$attr])*, ($($vis)*), $N);
-        __lazy_static_internal!(@TAIL, $N : $T = $e);
-        lazy_static!($($t)*);
-    };
-    (@TAIL, $N:ident : $T:ty = $e:expr) => {
-        impl $crate::__Deref for $N {
-            type Target = $T;
-            fn deref(&self) -> &$T {
-                #[inline(always)]
-                fn __static_ref_initialize() -> $T { $e }
-
-                #[inline(always)]
-                fn __stability() -> &'static $T {
-                    __lazy_static_create!(LAZY, $T);
-                    LAZY.get(__static_ref_initialize)
-                }
-                __stability()
-            }
-        }
-        impl $crate::LazyStatic for $N {
-            fn initialize(lazy: &Self) {
-                let _ = &**lazy;
-            }
-        }
-    };
-    // `vis` is wrapped in `()` to prevent parsing ambiguity
-    (@MAKE TY, $(#[$attr:meta])*, ($($vis:tt)*), $N:ident) => {
-        #[allow(missing_copy_implementations)]
-        #[allow(non_camel_case_types)]
-        #[allow(dead_code)]
-        $(#[$attr])*
-        $($vis)* struct $N {__private_field: ()}
-        #[doc(hidden)]
-        $($vis)* static $N: $N = $N {__private_field: ()};
-    };
-    () => ()
-}
-
-#[macro_export(local_inner_macros)]
-macro_rules! lazy_static {
-    ($(#[$attr:meta])* static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
-        // use `()` to explicitly forward the information about private items
-        __lazy_static_internal!($(#[$attr])* () static ref $N : $T = $e; $($t)*);
-    };
-    ($(#[$attr:meta])* pub static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
-        __lazy_static_internal!($(#[$attr])* (pub) static ref $N : $T = $e; $($t)*);
-    };
-    ($(#[$attr:meta])* pub ($($vis:tt)+) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
-        __lazy_static_internal!($(#[$attr])* (pub ($($vis)+)) static ref $N : $T = $e; $($t)*);
-    };
-    () => ()
-}
-
-/// Support trait for enabling a few common operation on lazy static values.
-///
-/// This is implemented by each defined lazy static, and
-/// used by the free functions in this crate.
-pub trait LazyStatic {
-    #[doc(hidden)]
-    fn initialize(lazy: &Self);
-}
-
-/// Takes a shared reference to a lazy static and initializes
-/// it if it has not been already.
-///
-/// This can be used to control the initialization point of a lazy static.
-///
-/// Example:
-///
-/// ```rust
-/// #[macro_use]
-/// extern crate lazy_static;
-///
-/// lazy_static! {
-///     static ref BUFFER: Vec<u8> = (0..255).collect();
-/// }
-///
-/// fn main() {
-///     lazy_static::initialize(&BUFFER);
-///
-///     // ...
-///     work_with_initialized_data(&BUFFER);
-/// }
-/// # fn work_with_initialized_data(_: &[u8]) {}
-/// ```
-pub fn initialize<T: LazyStatic>(lazy: &T) {
-    LazyStatic::initialize(lazy);
-}
diff --git a/vendor/lazy_static/tests/no_std.rs b/vendor/lazy_static/tests/no_std.rs
deleted file mode 100644
index f94a1aaa..00000000
--- a/vendor/lazy_static/tests/no_std.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![cfg(feature="spin_no_std")]
-
-#![no_std]
-
-#[macro_use]
-extern crate lazy_static;
-
-lazy_static! {
-    /// Documentation!
-    pub static ref NUMBER: u32 = times_two(3);
-}
-
-fn times_two(n: u32) -> u32 {
-    n * 2
-}
-
-#[test]
-fn test_basic() {
-    assert_eq!(*NUMBER, 6);
-}
diff --git a/vendor/lazy_static/tests/test.rs b/vendor/lazy_static/tests/test.rs
deleted file mode 100644
index 03d0ab68..00000000
--- a/vendor/lazy_static/tests/test.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-#[macro_use]
-extern crate lazy_static;
-use std::collections::HashMap;
-
-lazy_static! {
-    /// Documentation!
-    pub static ref NUMBER: u32 = times_two(3);
-
-    static ref ARRAY_BOXES: [Box<u32>; 3] = [Box::new(1), Box::new(2), Box::new(3)];
-
-    /// More documentation!
-    #[allow(unused_variables)]
-    #[derive(Copy, Clone, Debug)]
-    pub static ref STRING: String = "hello".to_string();
-
-    static ref HASHMAP: HashMap<u32, &'static str> = {
-        let mut m = HashMap::new();
-        m.insert(0, "abc");
-        m.insert(1, "def");
-        m.insert(2, "ghi");
-        m
-    };
-
-    // This should not compile if the unsafe is removed.
-    static ref UNSAFE: u32 = unsafe {
-        std::mem::transmute::<i32, u32>(-1)
-    };
-}
-
-lazy_static! {
-    static ref S1: &'static str = "a";
-    static ref S2: &'static str = "b";
-}
-lazy_static! {
-    static ref S3: String = [*S1, *S2].join("");
-}
-
-#[test]
-fn s3() {
-    assert_eq!(&*S3, "ab");
-}
-
-fn times_two(n: u32) -> u32 {
-    n * 2
-}
-
-#[test]
-fn test_basic() {
-    assert_eq!(&**STRING, "hello");
-    assert_eq!(*NUMBER, 6);
-    assert!(HASHMAP.get(&1).is_some());
-    assert!(HASHMAP.get(&3).is_none());
-    assert_eq!(&*ARRAY_BOXES, &[Box::new(1), Box::new(2), Box::new(3)]);
-    assert_eq!(*UNSAFE, std::u32::MAX);
-}
-
-#[test]
-fn test_repeat() {
-    assert_eq!(*NUMBER, 6);
-    assert_eq!(*NUMBER, 6);
-    assert_eq!(*NUMBER, 6);
-}
-
-#[test]
-fn test_meta() {
-    // this would not compile if STRING were not marked #[derive(Copy, Clone)]
-    let copy_of_string = STRING;
-    // just to make sure it was copied
-    assert!(&STRING as *const _ != &copy_of_string as *const _);
-
-    // this would not compile if STRING were not marked #[derive(Debug)]
-    assert_eq!(format!("{:?}", STRING), "STRING { __private_field: () }".to_string());
-}
-
-mod visibility {
-    lazy_static! {
-        pub static ref FOO: Box<u32> = Box::new(0);
-        static ref BAR: Box<u32> = Box::new(98);
-    }
-
-    pub mod inner {
-        lazy_static! {
-            pub(in visibility) static ref BAZ: Box<u32> = Box::new(42);
-            pub(crate) static ref BAG: Box<u32> = Box::new(37);
-        }
-    }
-
-    #[test]
-    fn sub_test() {
-        assert_eq!(**FOO, 0);
-        assert_eq!(**BAR, 98);
-        assert_eq!(**inner::BAZ, 42);
-        assert_eq!(**inner::BAG, 37);
-    }
-}
-
-#[test]
-fn test_visibility() {
-    assert_eq!(*visibility::FOO, Box::new(0));
-    assert_eq!(*visibility::inner::BAG, Box::new(37));
-}
-
-// This should not cause a warning about a missing Copy implementation
-lazy_static! {
-    pub static ref VAR: i32 = { 0 };
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-struct X;
-struct Once(X);
-const ONCE_INIT: Once = Once(X);
-static DATA: X = X;
-static ONCE: X = X;
-fn require_sync() -> X { X }
-fn transmute() -> X { X }
-fn __static_ref_initialize() -> X { X }
-fn test(_: Vec<X>) -> X { X }
-
-// All these names should not be shadowed
-lazy_static! {
-    static ref ITEM_NAME_TEST: X = {
-        test(vec![X, Once(X).0, ONCE_INIT.0, DATA, ONCE,
-                  require_sync(), transmute(),
-                  // Except this, which will sadly be shadowed by internals:
-                  // __static_ref_initialize()
-                  ])
-    };
-}
-
-#[test]
-fn item_name_shadowing() {
-    assert_eq!(*ITEM_NAME_TEST, X);
-}
-
-use std::sync::atomic::AtomicBool;
-#[allow(deprecated)]
-use std::sync::atomic::ATOMIC_BOOL_INIT;
-use std::sync::atomic::Ordering::SeqCst;
-
-#[allow(deprecated)]
-static PRE_INIT_FLAG: AtomicBool = ATOMIC_BOOL_INIT;
-
-lazy_static! {
-    static ref PRE_INIT: () = {
-        PRE_INIT_FLAG.store(true, SeqCst);
-        ()
-    };
-}
-
-#[test]
-fn pre_init() {
-    assert_eq!(PRE_INIT_FLAG.load(SeqCst), false);
-    lazy_static::initialize(&PRE_INIT);
-    assert_eq!(PRE_INIT_FLAG.load(SeqCst), true);
-}
-
-lazy_static! {
-    static ref LIFETIME_NAME: for<'a> fn(&'a u8) = { fn f(_: &u8) {} f };
-}
-
-#[test]
-fn lifetime_name() {
-    let _ = LIFETIME_NAME;
-}
diff --git a/vendor/proc-macro2/.cargo-checksum.json b/vendor/proc-macro2/.cargo-checksum.json
deleted file mode 100644
index b88de6c1..00000000
--- a/vendor/proc-macro2/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"0a5984c855f13db167b90022183c267afcebbafa42a5a66bbcba04953d23b7d7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"e1f9d4fc22cff2c049f166a403b41458632a94357890d31cf0e3ad83807fb430","build.rs":"4a6ea112a069e927e40dd79c4b2eaf054521c49eb381c1b24cd5a8a035ee06b5","src/detection.rs":"9d25d896889e65330858f2d6f6223c1b98cd1dad189813ad4161ff189fbda2b8","src/fallback.rs":"c161f65f18d7d19bcbd568f5c0bea1cfc1ce3bd9c66427b1fdb4944ad7966ce0","src/lib.rs":"993e046f5777ea09500775b6323eadd9c48cb48e9f818ec0d39faf50479f019e","src/marker.rs":"87fce2d0357f5b7998b6d9dfb064f4a0cbc9dabb19e33d4b514a446243ebe2e8","src/parse.rs":"b82101576fdc493793f040aa17c11267e2747964729df1f88c81fe413aed407e","src/wrapper.rs":"624527eaa49c272824ab5f7286e6ecbdd80b6eac54e99be11b6e8b29dcb0015d","tests/comments.rs":"ea6cbe6f4c8852e6a0612893c7d4f2c144a2e6a134a6c3db641a320cbfc3c800","tests/features.rs":"a86deb8644992a4eb64d9fd493eff16f9cf9c5cb6ade3a634ce0c990cf87d559","tests/marker.rs":"652db9f25c69ffc65baa60cdca8f195aa2e254d4de0a9ddc85de4dc2470544b6","tests/test.rs":"597186c00ebf51191934c88ff970b5457ca0fb8e608bf896be1ebf8d74c17f4d","tests/test_fmt.rs":"745dfdc41d09c5308c221395eb43f2041f0a1413d2927a813bc2ad4554438fe2"},"package":"b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"}
\ No newline at end of file
diff --git a/vendor/proc-macro2/Cargo.toml b/vendor/proc-macro2/Cargo.toml
deleted file mode 100644
index 901c787f..00000000
--- a/vendor/proc-macro2/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "proc-macro2"
-version = "1.0.29"
-authors = ["Alex Crichton <alex@alexcrichton.com>", "David Tolnay <dtolnay@gmail.com>"]
-description = "A substitute implementation of the compiler's `proc_macro` API to decouple\ntoken-based libraries from the procedural macro use case.\n"
-documentation = "https://docs.rs/proc-macro2"
-readme = "README.md"
-keywords = ["macros"]
-categories = ["development-tools::procedural-macro-helpers"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/alexcrichton/proc-macro2"
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "procmacro2_semver_exempt"]
-rustdoc-args = ["--cfg", "procmacro2_semver_exempt", "--cfg", "doc_cfg"]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[package.metadata.playground]
-features = ["span-locations"]
-[dependencies.unicode-xid]
-version = "0.2"
-[dev-dependencies.quote]
-version = "1.0"
-default_features = false
-
-[features]
-default = ["proc-macro"]
-nightly = []
-proc-macro = []
-span-locations = []
diff --git a/vendor/proc-macro2/LICENSE-APACHE b/vendor/proc-macro2/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/proc-macro2/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/proc-macro2/LICENSE-MIT b/vendor/proc-macro2/LICENSE-MIT
deleted file mode 100644
index 39e0ed66..00000000
--- a/vendor/proc-macro2/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 Alex Crichton
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/proc-macro2/README.md b/vendor/proc-macro2/README.md
deleted file mode 100644
index 3d05e871..00000000
--- a/vendor/proc-macro2/README.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# proc-macro2
-
-[![Build Status](https://img.shields.io/github/workflow/status/alexcrichton/proc-macro2/build%20and%20test)](https://github.com/alexcrichton/proc-macro2/actions)
-[![Latest Version](https://img.shields.io/crates/v/proc-macro2.svg)](https://crates.io/crates/proc-macro2)
-[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/proc-macro2)
-
-A wrapper around the procedural macro API of the compiler's `proc_macro` crate.
-This library serves two purposes:
-
-- **Bring proc-macro-like functionality to other contexts like build.rs and
-  main.rs.** Types from `proc_macro` are entirely specific to procedural macros
-  and cannot ever exist in code outside of a procedural macro. Meanwhile
-  `proc_macro2` types may exist anywhere including non-macro code. By developing
-  foundational libraries like [syn] and [quote] against `proc_macro2` rather
-  than `proc_macro`, the procedural macro ecosystem becomes easily applicable to
-  many other use cases and we avoid reimplementing non-macro equivalents of
-  those libraries.
-
-- **Make procedural macros unit testable.** As a consequence of being specific
-  to procedural macros, nothing that uses `proc_macro` can be executed from a
-  unit test. In order for helper libraries or components of a macro to be
-  testable in isolation, they must be implemented using `proc_macro2`.
-
-[syn]: https://github.com/dtolnay/syn
-[quote]: https://github.com/dtolnay/quote
-
-## Usage
-
-```toml
-[dependencies]
-proc-macro2 = "1.0"
-```
-
-The skeleton of a typical procedural macro typically looks like this:
-
-```rust
-extern crate proc_macro;
-
-#[proc_macro_derive(MyDerive)]
-pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input = proc_macro2::TokenStream::from(input);
-
-    let output: proc_macro2::TokenStream = {
-        /* transform input */
-    };
-
-    proc_macro::TokenStream::from(output)
-}
-```
-
-If parsing with [Syn], you'll use [`parse_macro_input!`] instead to propagate
-parse errors correctly back to the compiler when parsing fails.
-
-[`parse_macro_input!`]: https://docs.rs/syn/1.0/syn/macro.parse_macro_input.html
-
-## Unstable features
-
-The default feature set of proc-macro2 tracks the most recent stable compiler
-API. Functionality in `proc_macro` that is not yet stable is not exposed by
-proc-macro2 by default.
-
-To opt into the additional APIs available in the most recent nightly compiler,
-the `procmacro2_semver_exempt` config flag must be passed to rustc. We will
-polyfill those nightly-only APIs back to Rust 1.31.0. As these are unstable APIs
-that track the nightly compiler, minor versions of proc-macro2 may make breaking
-changes to them at any time.
-
-```
-RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
-```
-
-Note that this must not only be done for your crate, but for any crate that
-depends on your crate. This infectious nature is intentional, as it serves as a
-reminder that you are outside of the normal semver guarantees.
-
-Semver exempt methods are marked as such in the proc-macro2 documentation.
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/proc-macro2/build.rs b/vendor/proc-macro2/build.rs
deleted file mode 100644
index f32d5c8f..00000000
--- a/vendor/proc-macro2/build.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-// rustc-cfg emitted by the build script:
-//
-// "use_proc_macro"
-//     Link to extern crate proc_macro. Available on any compiler and any target
-//     except wasm32. Requires "proc-macro" Cargo cfg to be enabled (default is
-//     enabled). On wasm32 we never link to proc_macro even if "proc-macro" cfg
-//     is enabled.
-//
-// "wrap_proc_macro"
-//     Wrap types from libproc_macro rather than polyfilling the whole API.
-//     Enabled on rustc 1.29+ as long as procmacro2_semver_exempt is not set,
-//     because we can't emulate the unstable API without emulating everything
-//     else. Also enabled unconditionally on nightly, in which case the
-//     procmacro2_semver_exempt surface area is implemented by using the
-//     nightly-only proc_macro API.
-//
-// "hygiene"
-//    Enable Span::mixed_site() and non-dummy behavior of Span::resolved_at
-//    and Span::located_at. Enabled on Rust 1.45+.
-//
-// "proc_macro_span"
-//     Enable non-dummy behavior of Span::start and Span::end methods which
-//     requires an unstable compiler feature. Enabled when building with
-//     nightly, unless `-Z allow-feature` in RUSTFLAGS disallows unstable
-//     features.
-//
-// "super_unstable"
-//     Implement the semver exempt API in terms of the nightly-only proc_macro
-//     API. Enabled when using procmacro2_semver_exempt on a nightly compiler.
-//
-// "span_locations"
-//     Provide methods Span::start and Span::end which give the line/column
-//     location of a token. Enabled by procmacro2_semver_exempt or the
-//     "span-locations" Cargo cfg. This is behind a cfg because tracking
-//     location inside spans is a performance hit.
-
-use std::env;
-use std::iter;
-use std::process::{self, Command};
-use std::str;
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    let version = match rustc_version() {
-        Some(version) => version,
-        None => return,
-    };
-
-    if version.minor < 31 {
-        eprintln!("Minimum supported rustc version is 1.31");
-        process::exit(1);
-    }
-
-    let semver_exempt = cfg!(procmacro2_semver_exempt);
-    if semver_exempt {
-        // https://github.com/alexcrichton/proc-macro2/issues/147
-        println!("cargo:rustc-cfg=procmacro2_semver_exempt");
-    }
-
-    if semver_exempt || cfg!(feature = "span-locations") {
-        println!("cargo:rustc-cfg=span_locations");
-    }
-
-    if version.minor < 32 {
-        println!("cargo:rustc-cfg=no_libprocmacro_unwind_safe");
-    }
-
-    if version.minor < 39 {
-        println!("cargo:rustc-cfg=no_bind_by_move_pattern_guard");
-    }
-
-    if version.minor >= 44 {
-        println!("cargo:rustc-cfg=lexerror_display");
-    }
-
-    if version.minor >= 45 {
-        println!("cargo:rustc-cfg=hygiene");
-    }
-
-    if version.minor >= 54 {
-        println!("cargo:rustc-cfg=literal_from_str");
-    }
-
-    let target = env::var("TARGET").unwrap();
-    if !enable_use_proc_macro(&target) {
-        return;
-    }
-
-    println!("cargo:rustc-cfg=use_proc_macro");
-
-    if version.nightly || !semver_exempt {
-        println!("cargo:rustc-cfg=wrap_proc_macro");
-    }
-
-    if version.nightly && feature_allowed("proc_macro_span") {
-        println!("cargo:rustc-cfg=proc_macro_span");
-    }
-
-    if semver_exempt && version.nightly {
-        println!("cargo:rustc-cfg=super_unstable");
-    }
-}
-
-fn enable_use_proc_macro(target: &str) -> bool {
-    // wasm targets don't have the `proc_macro` crate, disable this feature.
-    if target.contains("wasm32") {
-        return false;
-    }
-
-    // Otherwise, only enable it if our feature is actually enabled.
-    cfg!(feature = "proc-macro")
-}
-
-struct RustcVersion {
-    minor: u32,
-    nightly: bool,
-}
-
-fn rustc_version() -> Option<RustcVersion> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let nightly = version.contains("nightly") || version.contains("dev");
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    let minor = pieces.next()?.parse().ok()?;
-    Some(RustcVersion { minor, nightly })
-}
-
-fn feature_allowed(feature: &str) -> bool {
-    // Recognized formats:
-    //
-    //     -Z allow-features=feature1,feature2
-    //
-    //     -Zallow-features=feature1,feature2
-
-    let flags_var;
-    let flags_var_string;
-    let mut flags_var_split;
-    let mut flags_none;
-    let flags: &mut dyn Iterator<Item = &str> =
-        if let Some(encoded_rustflags) = env::var_os("CARGO_ENCODED_RUSTFLAGS") {
-            flags_var = encoded_rustflags;
-            flags_var_string = flags_var.to_string_lossy();
-            flags_var_split = flags_var_string.split('\x1f');
-            &mut flags_var_split
-        } else if let Some(rustflags) = env::var_os("RUSTFLAGS") {
-            flags_var = rustflags;
-            flags_var_string = flags_var.to_string_lossy();
-            flags_var_split = flags_var_string.split(' ');
-            &mut flags_var_split
-        } else {
-            flags_none = iter::empty();
-            &mut flags_none
-        };
-
-    for mut flag in flags {
-        if flag.starts_with("-Z") {
-            flag = &flag["-Z".len()..];
-        }
-        if flag.starts_with("allow-features=") {
-            flag = &flag["allow-features=".len()..];
-            return flag.split(',').any(|allowed| allowed == feature);
-        }
-    }
-
-    // No allow-features= flag, allowed by default.
-    true
-}
diff --git a/vendor/proc-macro2/src/detection.rs b/vendor/proc-macro2/src/detection.rs
deleted file mode 100644
index c597bc99..00000000
--- a/vendor/proc-macro2/src/detection.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use std::panic::{self, PanicInfo};
-use std::sync::atomic::*;
-use std::sync::Once;
-
-static WORKS: AtomicUsize = AtomicUsize::new(0);
-static INIT: Once = Once::new();
-
-pub(crate) fn inside_proc_macro() -> bool {
-    match WORKS.load(Ordering::SeqCst) {
-        1 => return false,
-        2 => return true,
-        _ => {}
-    }
-
-    INIT.call_once(initialize);
-    inside_proc_macro()
-}
-
-pub(crate) fn force_fallback() {
-    WORKS.store(1, Ordering::SeqCst);
-}
-
-pub(crate) fn unforce_fallback() {
-    initialize();
-}
-
-// Swap in a null panic hook to avoid printing "thread panicked" to stderr,
-// then use catch_unwind to determine whether the compiler's proc_macro is
-// working. When proc-macro2 is used from outside of a procedural macro all
-// of the proc_macro crate's APIs currently panic.
-//
-// The Once is to prevent the possibility of this ordering:
-//
-//     thread 1 calls take_hook, gets the user's original hook
-//     thread 1 calls set_hook with the null hook
-//     thread 2 calls take_hook, thinks null hook is the original hook
-//     thread 2 calls set_hook with the null hook
-//     thread 1 calls set_hook with the actual original hook
-//     thread 2 calls set_hook with what it thinks is the original hook
-//
-// in which the user's hook has been lost.
-//
-// There is still a race condition where a panic in a different thread can
-// happen during the interval that the user's original panic hook is
-// unregistered such that their hook is incorrectly not called. This is
-// sufficiently unlikely and less bad than printing panic messages to stderr
-// on correct use of this crate. Maybe there is a libstd feature request
-// here. For now, if a user needs to guarantee that this failure mode does
-// not occur, they need to call e.g. `proc_macro2::Span::call_site()` from
-// the main thread before launching any other threads.
-fn initialize() {
-    type PanicHook = dyn Fn(&PanicInfo) + Sync + Send + 'static;
-
-    let null_hook: Box<PanicHook> = Box::new(|_panic_info| { /* ignore */ });
-    let sanity_check = &*null_hook as *const PanicHook;
-    let original_hook = panic::take_hook();
-    panic::set_hook(null_hook);
-
-    let works = panic::catch_unwind(proc_macro::Span::call_site).is_ok();
-    WORKS.store(works as usize + 1, Ordering::SeqCst);
-
-    let hopefully_null_hook = panic::take_hook();
-    panic::set_hook(original_hook);
-    if sanity_check != &*hopefully_null_hook {
-        panic!("observed race condition in proc_macro2::inside_proc_macro");
-    }
-}
diff --git a/vendor/proc-macro2/src/fallback.rs b/vendor/proc-macro2/src/fallback.rs
deleted file mode 100644
index 3d2feae1..00000000
--- a/vendor/proc-macro2/src/fallback.rs
+++ /dev/null
@@ -1,923 +0,0 @@
-use crate::parse::{self, Cursor};
-use crate::{Delimiter, Spacing, TokenTree};
-#[cfg(span_locations)]
-use std::cell::RefCell;
-#[cfg(span_locations)]
-use std::cmp;
-use std::fmt::{self, Debug, Display};
-use std::iter::FromIterator;
-use std::mem;
-use std::ops::RangeBounds;
-#[cfg(procmacro2_semver_exempt)]
-use std::path::Path;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::vec;
-use unicode_xid::UnicodeXID;
-
-/// Force use of proc-macro2's fallback implementation of the API for now, even
-/// if the compiler's implementation is available.
-pub fn force() {
-    #[cfg(wrap_proc_macro)]
-    crate::detection::force_fallback();
-}
-
-/// Resume using the compiler's implementation of the proc macro API if it is
-/// available.
-pub fn unforce() {
-    #[cfg(wrap_proc_macro)]
-    crate::detection::unforce_fallback();
-}
-
-#[derive(Clone)]
-pub(crate) struct TokenStream {
-    pub(crate) inner: Vec<TokenTree>,
-}
-
-#[derive(Debug)]
-pub(crate) struct LexError {
-    pub(crate) span: Span,
-}
-
-impl LexError {
-    pub(crate) fn span(&self) -> Span {
-        self.span
-    }
-
-    fn call_site() -> Self {
-        LexError {
-            span: Span::call_site(),
-        }
-    }
-}
-
-impl TokenStream {
-    pub fn new() -> TokenStream {
-        TokenStream { inner: Vec::new() }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0
-    }
-
-    fn take_inner(&mut self) -> Vec<TokenTree> {
-        mem::replace(&mut self.inner, Vec::new())
-    }
-
-    fn push_token(&mut self, token: TokenTree) {
-        // https://github.com/alexcrichton/proc-macro2/issues/235
-        match token {
-            #[cfg(not(no_bind_by_move_pattern_guard))]
-            TokenTree::Literal(crate::Literal {
-                #[cfg(wrap_proc_macro)]
-                    inner: crate::imp::Literal::Fallback(literal),
-                #[cfg(not(wrap_proc_macro))]
-                    inner: literal,
-                ..
-            }) if literal.text.starts_with('-') => {
-                push_negative_literal(self, literal);
-            }
-            #[cfg(no_bind_by_move_pattern_guard)]
-            TokenTree::Literal(crate::Literal {
-                #[cfg(wrap_proc_macro)]
-                    inner: crate::imp::Literal::Fallback(literal),
-                #[cfg(not(wrap_proc_macro))]
-                    inner: literal,
-                ..
-            }) => {
-                if literal.text.starts_with('-') {
-                    push_negative_literal(self, literal);
-                } else {
-                    self.inner
-                        .push(TokenTree::Literal(crate::Literal::_new_stable(literal)));
-                }
-            }
-            _ => self.inner.push(token),
-        }
-
-        #[cold]
-        fn push_negative_literal(stream: &mut TokenStream, mut literal: Literal) {
-            literal.text.remove(0);
-            let mut punct = crate::Punct::new('-', Spacing::Alone);
-            punct.set_span(crate::Span::_new_stable(literal.span));
-            stream.inner.push(TokenTree::Punct(punct));
-            stream
-                .inner
-                .push(TokenTree::Literal(crate::Literal::_new_stable(literal)));
-        }
-    }
-}
-
-// Nonrecursive to prevent stack overflow.
-impl Drop for TokenStream {
-    fn drop(&mut self) {
-        while let Some(token) = self.inner.pop() {
-            let group = match token {
-                TokenTree::Group(group) => group.inner,
-                _ => continue,
-            };
-            #[cfg(wrap_proc_macro)]
-            let group = match group {
-                crate::imp::Group::Fallback(group) => group,
-                _ => continue,
-            };
-            let mut group = group;
-            self.inner.extend(group.stream.take_inner());
-        }
-    }
-}
-
-#[cfg(span_locations)]
-fn get_cursor(src: &str) -> Cursor {
-    // Create a dummy file & add it to the source map
-    SOURCE_MAP.with(|cm| {
-        let mut cm = cm.borrow_mut();
-        let name = format!("<parsed string {}>", cm.files.len());
-        let span = cm.add_file(&name, src);
-        Cursor {
-            rest: src,
-            off: span.lo,
-        }
-    })
-}
-
-#[cfg(not(span_locations))]
-fn get_cursor(src: &str) -> Cursor {
-    Cursor { rest: src }
-}
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        // Create a dummy file & add it to the source map
-        let cursor = get_cursor(src);
-
-        parse::token_stream(cursor)
-    }
-}
-
-impl Display for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("cannot parse string into token stream")
-    }
-}
-
-impl Display for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut joint = false;
-        for (i, tt) in self.inner.iter().enumerate() {
-            if i != 0 && !joint {
-                write!(f, " ")?;
-            }
-            joint = false;
-            match tt {
-                TokenTree::Group(tt) => Display::fmt(tt, f),
-                TokenTree::Ident(tt) => Display::fmt(tt, f),
-                TokenTree::Punct(tt) => {
-                    joint = tt.spacing() == Spacing::Joint;
-                    Display::fmt(tt, f)
-                }
-                TokenTree::Literal(tt) => Display::fmt(tt, f),
-            }?
-        }
-
-        Ok(())
-    }
-}
-
-impl Debug for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("TokenStream ")?;
-        f.debug_list().entries(self.clone()).finish()
-    }
-}
-
-#[cfg(use_proc_macro)]
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        inner
-            .to_string()
-            .parse()
-            .expect("compiler token stream parse failed")
-    }
-}
-
-#[cfg(use_proc_macro)]
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        inner
-            .to_string()
-            .parse()
-            .expect("failed to parse to compiler tokens")
-    }
-}
-
-impl From<TokenTree> for TokenStream {
-    fn from(tree: TokenTree) -> TokenStream {
-        let mut stream = TokenStream::new();
-        stream.push_token(tree);
-        stream
-    }
-}
-
-impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(tokens: I) -> Self {
-        let mut stream = TokenStream::new();
-        stream.extend(tokens);
-        stream
-    }
-}
-
-impl FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
-        let mut v = Vec::new();
-
-        for mut stream in streams {
-            v.extend(stream.take_inner());
-        }
-
-        TokenStream { inner: v }
-    }
-}
-
-impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, tokens: I) {
-        tokens.into_iter().for_each(|token| self.push_token(token));
-    }
-}
-
-impl Extend<TokenStream> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
-        self.inner.extend(streams.into_iter().flatten());
-    }
-}
-
-pub(crate) type TokenTreeIter = vec::IntoIter<TokenTree>;
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = TokenTreeIter;
-
-    fn into_iter(mut self) -> TokenTreeIter {
-        self.take_inner().into_iter()
-    }
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub(crate) struct SourceFile {
-    path: PathBuf,
-}
-
-impl SourceFile {
-    /// Get the path to this source file as a string.
-    pub fn path(&self) -> PathBuf {
-        self.path.clone()
-    }
-
-    pub fn is_real(&self) -> bool {
-        // XXX(nika): Support real files in the future?
-        false
-    }
-}
-
-impl Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("SourceFile")
-            .field("path", &self.path())
-            .field("is_real", &self.is_real())
-            .finish()
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) struct LineColumn {
-    pub line: usize,
-    pub column: usize,
-}
-
-#[cfg(span_locations)]
-thread_local! {
-    static SOURCE_MAP: RefCell<SourceMap> = RefCell::new(SourceMap {
-        // NOTE: We start with a single dummy file which all call_site() and
-        // def_site() spans reference.
-        files: vec![FileInfo {
-            #[cfg(procmacro2_semver_exempt)]
-            name: "<unspecified>".to_owned(),
-            span: Span { lo: 0, hi: 0 },
-            lines: vec![0],
-        }],
-    });
-}
-
-#[cfg(span_locations)]
-struct FileInfo {
-    #[cfg(procmacro2_semver_exempt)]
-    name: String,
-    span: Span,
-    lines: Vec<usize>,
-}
-
-#[cfg(span_locations)]
-impl FileInfo {
-    fn offset_line_column(&self, offset: usize) -> LineColumn {
-        assert!(self.span_within(Span {
-            lo: offset as u32,
-            hi: offset as u32
-        }));
-        let offset = offset - self.span.lo as usize;
-        match self.lines.binary_search(&offset) {
-            Ok(found) => LineColumn {
-                line: found + 1,
-                column: 0,
-            },
-            Err(idx) => LineColumn {
-                line: idx,
-                column: offset - self.lines[idx - 1],
-            },
-        }
-    }
-
-    fn span_within(&self, span: Span) -> bool {
-        span.lo >= self.span.lo && span.hi <= self.span.hi
-    }
-}
-
-/// Computes the offsets of each line in the given source string
-/// and the total number of characters
-#[cfg(span_locations)]
-fn lines_offsets(s: &str) -> (usize, Vec<usize>) {
-    let mut lines = vec![0];
-    let mut total = 0;
-
-    for ch in s.chars() {
-        total += 1;
-        if ch == '\n' {
-            lines.push(total);
-        }
-    }
-
-    (total, lines)
-}
-
-#[cfg(span_locations)]
-struct SourceMap {
-    files: Vec<FileInfo>,
-}
-
-#[cfg(span_locations)]
-impl SourceMap {
-    fn next_start_pos(&self) -> u32 {
-        // Add 1 so there's always space between files.
-        //
-        // We'll always have at least 1 file, as we initialize our files list
-        // with a dummy file.
-        self.files.last().unwrap().span.hi + 1
-    }
-
-    fn add_file(&mut self, name: &str, src: &str) -> Span {
-        let (len, lines) = lines_offsets(src);
-        let lo = self.next_start_pos();
-        // XXX(nika): Shouild we bother doing a checked cast or checked add here?
-        let span = Span {
-            lo,
-            hi: lo + (len as u32),
-        };
-
-        self.files.push(FileInfo {
-            #[cfg(procmacro2_semver_exempt)]
-            name: name.to_owned(),
-            span,
-            lines,
-        });
-
-        #[cfg(not(procmacro2_semver_exempt))]
-        let _ = name;
-
-        span
-    }
-
-    fn fileinfo(&self, span: Span) -> &FileInfo {
-        for file in &self.files {
-            if file.span_within(span) {
-                return file;
-            }
-        }
-        panic!("Invalid span with no related FileInfo!");
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub(crate) struct Span {
-    #[cfg(span_locations)]
-    pub(crate) lo: u32,
-    #[cfg(span_locations)]
-    pub(crate) hi: u32,
-}
-
-impl Span {
-    #[cfg(not(span_locations))]
-    pub fn call_site() -> Span {
-        Span {}
-    }
-
-    #[cfg(span_locations)]
-    pub fn call_site() -> Span {
-        Span { lo: 0, hi: 0 }
-    }
-
-    #[cfg(hygiene)]
-    pub fn mixed_site() -> Span {
-        Span::call_site()
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn def_site() -> Span {
-        Span::call_site()
-    }
-
-    pub fn resolved_at(&self, _other: Span) -> Span {
-        // Stable spans consist only of line/column information, so
-        // `resolved_at` and `located_at` only select which span the
-        // caller wants line/column information from.
-        *self
-    }
-
-    pub fn located_at(&self, other: Span) -> Span {
-        other
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn source_file(&self) -> SourceFile {
-        SOURCE_MAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            SourceFile {
-                path: Path::new(&fi.name).to_owned(),
-            }
-        })
-    }
-
-    #[cfg(span_locations)]
-    pub fn start(&self) -> LineColumn {
-        SOURCE_MAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            fi.offset_line_column(self.lo as usize)
-        })
-    }
-
-    #[cfg(span_locations)]
-    pub fn end(&self) -> LineColumn {
-        SOURCE_MAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            fi.offset_line_column(self.hi as usize)
-        })
-    }
-
-    #[cfg(not(span_locations))]
-    pub fn join(&self, _other: Span) -> Option<Span> {
-        Some(Span {})
-    }
-
-    #[cfg(span_locations)]
-    pub fn join(&self, other: Span) -> Option<Span> {
-        SOURCE_MAP.with(|cm| {
-            let cm = cm.borrow();
-            // If `other` is not within the same FileInfo as us, return None.
-            if !cm.fileinfo(*self).span_within(other) {
-                return None;
-            }
-            Some(Span {
-                lo: cmp::min(self.lo, other.lo),
-                hi: cmp::max(self.hi, other.hi),
-            })
-        })
-    }
-
-    #[cfg(not(span_locations))]
-    fn first_byte(self) -> Self {
-        self
-    }
-
-    #[cfg(span_locations)]
-    fn first_byte(self) -> Self {
-        Span {
-            lo: self.lo,
-            hi: cmp::min(self.lo.saturating_add(1), self.hi),
-        }
-    }
-
-    #[cfg(not(span_locations))]
-    fn last_byte(self) -> Self {
-        self
-    }
-
-    #[cfg(span_locations)]
-    fn last_byte(self) -> Self {
-        Span {
-            lo: cmp::max(self.hi.saturating_sub(1), self.lo),
-            hi: self.hi,
-        }
-    }
-}
-
-impl Debug for Span {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        #[cfg(span_locations)]
-        return write!(f, "bytes({}..{})", self.lo, self.hi);
-
-        #[cfg(not(span_locations))]
-        write!(f, "Span")
-    }
-}
-
-pub(crate) fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
-    #[cfg(span_locations)]
-    {
-        if span.lo == 0 && span.hi == 0 {
-            return;
-        }
-    }
-
-    if cfg!(span_locations) {
-        debug.field("span", &span);
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct Group {
-    delimiter: Delimiter,
-    stream: TokenStream,
-    span: Span,
-}
-
-impl Group {
-    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
-        Group {
-            delimiter,
-            stream,
-            span: Span::call_site(),
-        }
-    }
-
-    pub fn delimiter(&self) -> Delimiter {
-        self.delimiter
-    }
-
-    pub fn stream(&self) -> TokenStream {
-        self.stream.clone()
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn span_open(&self) -> Span {
-        self.span.first_byte()
-    }
-
-    pub fn span_close(&self) -> Span {
-        self.span.last_byte()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-    }
-}
-
-impl Display for Group {
-    // We attempt to match libproc_macro's formatting.
-    // Empty parens: ()
-    // Nonempty parens: (...)
-    // Empty brackets: []
-    // Nonempty brackets: [...]
-    // Empty braces: { }
-    // Nonempty braces: { ... }
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let (open, close) = match self.delimiter {
-            Delimiter::Parenthesis => ("(", ")"),
-            Delimiter::Brace => ("{ ", "}"),
-            Delimiter::Bracket => ("[", "]"),
-            Delimiter::None => ("", ""),
-        };
-
-        f.write_str(open)?;
-        Display::fmt(&self.stream, f)?;
-        if self.delimiter == Delimiter::Brace && !self.stream.inner.is_empty() {
-            f.write_str(" ")?;
-        }
-        f.write_str(close)?;
-
-        Ok(())
-    }
-}
-
-impl Debug for Group {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = fmt.debug_struct("Group");
-        debug.field("delimiter", &self.delimiter);
-        debug.field("stream", &self.stream);
-        debug_span_field_if_nontrivial(&mut debug, self.span);
-        debug.finish()
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct Ident {
-    sym: String,
-    span: Span,
-    raw: bool,
-}
-
-impl Ident {
-    fn _new(string: &str, raw: bool, span: Span) -> Ident {
-        validate_ident(string);
-
-        Ident {
-            sym: string.to_owned(),
-            span,
-            raw,
-        }
-    }
-
-    pub fn new(string: &str, span: Span) -> Ident {
-        Ident::_new(string, false, span)
-    }
-
-    pub fn new_raw(string: &str, span: Span) -> Ident {
-        Ident::_new(string, true, span)
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-    }
-}
-
-pub(crate) fn is_ident_start(c: char) -> bool {
-    ('a' <= c && c <= 'z')
-        || ('A' <= c && c <= 'Z')
-        || c == '_'
-        || (c > '\x7f' && UnicodeXID::is_xid_start(c))
-}
-
-pub(crate) fn is_ident_continue(c: char) -> bool {
-    ('a' <= c && c <= 'z')
-        || ('A' <= c && c <= 'Z')
-        || c == '_'
-        || ('0' <= c && c <= '9')
-        || (c > '\x7f' && UnicodeXID::is_xid_continue(c))
-}
-
-fn validate_ident(string: &str) {
-    let validate = string;
-    if validate.is_empty() {
-        panic!("Ident is not allowed to be empty; use Option<Ident>");
-    }
-
-    if validate.bytes().all(|digit| digit >= b'0' && digit <= b'9') {
-        panic!("Ident cannot be a number; use Literal instead");
-    }
-
-    fn ident_ok(string: &str) -> bool {
-        let mut chars = string.chars();
-        let first = chars.next().unwrap();
-        if !is_ident_start(first) {
-            return false;
-        }
-        for ch in chars {
-            if !is_ident_continue(ch) {
-                return false;
-            }
-        }
-        true
-    }
-
-    if !ident_ok(validate) {
-        panic!("{:?} is not a valid Ident", string);
-    }
-}
-
-impl PartialEq for Ident {
-    fn eq(&self, other: &Ident) -> bool {
-        self.sym == other.sym && self.raw == other.raw
-    }
-}
-
-impl<T> PartialEq<T> for Ident
-where
-    T: ?Sized + AsRef<str>,
-{
-    fn eq(&self, other: &T) -> bool {
-        let other = other.as_ref();
-        if self.raw {
-            other.starts_with("r#") && self.sym == other[2..]
-        } else {
-            self.sym == other
-        }
-    }
-}
-
-impl Display for Ident {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.raw {
-            f.write_str("r#")?;
-        }
-        Display::fmt(&self.sym, f)
-    }
-}
-
-impl Debug for Ident {
-    // Ident(proc_macro), Ident(r#union)
-    #[cfg(not(span_locations))]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = f.debug_tuple("Ident");
-        debug.field(&format_args!("{}", self));
-        debug.finish()
-    }
-
-    // Ident {
-    //     sym: proc_macro,
-    //     span: bytes(128..138)
-    // }
-    #[cfg(span_locations)]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = f.debug_struct("Ident");
-        debug.field("sym", &format_args!("{}", self));
-        debug_span_field_if_nontrivial(&mut debug, self.span);
-        debug.finish()
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct Literal {
-    text: String,
-    span: Span,
-}
-
-macro_rules! suffixed_numbers {
-    ($($name:ident => $kind:ident,)*) => ($(
-        pub fn $name(n: $kind) -> Literal {
-            Literal::_new(format!(concat!("{}", stringify!($kind)), n))
-        }
-    )*)
-}
-
-macro_rules! unsuffixed_numbers {
-    ($($name:ident => $kind:ident,)*) => ($(
-        pub fn $name(n: $kind) -> Literal {
-            Literal::_new(n.to_string())
-        }
-    )*)
-}
-
-impl Literal {
-    pub(crate) fn _new(text: String) -> Literal {
-        Literal {
-            text,
-            span: Span::call_site(),
-        }
-    }
-
-    suffixed_numbers! {
-        u8_suffixed => u8,
-        u16_suffixed => u16,
-        u32_suffixed => u32,
-        u64_suffixed => u64,
-        u128_suffixed => u128,
-        usize_suffixed => usize,
-        i8_suffixed => i8,
-        i16_suffixed => i16,
-        i32_suffixed => i32,
-        i64_suffixed => i64,
-        i128_suffixed => i128,
-        isize_suffixed => isize,
-
-        f32_suffixed => f32,
-        f64_suffixed => f64,
-    }
-
-    unsuffixed_numbers! {
-        u8_unsuffixed => u8,
-        u16_unsuffixed => u16,
-        u32_unsuffixed => u32,
-        u64_unsuffixed => u64,
-        u128_unsuffixed => u128,
-        usize_unsuffixed => usize,
-        i8_unsuffixed => i8,
-        i16_unsuffixed => i16,
-        i32_unsuffixed => i32,
-        i64_unsuffixed => i64,
-        i128_unsuffixed => i128,
-        isize_unsuffixed => isize,
-    }
-
-    pub fn f32_unsuffixed(f: f32) -> Literal {
-        let mut s = f.to_string();
-        if !s.contains('.') {
-            s.push_str(".0");
-        }
-        Literal::_new(s)
-    }
-
-    pub fn f64_unsuffixed(f: f64) -> Literal {
-        let mut s = f.to_string();
-        if !s.contains('.') {
-            s.push_str(".0");
-        }
-        Literal::_new(s)
-    }
-
-    pub fn string(t: &str) -> Literal {
-        let mut text = String::with_capacity(t.len() + 2);
-        text.push('"');
-        for c in t.chars() {
-            if c == '\'' {
-                // escape_debug turns this into "\'" which is unnecessary.
-                text.push(c);
-            } else {
-                text.extend(c.escape_debug());
-            }
-        }
-        text.push('"');
-        Literal::_new(text)
-    }
-
-    pub fn character(t: char) -> Literal {
-        let mut text = String::new();
-        text.push('\'');
-        if t == '"' {
-            // escape_debug turns this into '\"' which is unnecessary.
-            text.push(t);
-        } else {
-            text.extend(t.escape_debug());
-        }
-        text.push('\'');
-        Literal::_new(text)
-    }
-
-    pub fn byte_string(bytes: &[u8]) -> Literal {
-        let mut escaped = "b\"".to_string();
-        for b in bytes {
-            #[allow(clippy::match_overlapping_arm)]
-            match *b {
-                b'\0' => escaped.push_str(r"\0"),
-                b'\t' => escaped.push_str(r"\t"),
-                b'\n' => escaped.push_str(r"\n"),
-                b'\r' => escaped.push_str(r"\r"),
-                b'"' => escaped.push_str("\\\""),
-                b'\\' => escaped.push_str("\\\\"),
-                b'\x20'..=b'\x7E' => escaped.push(*b as char),
-                _ => escaped.push_str(&format!("\\x{:02X}", b)),
-            }
-        }
-        escaped.push('"');
-        Literal::_new(escaped)
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-    }
-
-    pub fn subspan<R: RangeBounds<usize>>(&self, _range: R) -> Option<Span> {
-        None
-    }
-}
-
-impl FromStr for Literal {
-    type Err = LexError;
-
-    fn from_str(repr: &str) -> Result<Self, Self::Err> {
-        let cursor = get_cursor(repr);
-        if let Ok((_rest, literal)) = parse::literal(cursor) {
-            if literal.text.len() == repr.len() {
-                return Ok(literal);
-            }
-        }
-        Err(LexError::call_site())
-    }
-}
-
-impl Display for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.text, f)
-    }
-}
-
-impl Debug for Literal {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = fmt.debug_struct("Literal");
-        debug.field("lit", &format_args!("{}", self.text));
-        debug_span_field_if_nontrivial(&mut debug, self.span);
-        debug.finish()
-    }
-}
diff --git a/vendor/proc-macro2/src/lib.rs b/vendor/proc-macro2/src/lib.rs
deleted file mode 100644
index 1d35bfd2..00000000
--- a/vendor/proc-macro2/src/lib.rs
+++ /dev/null
@@ -1,1272 +0,0 @@
-//! A wrapper around the procedural macro API of the compiler's [`proc_macro`]
-//! crate. This library serves two purposes:
-//!
-//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/
-//!
-//! - **Bring proc-macro-like functionality to other contexts like build.rs and
-//!   main.rs.** Types from `proc_macro` are entirely specific to procedural
-//!   macros and cannot ever exist in code outside of a procedural macro.
-//!   Meanwhile `proc_macro2` types may exist anywhere including non-macro code.
-//!   By developing foundational libraries like [syn] and [quote] against
-//!   `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem
-//!   becomes easily applicable to many other use cases and we avoid
-//!   reimplementing non-macro equivalents of those libraries.
-//!
-//! - **Make procedural macros unit testable.** As a consequence of being
-//!   specific to procedural macros, nothing that uses `proc_macro` can be
-//!   executed from a unit test. In order for helper libraries or components of
-//!   a macro to be testable in isolation, they must be implemented using
-//!   `proc_macro2`.
-//!
-//! [syn]: https://github.com/dtolnay/syn
-//! [quote]: https://github.com/dtolnay/quote
-//!
-//! # Usage
-//!
-//! The skeleton of a typical procedural macro typically looks like this:
-//!
-//! ```
-//! extern crate proc_macro;
-//!
-//! # const IGNORE: &str = stringify! {
-//! #[proc_macro_derive(MyDerive)]
-//! # };
-//! # #[cfg(wrap_proc_macro)]
-//! pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-//!     let input = proc_macro2::TokenStream::from(input);
-//!
-//!     let output: proc_macro2::TokenStream = {
-//!         /* transform input */
-//!         # input
-//!     };
-//!
-//!     proc_macro::TokenStream::from(output)
-//! }
-//! ```
-//!
-//! If parsing with [Syn], you'll use [`parse_macro_input!`] instead to
-//! propagate parse errors correctly back to the compiler when parsing fails.
-//!
-//! [`parse_macro_input!`]: https://docs.rs/syn/1.0/syn/macro.parse_macro_input.html
-//!
-//! # Unstable features
-//!
-//! The default feature set of proc-macro2 tracks the most recent stable
-//! compiler API. Functionality in `proc_macro` that is not yet stable is not
-//! exposed by proc-macro2 by default.
-//!
-//! To opt into the additional APIs available in the most recent nightly
-//! compiler, the `procmacro2_semver_exempt` config flag must be passed to
-//! rustc. We will polyfill those nightly-only APIs back to Rust 1.31.0. As
-//! these are unstable APIs that track the nightly compiler, minor versions of
-//! proc-macro2 may make breaking changes to them at any time.
-//!
-//! ```sh
-//! RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
-//! ```
-//!
-//! Note that this must not only be done for your crate, but for any crate that
-//! depends on your crate. This infectious nature is intentional, as it serves
-//! as a reminder that you are outside of the normal semver guarantees.
-//!
-//! Semver exempt methods are marked as such in the proc-macro2 documentation.
-//!
-//! # Thread-Safety
-//!
-//! Most types in this crate are `!Sync` because the underlying compiler
-//! types make use of thread-local memory, meaning they cannot be accessed from
-//! a different thread.
-
-// Proc-macro2 types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/proc-macro2/1.0.29")]
-#![cfg_attr(any(proc_macro_span, super_unstable), feature(proc_macro_span))]
-#![cfg_attr(super_unstable, feature(proc_macro_raw_ident, proc_macro_def_site))]
-#![cfg_attr(doc_cfg, feature(doc_cfg))]
-#![allow(clippy::needless_doctest_main, clippy::vec_init_then_push)]
-
-#[cfg(use_proc_macro)]
-extern crate proc_macro;
-
-mod marker;
-mod parse;
-
-#[cfg(wrap_proc_macro)]
-mod detection;
-
-// Public for proc_macro2::fallback::force() and unforce(), but those are quite
-// a niche use case so we omit it from rustdoc.
-#[doc(hidden)]
-pub mod fallback;
-
-#[cfg(not(wrap_proc_macro))]
-use crate::fallback as imp;
-#[path = "wrapper.rs"]
-#[cfg(wrap_proc_macro)]
-mod imp;
-
-use crate::marker::Marker;
-use std::cmp::Ordering;
-use std::error::Error;
-use std::fmt::{self, Debug, Display};
-use std::hash::{Hash, Hasher};
-use std::iter::FromIterator;
-use std::ops::RangeBounds;
-#[cfg(procmacro2_semver_exempt)]
-use std::path::PathBuf;
-use std::str::FromStr;
-
-/// An abstract stream of tokens, or more concretely a sequence of token trees.
-///
-/// This type provides interfaces for iterating over token trees and for
-/// collecting token trees into one stream.
-///
-/// Token stream is both the input and output of `#[proc_macro]`,
-/// `#[proc_macro_attribute]` and `#[proc_macro_derive]` definitions.
-#[derive(Clone)]
-pub struct TokenStream {
-    inner: imp::TokenStream,
-    _marker: Marker,
-}
-
-/// Error returned from `TokenStream::from_str`.
-pub struct LexError {
-    inner: imp::LexError,
-    _marker: Marker,
-}
-
-impl TokenStream {
-    fn _new(inner: imp::TokenStream) -> TokenStream {
-        TokenStream {
-            inner,
-            _marker: Marker,
-        }
-    }
-
-    fn _new_stable(inner: fallback::TokenStream) -> TokenStream {
-        TokenStream {
-            inner: inner.into(),
-            _marker: Marker,
-        }
-    }
-
-    /// Returns an empty `TokenStream` containing no token trees.
-    pub fn new() -> TokenStream {
-        TokenStream::_new(imp::TokenStream::new())
-    }
-
-    /// Checks if this `TokenStream` is empty.
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-}
-
-/// `TokenStream::default()` returns an empty stream,
-/// i.e. this is equivalent with `TokenStream::new()`.
-impl Default for TokenStream {
-    fn default() -> Self {
-        TokenStream::new()
-    }
-}
-
-/// Attempts to break the string into tokens and parse those tokens into a token
-/// stream.
-///
-/// May fail for a number of reasons, for example, if the string contains
-/// unbalanced delimiters or characters not existing in the language.
-///
-/// NOTE: Some errors may cause panics instead of returning `LexError`. We
-/// reserve the right to change these errors into `LexError`s later.
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        let e = src.parse().map_err(|e| LexError {
-            inner: e,
-            _marker: Marker,
-        })?;
-        Ok(TokenStream::_new(e))
-    }
-}
-
-#[cfg(use_proc_macro)]
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        TokenStream::_new(inner.into())
-    }
-}
-
-#[cfg(use_proc_macro)]
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        inner.inner.into()
-    }
-}
-
-impl From<TokenTree> for TokenStream {
-    fn from(token: TokenTree) -> Self {
-        TokenStream::_new(imp::TokenStream::from(token))
-    }
-}
-
-impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
-        self.inner.extend(streams)
-    }
-}
-
-impl Extend<TokenStream> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
-        self.inner
-            .extend(streams.into_iter().map(|stream| stream.inner))
-    }
-}
-
-/// Collects a number of token trees into a single stream.
-impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
-        TokenStream::_new(streams.into_iter().collect())
-    }
-}
-impl FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
-        TokenStream::_new(streams.into_iter().map(|i| i.inner).collect())
-    }
-}
-
-/// Prints the token stream as a string that is supposed to be losslessly
-/// convertible back into the same token stream (modulo spans), except for
-/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative
-/// numeric literals.
-impl Display for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.inner, f)
-    }
-}
-
-/// Prints token in a form convenient for debugging.
-impl Debug for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-impl LexError {
-    pub fn span(&self) -> Span {
-        Span::_new(self.inner.span())
-    }
-}
-
-impl Debug for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-impl Display for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.inner, f)
-    }
-}
-
-impl Error for LexError {}
-
-/// The source file of a given `Span`.
-///
-/// This type is semver exempt and not exposed by default.
-#[cfg(procmacro2_semver_exempt)]
-#[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
-#[derive(Clone, PartialEq, Eq)]
-pub struct SourceFile {
-    inner: imp::SourceFile,
-    _marker: Marker,
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl SourceFile {
-    fn _new(inner: imp::SourceFile) -> Self {
-        SourceFile {
-            inner,
-            _marker: Marker,
-        }
-    }
-
-    /// Get the path to this source file.
-    ///
-    /// ### Note
-    ///
-    /// If the code span associated with this `SourceFile` was generated by an
-    /// external macro, this may not be an actual path on the filesystem. Use
-    /// [`is_real`] to check.
-    ///
-    /// Also note that even if `is_real` returns `true`, if
-    /// `--remap-path-prefix` was passed on the command line, the path as given
-    /// may not actually be valid.
-    ///
-    /// [`is_real`]: #method.is_real
-    pub fn path(&self) -> PathBuf {
-        self.inner.path()
-    }
-
-    /// Returns `true` if this source file is a real source file, and not
-    /// generated by an external macro's expansion.
-    pub fn is_real(&self) -> bool {
-        self.inner.is_real()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-/// A line-column pair representing the start or end of a `Span`.
-///
-/// This type is semver exempt and not exposed by default.
-#[cfg(span_locations)]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct LineColumn {
-    /// The 1-indexed line in the source file on which the span starts or ends
-    /// (inclusive).
-    pub line: usize,
-    /// The 0-indexed column (in UTF-8 characters) in the source file on which
-    /// the span starts or ends (inclusive).
-    pub column: usize,
-}
-
-#[cfg(span_locations)]
-impl Ord for LineColumn {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.line
-            .cmp(&other.line)
-            .then(self.column.cmp(&other.column))
-    }
-}
-
-#[cfg(span_locations)]
-impl PartialOrd for LineColumn {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-/// A region of source code, along with macro expansion information.
-#[derive(Copy, Clone)]
-pub struct Span {
-    inner: imp::Span,
-    _marker: Marker,
-}
-
-impl Span {
-    fn _new(inner: imp::Span) -> Span {
-        Span {
-            inner,
-            _marker: Marker,
-        }
-    }
-
-    fn _new_stable(inner: fallback::Span) -> Span {
-        Span {
-            inner: inner.into(),
-            _marker: Marker,
-        }
-    }
-
-    /// The span of the invocation of the current procedural macro.
-    ///
-    /// Identifiers created with this span will be resolved as if they were
-    /// written directly at the macro call location (call-site hygiene) and
-    /// other code at the macro call site will be able to refer to them as well.
-    pub fn call_site() -> Span {
-        Span::_new(imp::Span::call_site())
-    }
-
-    /// The span located at the invocation of the procedural macro, but with
-    /// local variables, labels, and `$crate` resolved at the definition site
-    /// of the macro. This is the same hygiene behavior as `macro_rules`.
-    ///
-    /// This function requires Rust 1.45 or later.
-    #[cfg(hygiene)]
-    pub fn mixed_site() -> Span {
-        Span::_new(imp::Span::mixed_site())
-    }
-
-    /// A span that resolves at the macro definition site.
-    ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
-    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
-    pub fn def_site() -> Span {
-        Span::_new(imp::Span::def_site())
-    }
-
-    /// Creates a new span with the same line/column information as `self` but
-    /// that resolves symbols as though it were at `other`.
-    pub fn resolved_at(&self, other: Span) -> Span {
-        Span::_new(self.inner.resolved_at(other.inner))
-    }
-
-    /// Creates a new span with the same name resolution behavior as `self` but
-    /// with the line/column information of `other`.
-    pub fn located_at(&self, other: Span) -> Span {
-        Span::_new(self.inner.located_at(other.inner))
-    }
-
-    /// Convert `proc_macro2::Span` to `proc_macro::Span`.
-    ///
-    /// This method is available when building with a nightly compiler, or when
-    /// building with rustc 1.29+ *without* semver exempt features.
-    ///
-    /// # Panics
-    ///
-    /// Panics if called from outside of a procedural macro. Unlike
-    /// `proc_macro2::Span`, the `proc_macro::Span` type can only exist within
-    /// the context of a procedural macro invocation.
-    #[cfg(wrap_proc_macro)]
-    pub fn unwrap(self) -> proc_macro::Span {
-        self.inner.unwrap()
-    }
-
-    // Soft deprecated. Please use Span::unwrap.
-    #[cfg(wrap_proc_macro)]
-    #[doc(hidden)]
-    pub fn unstable(self) -> proc_macro::Span {
-        self.unwrap()
-    }
-
-    /// The original source file into which this span points.
-    ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
-    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
-    pub fn source_file(&self) -> SourceFile {
-        SourceFile::_new(self.inner.source_file())
-    }
-
-    /// Get the starting line/column in the source file for this span.
-    ///
-    /// This method requires the `"span-locations"` feature to be enabled.
-    ///
-    /// When executing in a procedural macro context, the returned line/column
-    /// are only meaningful if compiled with a nightly toolchain. The stable
-    /// toolchain does not have this information available. When executing
-    /// outside of a procedural macro, such as main.rs or build.rs, the
-    /// line/column are always meaningful regardless of toolchain.
-    #[cfg(span_locations)]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
-    pub fn start(&self) -> LineColumn {
-        let imp::LineColumn { line, column } = self.inner.start();
-        LineColumn { line, column }
-    }
-
-    /// Get the ending line/column in the source file for this span.
-    ///
-    /// This method requires the `"span-locations"` feature to be enabled.
-    ///
-    /// When executing in a procedural macro context, the returned line/column
-    /// are only meaningful if compiled with a nightly toolchain. The stable
-    /// toolchain does not have this information available. When executing
-    /// outside of a procedural macro, such as main.rs or build.rs, the
-    /// line/column are always meaningful regardless of toolchain.
-    #[cfg(span_locations)]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
-    pub fn end(&self) -> LineColumn {
-        let imp::LineColumn { line, column } = self.inner.end();
-        LineColumn { line, column }
-    }
-
-    /// Create a new span encompassing `self` and `other`.
-    ///
-    /// Returns `None` if `self` and `other` are from different files.
-    ///
-    /// Warning: the underlying [`proc_macro::Span::join`] method is
-    /// nightly-only. When called from within a procedural macro not using a
-    /// nightly compiler, this method will always return `None`.
-    ///
-    /// [`proc_macro::Span::join`]: https://doc.rust-lang.org/proc_macro/struct.Span.html#method.join
-    pub fn join(&self, other: Span) -> Option<Span> {
-        self.inner.join(other.inner).map(Span::_new)
-    }
-
-    /// Compares two spans to see if they're equal.
-    ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
-    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
-    pub fn eq(&self, other: &Span) -> bool {
-        self.inner.eq(&other.inner)
-    }
-}
-
-/// Prints a span in a form convenient for debugging.
-impl Debug for Span {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-/// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`).
-#[derive(Clone)]
-pub enum TokenTree {
-    /// A token stream surrounded by bracket delimiters.
-    Group(Group),
-    /// An identifier.
-    Ident(Ident),
-    /// A single punctuation character (`+`, `,`, `$`, etc.).
-    Punct(Punct),
-    /// A literal character (`'a'`), string (`"hello"`), number (`2.3`), etc.
-    Literal(Literal),
-}
-
-impl TokenTree {
-    /// Returns the span of this tree, delegating to the `span` method of
-    /// the contained token or a delimited stream.
-    pub fn span(&self) -> Span {
-        match self {
-            TokenTree::Group(t) => t.span(),
-            TokenTree::Ident(t) => t.span(),
-            TokenTree::Punct(t) => t.span(),
-            TokenTree::Literal(t) => t.span(),
-        }
-    }
-
-    /// Configures the span for *only this token*.
-    ///
-    /// Note that if this token is a `Group` then this method will not configure
-    /// the span of each of the internal tokens, this will simply delegate to
-    /// the `set_span` method of each variant.
-    pub fn set_span(&mut self, span: Span) {
-        match self {
-            TokenTree::Group(t) => t.set_span(span),
-            TokenTree::Ident(t) => t.set_span(span),
-            TokenTree::Punct(t) => t.set_span(span),
-            TokenTree::Literal(t) => t.set_span(span),
-        }
-    }
-}
-
-impl From<Group> for TokenTree {
-    fn from(g: Group) -> TokenTree {
-        TokenTree::Group(g)
-    }
-}
-
-impl From<Ident> for TokenTree {
-    fn from(g: Ident) -> TokenTree {
-        TokenTree::Ident(g)
-    }
-}
-
-impl From<Punct> for TokenTree {
-    fn from(g: Punct) -> TokenTree {
-        TokenTree::Punct(g)
-    }
-}
-
-impl From<Literal> for TokenTree {
-    fn from(g: Literal) -> TokenTree {
-        TokenTree::Literal(g)
-    }
-}
-
-/// Prints the token tree as a string that is supposed to be losslessly
-/// convertible back into the same token tree (modulo spans), except for
-/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative
-/// numeric literals.
-impl Display for TokenTree {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TokenTree::Group(t) => Display::fmt(t, f),
-            TokenTree::Ident(t) => Display::fmt(t, f),
-            TokenTree::Punct(t) => Display::fmt(t, f),
-            TokenTree::Literal(t) => Display::fmt(t, f),
-        }
-    }
-}
-
-/// Prints token tree in a form convenient for debugging.
-impl Debug for TokenTree {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // Each of these has the name in the struct type in the derived debug,
-        // so don't bother with an extra layer of indirection
-        match self {
-            TokenTree::Group(t) => Debug::fmt(t, f),
-            TokenTree::Ident(t) => {
-                let mut debug = f.debug_struct("Ident");
-                debug.field("sym", &format_args!("{}", t));
-                imp::debug_span_field_if_nontrivial(&mut debug, t.span().inner);
-                debug.finish()
-            }
-            TokenTree::Punct(t) => Debug::fmt(t, f),
-            TokenTree::Literal(t) => Debug::fmt(t, f),
-        }
-    }
-}
-
-/// A delimited token stream.
-///
-/// A `Group` internally contains a `TokenStream` which is surrounded by
-/// `Delimiter`s.
-#[derive(Clone)]
-pub struct Group {
-    inner: imp::Group,
-}
-
-/// Describes how a sequence of token trees is delimited.
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Delimiter {
-    /// `( ... )`
-    Parenthesis,
-    /// `{ ... }`
-    Brace,
-    /// `[ ... ]`
-    Bracket,
-    /// `Ø ... Ø`
-    ///
-    /// An implicit delimiter, that may, for example, appear around tokens
-    /// coming from a "macro variable" `$var`. It is important to preserve
-    /// operator priorities in cases like `$var * 3` where `$var` is `1 + 2`.
-    /// Implicit delimiters may not survive roundtrip of a token stream through
-    /// a string.
-    None,
-}
-
-impl Group {
-    fn _new(inner: imp::Group) -> Self {
-        Group { inner }
-    }
-
-    fn _new_stable(inner: fallback::Group) -> Self {
-        Group {
-            inner: inner.into(),
-        }
-    }
-
-    /// Creates a new `Group` with the given delimiter and token stream.
-    ///
-    /// This constructor will set the span for this group to
-    /// `Span::call_site()`. To change the span you can use the `set_span`
-    /// method below.
-    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
-        Group {
-            inner: imp::Group::new(delimiter, stream.inner),
-        }
-    }
-
-    /// Returns the delimiter of this `Group`
-    pub fn delimiter(&self) -> Delimiter {
-        self.inner.delimiter()
-    }
-
-    /// Returns the `TokenStream` of tokens that are delimited in this `Group`.
-    ///
-    /// Note that the returned token stream does not include the delimiter
-    /// returned above.
-    pub fn stream(&self) -> TokenStream {
-        TokenStream::_new(self.inner.stream())
-    }
-
-    /// Returns the span for the delimiters of this token stream, spanning the
-    /// entire `Group`.
-    ///
-    /// ```text
-    /// pub fn span(&self) -> Span {
-    ///            ^^^^^^^
-    /// ```
-    pub fn span(&self) -> Span {
-        Span::_new(self.inner.span())
-    }
-
-    /// Returns the span pointing to the opening delimiter of this group.
-    ///
-    /// ```text
-    /// pub fn span_open(&self) -> Span {
-    ///                 ^
-    /// ```
-    pub fn span_open(&self) -> Span {
-        Span::_new(self.inner.span_open())
-    }
-
-    /// Returns the span pointing to the closing delimiter of this group.
-    ///
-    /// ```text
-    /// pub fn span_close(&self) -> Span {
-    ///                        ^
-    /// ```
-    pub fn span_close(&self) -> Span {
-        Span::_new(self.inner.span_close())
-    }
-
-    /// Configures the span for this `Group`'s delimiters, but not its internal
-    /// tokens.
-    ///
-    /// This method will **not** set the span of all the internal tokens spanned
-    /// by this group, but rather it will only set the span of the delimiter
-    /// tokens at the level of the `Group`.
-    pub fn set_span(&mut self, span: Span) {
-        self.inner.set_span(span.inner)
-    }
-}
-
-/// Prints the group as a string that should be losslessly convertible back
-/// into the same group (modulo spans), except for possibly `TokenTree::Group`s
-/// with `Delimiter::None` delimiters.
-impl Display for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.inner, formatter)
-    }
-}
-
-impl Debug for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, formatter)
-    }
-}
-
-/// A `Punct` is a single punctuation character like `+`, `-` or `#`.
-///
-/// Multicharacter operators like `+=` are represented as two instances of
-/// `Punct` with different forms of `Spacing` returned.
-#[derive(Clone)]
-pub struct Punct {
-    ch: char,
-    spacing: Spacing,
-    span: Span,
-}
-
-/// Whether a `Punct` is followed immediately by another `Punct` or followed by
-/// another token or whitespace.
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Spacing {
-    /// E.g. `+` is `Alone` in `+ =`, `+ident` or `+()`.
-    Alone,
-    /// E.g. `+` is `Joint` in `+=` or `'` is `Joint` in `'#`.
-    ///
-    /// Additionally, single quote `'` can join with identifiers to form
-    /// lifetimes `'ident`.
-    Joint,
-}
-
-impl Punct {
-    /// Creates a new `Punct` from the given character and spacing.
-    ///
-    /// The `ch` argument must be a valid punctuation character permitted by the
-    /// language, otherwise the function will panic.
-    ///
-    /// The returned `Punct` will have the default span of `Span::call_site()`
-    /// which can be further configured with the `set_span` method below.
-    pub fn new(ch: char, spacing: Spacing) -> Punct {
-        Punct {
-            ch,
-            spacing,
-            span: Span::call_site(),
-        }
-    }
-
-    /// Returns the value of this punctuation character as `char`.
-    pub fn as_char(&self) -> char {
-        self.ch
-    }
-
-    /// Returns the spacing of this punctuation character, indicating whether
-    /// it's immediately followed by another `Punct` in the token stream, so
-    /// they can potentially be combined into a multicharacter operator
-    /// (`Joint`), or it's followed by some other token or whitespace (`Alone`)
-    /// so the operator has certainly ended.
-    pub fn spacing(&self) -> Spacing {
-        self.spacing
-    }
-
-    /// Returns the span for this punctuation character.
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    /// Configure the span for this punctuation character.
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-    }
-}
-
-/// Prints the punctuation character as a string that should be losslessly
-/// convertible back into the same character.
-impl Display for Punct {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.ch, f)
-    }
-}
-
-impl Debug for Punct {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = fmt.debug_struct("Punct");
-        debug.field("char", &self.ch);
-        debug.field("spacing", &self.spacing);
-        imp::debug_span_field_if_nontrivial(&mut debug, self.span.inner);
-        debug.finish()
-    }
-}
-
-/// A word of Rust code, which may be a keyword or legal variable name.
-///
-/// An identifier consists of at least one Unicode code point, the first of
-/// which has the XID_Start property and the rest of which have the XID_Continue
-/// property.
-///
-/// - The empty string is not an identifier. Use `Option<Ident>`.
-/// - A lifetime is not an identifier. Use `syn::Lifetime` instead.
-///
-/// An identifier constructed with `Ident::new` is permitted to be a Rust
-/// keyword, though parsing one through its [`Parse`] implementation rejects
-/// Rust keywords. Use `input.call(Ident::parse_any)` when parsing to match the
-/// behaviour of `Ident::new`.
-///
-/// [`Parse`]: https://docs.rs/syn/1.0/syn/parse/trait.Parse.html
-///
-/// # Examples
-///
-/// A new ident can be created from a string using the `Ident::new` function.
-/// A span must be provided explicitly which governs the name resolution
-/// behavior of the resulting identifier.
-///
-/// ```
-/// use proc_macro2::{Ident, Span};
-///
-/// fn main() {
-///     let call_ident = Ident::new("calligraphy", Span::call_site());
-///
-///     println!("{}", call_ident);
-/// }
-/// ```
-///
-/// An ident can be interpolated into a token stream using the `quote!` macro.
-///
-/// ```
-/// use proc_macro2::{Ident, Span};
-/// use quote::quote;
-///
-/// fn main() {
-///     let ident = Ident::new("demo", Span::call_site());
-///
-///     // Create a variable binding whose name is this ident.
-///     let expanded = quote! { let #ident = 10; };
-///
-///     // Create a variable binding with a slightly different name.
-///     let temp_ident = Ident::new(&format!("new_{}", ident), Span::call_site());
-///     let expanded = quote! { let #temp_ident = 10; };
-/// }
-/// ```
-///
-/// A string representation of the ident is available through the `to_string()`
-/// method.
-///
-/// ```
-/// # use proc_macro2::{Ident, Span};
-/// #
-/// # let ident = Ident::new("another_identifier", Span::call_site());
-/// #
-/// // Examine the ident as a string.
-/// let ident_string = ident.to_string();
-/// if ident_string.len() > 60 {
-///     println!("Very long identifier: {}", ident_string)
-/// }
-/// ```
-#[derive(Clone)]
-pub struct Ident {
-    inner: imp::Ident,
-    _marker: Marker,
-}
-
-impl Ident {
-    fn _new(inner: imp::Ident) -> Ident {
-        Ident {
-            inner,
-            _marker: Marker,
-        }
-    }
-
-    /// Creates a new `Ident` with the given `string` as well as the specified
-    /// `span`.
-    ///
-    /// The `string` argument must be a valid identifier permitted by the
-    /// language, otherwise the function will panic.
-    ///
-    /// Note that `span`, currently in rustc, configures the hygiene information
-    /// for this identifier.
-    ///
-    /// As of this time `Span::call_site()` explicitly opts-in to "call-site"
-    /// hygiene meaning that identifiers created with this span will be resolved
-    /// as if they were written directly at the location of the macro call, and
-    /// other code at the macro call site will be able to refer to them as well.
-    ///
-    /// Later spans like `Span::def_site()` will allow to opt-in to
-    /// "definition-site" hygiene meaning that identifiers created with this
-    /// span will be resolved at the location of the macro definition and other
-    /// code at the macro call site will not be able to refer to them.
-    ///
-    /// Due to the current importance of hygiene this constructor, unlike other
-    /// tokens, requires a `Span` to be specified at construction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the input string is neither a keyword nor a legal variable
-    /// name. If you are not sure whether the string contains an identifier and
-    /// need to handle an error case, use
-    /// <a href="https://docs.rs/syn/1.0/syn/fn.parse_str.html"><code
-    ///   style="padding-right:0;">syn::parse_str</code></a><code
-    ///   style="padding-left:0;">::&lt;Ident&gt;</code>
-    /// rather than `Ident::new`.
-    pub fn new(string: &str, span: Span) -> Ident {
-        Ident::_new(imp::Ident::new(string, span.inner))
-    }
-
-    /// Same as `Ident::new`, but creates a raw identifier (`r#ident`).
-    ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
-    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
-    pub fn new_raw(string: &str, span: Span) -> Ident {
-        Ident::_new_raw(string, span)
-    }
-
-    fn _new_raw(string: &str, span: Span) -> Ident {
-        Ident::_new(imp::Ident::new_raw(string, span.inner))
-    }
-
-    /// Returns the span of this `Ident`.
-    pub fn span(&self) -> Span {
-        Span::_new(self.inner.span())
-    }
-
-    /// Configures the span of this `Ident`, possibly changing its hygiene
-    /// context.
-    pub fn set_span(&mut self, span: Span) {
-        self.inner.set_span(span.inner);
-    }
-}
-
-impl PartialEq for Ident {
-    fn eq(&self, other: &Ident) -> bool {
-        self.inner == other.inner
-    }
-}
-
-impl<T> PartialEq<T> for Ident
-where
-    T: ?Sized + AsRef<str>,
-{
-    fn eq(&self, other: &T) -> bool {
-        self.inner == other
-    }
-}
-
-impl Eq for Ident {}
-
-impl PartialOrd for Ident {
-    fn partial_cmp(&self, other: &Ident) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Ident {
-    fn cmp(&self, other: &Ident) -> Ordering {
-        self.to_string().cmp(&other.to_string())
-    }
-}
-
-impl Hash for Ident {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        self.to_string().hash(hasher)
-    }
-}
-
-/// Prints the identifier as a string that should be losslessly convertible back
-/// into the same identifier.
-impl Display for Ident {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.inner, f)
-    }
-}
-
-impl Debug for Ident {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-/// A literal string (`"hello"`), byte string (`b"hello"`), character (`'a'`),
-/// byte character (`b'a'`), an integer or floating point number with or without
-/// a suffix (`1`, `1u8`, `2.3`, `2.3f32`).
-///
-/// Boolean literals like `true` and `false` do not belong here, they are
-/// `Ident`s.
-#[derive(Clone)]
-pub struct Literal {
-    inner: imp::Literal,
-    _marker: Marker,
-}
-
-macro_rules! suffixed_int_literals {
-    ($($name:ident => $kind:ident,)*) => ($(
-        /// Creates a new suffixed integer literal with the specified value.
-        ///
-        /// This function will create an integer like `1u32` where the integer
-        /// value specified is the first part of the token and the integral is
-        /// also suffixed at the end. Literals created from negative numbers may
-        /// not survive roundtrips through `TokenStream` or strings and may be
-        /// broken into two tokens (`-` and positive literal).
-        ///
-        /// Literals created through this method have the `Span::call_site()`
-        /// span by default, which can be configured with the `set_span` method
-        /// below.
-        pub fn $name(n: $kind) -> Literal {
-            Literal::_new(imp::Literal::$name(n))
-        }
-    )*)
-}
-
-macro_rules! unsuffixed_int_literals {
-    ($($name:ident => $kind:ident,)*) => ($(
-        /// Creates a new unsuffixed integer literal with the specified value.
-        ///
-        /// This function will create an integer like `1` where the integer
-        /// value specified is the first part of the token. No suffix is
-        /// specified on this token, meaning that invocations like
-        /// `Literal::i8_unsuffixed(1)` are equivalent to
-        /// `Literal::u32_unsuffixed(1)`. Literals created from negative numbers
-        /// may not survive roundtrips through `TokenStream` or strings and may
-        /// be broken into two tokens (`-` and positive literal).
-        ///
-        /// Literals created through this method have the `Span::call_site()`
-        /// span by default, which can be configured with the `set_span` method
-        /// below.
-        pub fn $name(n: $kind) -> Literal {
-            Literal::_new(imp::Literal::$name(n))
-        }
-    )*)
-}
-
-impl Literal {
-    fn _new(inner: imp::Literal) -> Literal {
-        Literal {
-            inner,
-            _marker: Marker,
-        }
-    }
-
-    fn _new_stable(inner: fallback::Literal) -> Literal {
-        Literal {
-            inner: inner.into(),
-            _marker: Marker,
-        }
-    }
-
-    suffixed_int_literals! {
-        u8_suffixed => u8,
-        u16_suffixed => u16,
-        u32_suffixed => u32,
-        u64_suffixed => u64,
-        u128_suffixed => u128,
-        usize_suffixed => usize,
-        i8_suffixed => i8,
-        i16_suffixed => i16,
-        i32_suffixed => i32,
-        i64_suffixed => i64,
-        i128_suffixed => i128,
-        isize_suffixed => isize,
-    }
-
-    unsuffixed_int_literals! {
-        u8_unsuffixed => u8,
-        u16_unsuffixed => u16,
-        u32_unsuffixed => u32,
-        u64_unsuffixed => u64,
-        u128_unsuffixed => u128,
-        usize_unsuffixed => usize,
-        i8_unsuffixed => i8,
-        i16_unsuffixed => i16,
-        i32_unsuffixed => i32,
-        i64_unsuffixed => i64,
-        i128_unsuffixed => i128,
-        isize_unsuffixed => isize,
-    }
-
-    /// Creates a new unsuffixed floating-point literal.
-    ///
-    /// This constructor is similar to those like `Literal::i8_unsuffixed` where
-    /// the float's value is emitted directly into the token but no suffix is
-    /// used, so it may be inferred to be a `f64` later in the compiler.
-    /// Literals created from negative numbers may not survive rountrips through
-    /// `TokenStream` or strings and may be broken into two tokens (`-` and
-    /// positive literal).
-    ///
-    /// # Panics
-    ///
-    /// This function requires that the specified float is finite, for example
-    /// if it is infinity or NaN this function will panic.
-    pub fn f64_unsuffixed(f: f64) -> Literal {
-        assert!(f.is_finite());
-        Literal::_new(imp::Literal::f64_unsuffixed(f))
-    }
-
-    /// Creates a new suffixed floating-point literal.
-    ///
-    /// This constructor will create a literal like `1.0f64` where the value
-    /// specified is the preceding part of the token and `f64` is the suffix of
-    /// the token. This token will always be inferred to be an `f64` in the
-    /// compiler. Literals created from negative numbers may not survive
-    /// rountrips through `TokenStream` or strings and may be broken into two
-    /// tokens (`-` and positive literal).
-    ///
-    /// # Panics
-    ///
-    /// This function requires that the specified float is finite, for example
-    /// if it is infinity or NaN this function will panic.
-    pub fn f64_suffixed(f: f64) -> Literal {
-        assert!(f.is_finite());
-        Literal::_new(imp::Literal::f64_suffixed(f))
-    }
-
-    /// Creates a new unsuffixed floating-point literal.
-    ///
-    /// This constructor is similar to those like `Literal::i8_unsuffixed` where
-    /// the float's value is emitted directly into the token but no suffix is
-    /// used, so it may be inferred to be a `f64` later in the compiler.
-    /// Literals created from negative numbers may not survive rountrips through
-    /// `TokenStream` or strings and may be broken into two tokens (`-` and
-    /// positive literal).
-    ///
-    /// # Panics
-    ///
-    /// This function requires that the specified float is finite, for example
-    /// if it is infinity or NaN this function will panic.
-    pub fn f32_unsuffixed(f: f32) -> Literal {
-        assert!(f.is_finite());
-        Literal::_new(imp::Literal::f32_unsuffixed(f))
-    }
-
-    /// Creates a new suffixed floating-point literal.
-    ///
-    /// This constructor will create a literal like `1.0f32` where the value
-    /// specified is the preceding part of the token and `f32` is the suffix of
-    /// the token. This token will always be inferred to be an `f32` in the
-    /// compiler. Literals created from negative numbers may not survive
-    /// rountrips through `TokenStream` or strings and may be broken into two
-    /// tokens (`-` and positive literal).
-    ///
-    /// # Panics
-    ///
-    /// This function requires that the specified float is finite, for example
-    /// if it is infinity or NaN this function will panic.
-    pub fn f32_suffixed(f: f32) -> Literal {
-        assert!(f.is_finite());
-        Literal::_new(imp::Literal::f32_suffixed(f))
-    }
-
-    /// String literal.
-    pub fn string(string: &str) -> Literal {
-        Literal::_new(imp::Literal::string(string))
-    }
-
-    /// Character literal.
-    pub fn character(ch: char) -> Literal {
-        Literal::_new(imp::Literal::character(ch))
-    }
-
-    /// Byte string literal.
-    pub fn byte_string(s: &[u8]) -> Literal {
-        Literal::_new(imp::Literal::byte_string(s))
-    }
-
-    /// Returns the span encompassing this literal.
-    pub fn span(&self) -> Span {
-        Span::_new(self.inner.span())
-    }
-
-    /// Configures the span associated for this literal.
-    pub fn set_span(&mut self, span: Span) {
-        self.inner.set_span(span.inner);
-    }
-
-    /// Returns a `Span` that is a subset of `self.span()` containing only
-    /// the source bytes in range `range`. Returns `None` if the would-be
-    /// trimmed span is outside the bounds of `self`.
-    ///
-    /// Warning: the underlying [`proc_macro::Literal::subspan`] method is
-    /// nightly-only. When called from within a procedural macro not using a
-    /// nightly compiler, this method will always return `None`.
-    ///
-    /// [`proc_macro::Literal::subspan`]: https://doc.rust-lang.org/proc_macro/struct.Literal.html#method.subspan
-    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        self.inner.subspan(range).map(Span::_new)
-    }
-}
-
-impl FromStr for Literal {
-    type Err = LexError;
-
-    fn from_str(repr: &str) -> Result<Self, LexError> {
-        repr.parse().map(Literal::_new).map_err(|inner| LexError {
-            inner,
-            _marker: Marker,
-        })
-    }
-}
-
-impl Debug for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.inner, f)
-    }
-}
-
-impl Display for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.inner, f)
-    }
-}
-
-/// Public implementation details for the `TokenStream` type, such as iterators.
-pub mod token_stream {
-    use crate::marker::Marker;
-    use crate::{imp, TokenTree};
-    use std::fmt::{self, Debug};
-
-    pub use crate::TokenStream;
-
-    /// An iterator over `TokenStream`'s `TokenTree`s.
-    ///
-    /// The iteration is "shallow", e.g. the iterator doesn't recurse into
-    /// delimited groups, and returns whole groups as token trees.
-    #[derive(Clone)]
-    pub struct IntoIter {
-        inner: imp::TokenTreeIter,
-        _marker: Marker,
-    }
-
-    impl Iterator for IntoIter {
-        type Item = TokenTree;
-
-        fn next(&mut self) -> Option<TokenTree> {
-            self.inner.next()
-        }
-    }
-
-    impl Debug for IntoIter {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            Debug::fmt(&self.inner, f)
-        }
-    }
-
-    impl IntoIterator for TokenStream {
-        type Item = TokenTree;
-        type IntoIter = IntoIter;
-
-        fn into_iter(self) -> IntoIter {
-            IntoIter {
-                inner: self.inner.into_iter(),
-                _marker: Marker,
-            }
-        }
-    }
-}
diff --git a/vendor/proc-macro2/src/marker.rs b/vendor/proc-macro2/src/marker.rs
deleted file mode 100644
index 58729baf..00000000
--- a/vendor/proc-macro2/src/marker.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use std::marker::PhantomData;
-use std::panic::{RefUnwindSafe, UnwindSafe};
-use std::rc::Rc;
-
-// Zero sized marker with the correct set of autotrait impls we want all proc
-// macro types to have.
-pub(crate) type Marker = PhantomData<ProcMacroAutoTraits>;
-
-pub(crate) use self::value::*;
-
-mod value {
-    pub(crate) use std::marker::PhantomData as Marker;
-}
-
-pub(crate) struct ProcMacroAutoTraits(Rc<()>);
-
-impl UnwindSafe for ProcMacroAutoTraits {}
-impl RefUnwindSafe for ProcMacroAutoTraits {}
diff --git a/vendor/proc-macro2/src/parse.rs b/vendor/proc-macro2/src/parse.rs
deleted file mode 100644
index eddb4901..00000000
--- a/vendor/proc-macro2/src/parse.rs
+++ /dev/null
@@ -1,866 +0,0 @@
-use crate::fallback::{
-    is_ident_continue, is_ident_start, Group, LexError, Literal, Span, TokenStream,
-};
-use crate::{Delimiter, Punct, Spacing, TokenTree};
-use std::char;
-use std::str::{Bytes, CharIndices, Chars};
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub(crate) struct Cursor<'a> {
-    pub rest: &'a str,
-    #[cfg(span_locations)]
-    pub off: u32,
-}
-
-impl<'a> Cursor<'a> {
-    fn advance(&self, bytes: usize) -> Cursor<'a> {
-        let (_front, rest) = self.rest.split_at(bytes);
-        Cursor {
-            rest,
-            #[cfg(span_locations)]
-            off: self.off + _front.chars().count() as u32,
-        }
-    }
-
-    fn starts_with(&self, s: &str) -> bool {
-        self.rest.starts_with(s)
-    }
-
-    fn is_empty(&self) -> bool {
-        self.rest.is_empty()
-    }
-
-    fn len(&self) -> usize {
-        self.rest.len()
-    }
-
-    fn as_bytes(&self) -> &'a [u8] {
-        self.rest.as_bytes()
-    }
-
-    fn bytes(&self) -> Bytes<'a> {
-        self.rest.bytes()
-    }
-
-    fn chars(&self) -> Chars<'a> {
-        self.rest.chars()
-    }
-
-    fn char_indices(&self) -> CharIndices<'a> {
-        self.rest.char_indices()
-    }
-
-    fn parse(&self, tag: &str) -> Result<Cursor<'a>, Reject> {
-        if self.starts_with(tag) {
-            Ok(self.advance(tag.len()))
-        } else {
-            Err(Reject)
-        }
-    }
-}
-
-pub(crate) struct Reject;
-type PResult<'a, O> = Result<(Cursor<'a>, O), Reject>;
-
-fn skip_whitespace(input: Cursor) -> Cursor {
-    let mut s = input;
-
-    while !s.is_empty() {
-        let byte = s.as_bytes()[0];
-        if byte == b'/' {
-            if s.starts_with("//")
-                && (!s.starts_with("///") || s.starts_with("////"))
-                && !s.starts_with("//!")
-            {
-                let (cursor, _) = take_until_newline_or_eof(s);
-                s = cursor;
-                continue;
-            } else if s.starts_with("/**/") {
-                s = s.advance(4);
-                continue;
-            } else if s.starts_with("/*")
-                && (!s.starts_with("/**") || s.starts_with("/***"))
-                && !s.starts_with("/*!")
-            {
-                match block_comment(s) {
-                    Ok((rest, _)) => {
-                        s = rest;
-                        continue;
-                    }
-                    Err(Reject) => return s,
-                }
-            }
-        }
-        match byte {
-            b' ' | 0x09..=0x0d => {
-                s = s.advance(1);
-                continue;
-            }
-            b if b <= 0x7f => {}
-            _ => {
-                let ch = s.chars().next().unwrap();
-                if is_whitespace(ch) {
-                    s = s.advance(ch.len_utf8());
-                    continue;
-                }
-            }
-        }
-        return s;
-    }
-    s
-}
-
-fn block_comment(input: Cursor) -> PResult<&str> {
-    if !input.starts_with("/*") {
-        return Err(Reject);
-    }
-
-    let mut depth = 0;
-    let bytes = input.as_bytes();
-    let mut i = 0;
-    let upper = bytes.len() - 1;
-
-    while i < upper {
-        if bytes[i] == b'/' && bytes[i + 1] == b'*' {
-            depth += 1;
-            i += 1; // eat '*'
-        } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
-            depth -= 1;
-            if depth == 0 {
-                return Ok((input.advance(i + 2), &input.rest[..i + 2]));
-            }
-            i += 1; // eat '/'
-        }
-        i += 1;
-    }
-
-    Err(Reject)
-}
-
-fn is_whitespace(ch: char) -> bool {
-    // Rust treats left-to-right mark and right-to-left mark as whitespace
-    ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
-}
-
-fn word_break(input: Cursor) -> Result<Cursor, Reject> {
-    match input.chars().next() {
-        Some(ch) if is_ident_continue(ch) => Err(Reject),
-        Some(_) | None => Ok(input),
-    }
-}
-
-pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
-    let mut trees = Vec::new();
-    let mut stack = Vec::new();
-
-    loop {
-        input = skip_whitespace(input);
-
-        if let Ok((rest, tt)) = doc_comment(input) {
-            trees.extend(tt);
-            input = rest;
-            continue;
-        }
-
-        #[cfg(span_locations)]
-        let lo = input.off;
-
-        let first = match input.bytes().next() {
-            Some(first) => first,
-            None => match stack.last() {
-                None => return Ok(TokenStream { inner: trees }),
-                #[cfg(span_locations)]
-                Some((lo, _frame)) => {
-                    return Err(LexError {
-                        span: Span { lo: *lo, hi: *lo },
-                    })
-                }
-                #[cfg(not(span_locations))]
-                Some(_frame) => return Err(LexError { span: Span {} }),
-            },
-        };
-
-        if let Some(open_delimiter) = match first {
-            b'(' => Some(Delimiter::Parenthesis),
-            b'[' => Some(Delimiter::Bracket),
-            b'{' => Some(Delimiter::Brace),
-            _ => None,
-        } {
-            input = input.advance(1);
-            let frame = (open_delimiter, trees);
-            #[cfg(span_locations)]
-            let frame = (lo, frame);
-            stack.push(frame);
-            trees = Vec::new();
-        } else if let Some(close_delimiter) = match first {
-            b')' => Some(Delimiter::Parenthesis),
-            b']' => Some(Delimiter::Bracket),
-            b'}' => Some(Delimiter::Brace),
-            _ => None,
-        } {
-            let frame = match stack.pop() {
-                Some(frame) => frame,
-                None => return Err(lex_error(input)),
-            };
-            #[cfg(span_locations)]
-            let (lo, frame) = frame;
-            let (open_delimiter, outer) = frame;
-            if open_delimiter != close_delimiter {
-                return Err(lex_error(input));
-            }
-            input = input.advance(1);
-            let mut g = Group::new(open_delimiter, TokenStream { inner: trees });
-            g.set_span(Span {
-                #[cfg(span_locations)]
-                lo,
-                #[cfg(span_locations)]
-                hi: input.off,
-            });
-            trees = outer;
-            trees.push(TokenTree::Group(crate::Group::_new_stable(g)));
-        } else {
-            let (rest, mut tt) = match leaf_token(input) {
-                Ok((rest, tt)) => (rest, tt),
-                Err(Reject) => return Err(lex_error(input)),
-            };
-            tt.set_span(crate::Span::_new_stable(Span {
-                #[cfg(span_locations)]
-                lo,
-                #[cfg(span_locations)]
-                hi: rest.off,
-            }));
-            trees.push(tt);
-            input = rest;
-        }
-    }
-}
-
-fn lex_error(cursor: Cursor) -> LexError {
-    #[cfg(not(span_locations))]
-    let _ = cursor;
-    LexError {
-        span: Span {
-            #[cfg(span_locations)]
-            lo: cursor.off,
-            #[cfg(span_locations)]
-            hi: cursor.off,
-        },
-    }
-}
-
-fn leaf_token(input: Cursor) -> PResult<TokenTree> {
-    if let Ok((input, l)) = literal(input) {
-        // must be parsed before ident
-        Ok((input, TokenTree::Literal(crate::Literal::_new_stable(l))))
-    } else if let Ok((input, p)) = punct(input) {
-        Ok((input, TokenTree::Punct(p)))
-    } else if let Ok((input, i)) = ident(input) {
-        Ok((input, TokenTree::Ident(i)))
-    } else {
-        Err(Reject)
-    }
-}
-
-fn ident(input: Cursor) -> PResult<crate::Ident> {
-    if ["r\"", "r#\"", "r##", "b\"", "b\'", "br\"", "br#"]
-        .iter()
-        .any(|prefix| input.starts_with(prefix))
-    {
-        Err(Reject)
-    } else {
-        ident_any(input)
-    }
-}
-
-fn ident_any(input: Cursor) -> PResult<crate::Ident> {
-    let raw = input.starts_with("r#");
-    let rest = input.advance((raw as usize) << 1);
-
-    let (rest, sym) = ident_not_raw(rest)?;
-
-    if !raw {
-        let ident = crate::Ident::new(sym, crate::Span::call_site());
-        return Ok((rest, ident));
-    }
-
-    if sym == "_" {
-        return Err(Reject);
-    }
-
-    let ident = crate::Ident::_new_raw(sym, crate::Span::call_site());
-    Ok((rest, ident))
-}
-
-fn ident_not_raw(input: Cursor) -> PResult<&str> {
-    let mut chars = input.char_indices();
-
-    match chars.next() {
-        Some((_, ch)) if is_ident_start(ch) => {}
-        _ => return Err(Reject),
-    }
-
-    let mut end = input.len();
-    for (i, ch) in chars {
-        if !is_ident_continue(ch) {
-            end = i;
-            break;
-        }
-    }
-
-    Ok((input.advance(end), &input.rest[..end]))
-}
-
-pub(crate) fn literal(input: Cursor) -> PResult<Literal> {
-    let rest = literal_nocapture(input)?;
-    let end = input.len() - rest.len();
-    Ok((rest, Literal::_new(input.rest[..end].to_string())))
-}
-
-fn literal_nocapture(input: Cursor) -> Result<Cursor, Reject> {
-    if let Ok(ok) = string(input) {
-        Ok(ok)
-    } else if let Ok(ok) = byte_string(input) {
-        Ok(ok)
-    } else if let Ok(ok) = byte(input) {
-        Ok(ok)
-    } else if let Ok(ok) = character(input) {
-        Ok(ok)
-    } else if let Ok(ok) = float(input) {
-        Ok(ok)
-    } else if let Ok(ok) = int(input) {
-        Ok(ok)
-    } else {
-        Err(Reject)
-    }
-}
-
-fn literal_suffix(input: Cursor) -> Cursor {
-    match ident_not_raw(input) {
-        Ok((input, _)) => input,
-        Err(Reject) => input,
-    }
-}
-
-fn string(input: Cursor) -> Result<Cursor, Reject> {
-    if let Ok(input) = input.parse("\"") {
-        cooked_string(input)
-    } else if let Ok(input) = input.parse("r") {
-        raw_string(input)
-    } else {
-        Err(Reject)
-    }
-}
-
-fn cooked_string(input: Cursor) -> Result<Cursor, Reject> {
-    let mut chars = input.char_indices().peekable();
-
-    while let Some((i, ch)) = chars.next() {
-        match ch {
-            '"' => {
-                let input = input.advance(i + 1);
-                return Ok(literal_suffix(input));
-            }
-            '\r' => match chars.next() {
-                Some((_, '\n')) => {}
-                _ => break,
-            },
-            '\\' => match chars.next() {
-                Some((_, 'x')) => {
-                    if !backslash_x_char(&mut chars) {
-                        break;
-                    }
-                }
-                Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
-                | Some((_, '\'')) | Some((_, '"')) | Some((_, '0')) => {}
-                Some((_, 'u')) => {
-                    if !backslash_u(&mut chars) {
-                        break;
-                    }
-                }
-                Some((_, ch @ '\n')) | Some((_, ch @ '\r')) => {
-                    let mut last = ch;
-                    loop {
-                        if last == '\r' && chars.next().map_or(true, |(_, ch)| ch != '\n') {
-                            return Err(Reject);
-                        }
-                        match chars.peek() {
-                            Some((_, ch)) if ch.is_whitespace() => {
-                                last = *ch;
-                                chars.next();
-                            }
-                            _ => break,
-                        }
-                    }
-                }
-                _ => break,
-            },
-            _ch => {}
-        }
-    }
-    Err(Reject)
-}
-
-fn byte_string(input: Cursor) -> Result<Cursor, Reject> {
-    if let Ok(input) = input.parse("b\"") {
-        cooked_byte_string(input)
-    } else if let Ok(input) = input.parse("br") {
-        raw_string(input)
-    } else {
-        Err(Reject)
-    }
-}
-
-fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, Reject> {
-    let mut bytes = input.bytes().enumerate();
-    while let Some((offset, b)) = bytes.next() {
-        match b {
-            b'"' => {
-                let input = input.advance(offset + 1);
-                return Ok(literal_suffix(input));
-            }
-            b'\r' => match bytes.next() {
-                Some((_, b'\n')) => {}
-                _ => break,
-            },
-            b'\\' => match bytes.next() {
-                Some((_, b'x')) => {
-                    if !backslash_x_byte(&mut bytes) {
-                        break;
-                    }
-                }
-                Some((_, b'n')) | Some((_, b'r')) | Some((_, b't')) | Some((_, b'\\'))
-                | Some((_, b'0')) | Some((_, b'\'')) | Some((_, b'"')) => {}
-                Some((newline, b @ b'\n')) | Some((newline, b @ b'\r')) => {
-                    let mut last = b as char;
-                    let rest = input.advance(newline + 1);
-                    let mut chars = rest.char_indices();
-                    loop {
-                        if last == '\r' && chars.next().map_or(true, |(_, ch)| ch != '\n') {
-                            return Err(Reject);
-                        }
-                        match chars.next() {
-                            Some((_, ch)) if ch.is_whitespace() => last = ch,
-                            Some((offset, _)) => {
-                                input = rest.advance(offset);
-                                bytes = input.bytes().enumerate();
-                                break;
-                            }
-                            None => return Err(Reject),
-                        }
-                    }
-                }
-                _ => break,
-            },
-            b if b < 0x80 => {}
-            _ => break,
-        }
-    }
-    Err(Reject)
-}
-
-fn raw_string(input: Cursor) -> Result<Cursor, Reject> {
-    let mut chars = input.char_indices();
-    let mut n = 0;
-    for (i, ch) in &mut chars {
-        match ch {
-            '"' => {
-                n = i;
-                break;
-            }
-            '#' => {}
-            _ => return Err(Reject),
-        }
-    }
-    while let Some((i, ch)) = chars.next() {
-        match ch {
-            '"' if input.rest[i + 1..].starts_with(&input.rest[..n]) => {
-                let rest = input.advance(i + 1 + n);
-                return Ok(literal_suffix(rest));
-            }
-            '\r' => match chars.next() {
-                Some((_, '\n')) => {}
-                _ => break,
-            },
-            _ => {}
-        }
-    }
-    Err(Reject)
-}
-
-fn byte(input: Cursor) -> Result<Cursor, Reject> {
-    let input = input.parse("b'")?;
-    let mut bytes = input.bytes().enumerate();
-    let ok = match bytes.next().map(|(_, b)| b) {
-        Some(b'\\') => match bytes.next().map(|(_, b)| b) {
-            Some(b'x') => backslash_x_byte(&mut bytes),
-            Some(b'n') | Some(b'r') | Some(b't') | Some(b'\\') | Some(b'0') | Some(b'\'')
-            | Some(b'"') => true,
-            _ => false,
-        },
-        b => b.is_some(),
-    };
-    if !ok {
-        return Err(Reject);
-    }
-    let (offset, _) = bytes.next().ok_or(Reject)?;
-    if !input.chars().as_str().is_char_boundary(offset) {
-        return Err(Reject);
-    }
-    let input = input.advance(offset).parse("'")?;
-    Ok(literal_suffix(input))
-}
-
-fn character(input: Cursor) -> Result<Cursor, Reject> {
-    let input = input.parse("'")?;
-    let mut chars = input.char_indices();
-    let ok = match chars.next().map(|(_, ch)| ch) {
-        Some('\\') => match chars.next().map(|(_, ch)| ch) {
-            Some('x') => backslash_x_char(&mut chars),
-            Some('u') => backslash_u(&mut chars),
-            Some('n') | Some('r') | Some('t') | Some('\\') | Some('0') | Some('\'') | Some('"') => {
-                true
-            }
-            _ => false,
-        },
-        ch => ch.is_some(),
-    };
-    if !ok {
-        return Err(Reject);
-    }
-    let (idx, _) = chars.next().ok_or(Reject)?;
-    let input = input.advance(idx).parse("'")?;
-    Ok(literal_suffix(input))
-}
-
-macro_rules! next_ch {
-    ($chars:ident @ $pat:pat $(| $rest:pat)*) => {
-        match $chars.next() {
-            Some((_, ch)) => match ch {
-                $pat $(| $rest)* => ch,
-                _ => return false,
-            },
-            None => return false,
-        }
-    };
-}
-
-fn backslash_x_char<I>(chars: &mut I) -> bool
-where
-    I: Iterator<Item = (usize, char)>,
-{
-    next_ch!(chars @ '0'..='7');
-    next_ch!(chars @ '0'..='9' | 'a'..='f' | 'A'..='F');
-    true
-}
-
-fn backslash_x_byte<I>(chars: &mut I) -> bool
-where
-    I: Iterator<Item = (usize, u8)>,
-{
-    next_ch!(chars @ b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F');
-    next_ch!(chars @ b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F');
-    true
-}
-
-fn backslash_u<I>(chars: &mut I) -> bool
-where
-    I: Iterator<Item = (usize, char)>,
-{
-    next_ch!(chars @ '{');
-    let mut value = 0;
-    let mut len = 0;
-    for (_, ch) in chars {
-        let digit = match ch {
-            '0'..='9' => ch as u8 - b'0',
-            'a'..='f' => 10 + ch as u8 - b'a',
-            'A'..='F' => 10 + ch as u8 - b'A',
-            '_' if len > 0 => continue,
-            '}' if len > 0 => return char::from_u32(value).is_some(),
-            _ => return false,
-        };
-        if len == 6 {
-            return false;
-        }
-        value *= 0x10;
-        value += u32::from(digit);
-        len += 1;
-    }
-    false
-}
-
-fn float(input: Cursor) -> Result<Cursor, Reject> {
-    let mut rest = float_digits(input)?;
-    if let Some(ch) = rest.chars().next() {
-        if is_ident_start(ch) {
-            rest = ident_not_raw(rest)?.0;
-        }
-    }
-    word_break(rest)
-}
-
-fn float_digits(input: Cursor) -> Result<Cursor, Reject> {
-    let mut chars = input.chars().peekable();
-    match chars.next() {
-        Some(ch) if ch >= '0' && ch <= '9' => {}
-        _ => return Err(Reject),
-    }
-
-    let mut len = 1;
-    let mut has_dot = false;
-    let mut has_exp = false;
-    while let Some(&ch) = chars.peek() {
-        match ch {
-            '0'..='9' | '_' => {
-                chars.next();
-                len += 1;
-            }
-            '.' => {
-                if has_dot {
-                    break;
-                }
-                chars.next();
-                if chars
-                    .peek()
-                    .map(|&ch| ch == '.' || is_ident_start(ch))
-                    .unwrap_or(false)
-                {
-                    return Err(Reject);
-                }
-                len += 1;
-                has_dot = true;
-            }
-            'e' | 'E' => {
-                chars.next();
-                len += 1;
-                has_exp = true;
-                break;
-            }
-            _ => break,
-        }
-    }
-
-    if !(has_dot || has_exp) {
-        return Err(Reject);
-    }
-
-    if has_exp {
-        let token_before_exp = if has_dot {
-            Ok(input.advance(len - 1))
-        } else {
-            Err(Reject)
-        };
-        let mut has_sign = false;
-        let mut has_exp_value = false;
-        while let Some(&ch) = chars.peek() {
-            match ch {
-                '+' | '-' => {
-                    if has_exp_value {
-                        break;
-                    }
-                    if has_sign {
-                        return token_before_exp;
-                    }
-                    chars.next();
-                    len += 1;
-                    has_sign = true;
-                }
-                '0'..='9' => {
-                    chars.next();
-                    len += 1;
-                    has_exp_value = true;
-                }
-                '_' => {
-                    chars.next();
-                    len += 1;
-                }
-                _ => break,
-            }
-        }
-        if !has_exp_value {
-            return token_before_exp;
-        }
-    }
-
-    Ok(input.advance(len))
-}
-
-fn int(input: Cursor) -> Result<Cursor, Reject> {
-    let mut rest = digits(input)?;
-    if let Some(ch) = rest.chars().next() {
-        if is_ident_start(ch) {
-            rest = ident_not_raw(rest)?.0;
-        }
-    }
-    word_break(rest)
-}
-
-fn digits(mut input: Cursor) -> Result<Cursor, Reject> {
-    let base = if input.starts_with("0x") {
-        input = input.advance(2);
-        16
-    } else if input.starts_with("0o") {
-        input = input.advance(2);
-        8
-    } else if input.starts_with("0b") {
-        input = input.advance(2);
-        2
-    } else {
-        10
-    };
-
-    let mut len = 0;
-    let mut empty = true;
-    for b in input.bytes() {
-        match b {
-            b'0'..=b'9' => {
-                let digit = (b - b'0') as u64;
-                if digit >= base {
-                    return Err(Reject);
-                }
-            }
-            b'a'..=b'f' => {
-                let digit = 10 + (b - b'a') as u64;
-                if digit >= base {
-                    break;
-                }
-            }
-            b'A'..=b'F' => {
-                let digit = 10 + (b - b'A') as u64;
-                if digit >= base {
-                    break;
-                }
-            }
-            b'_' => {
-                if empty && base == 10 {
-                    return Err(Reject);
-                }
-                len += 1;
-                continue;
-            }
-            _ => break,
-        };
-        len += 1;
-        empty = false;
-    }
-    if empty {
-        Err(Reject)
-    } else {
-        Ok(input.advance(len))
-    }
-}
-
-fn punct(input: Cursor) -> PResult<Punct> {
-    let (rest, ch) = punct_char(input)?;
-    if ch == '\'' {
-        if ident_any(rest)?.0.starts_with("'") {
-            Err(Reject)
-        } else {
-            Ok((rest, Punct::new('\'', Spacing::Joint)))
-        }
-    } else {
-        let kind = match punct_char(rest) {
-            Ok(_) => Spacing::Joint,
-            Err(Reject) => Spacing::Alone,
-        };
-        Ok((rest, Punct::new(ch, kind)))
-    }
-}
-
-fn punct_char(input: Cursor) -> PResult<char> {
-    if input.starts_with("//") || input.starts_with("/*") {
-        // Do not accept `/` of a comment as a punct.
-        return Err(Reject);
-    }
-
-    let mut chars = input.chars();
-    let first = match chars.next() {
-        Some(ch) => ch,
-        None => {
-            return Err(Reject);
-        }
-    };
-    let recognized = "~!@#$%^&*-=+|;:,<.>/?'";
-    if recognized.contains(first) {
-        Ok((input.advance(first.len_utf8()), first))
-    } else {
-        Err(Reject)
-    }
-}
-
-fn doc_comment(input: Cursor) -> PResult<Vec<TokenTree>> {
-    #[cfg(span_locations)]
-    let lo = input.off;
-    let (rest, (comment, inner)) = doc_comment_contents(input)?;
-    let span = crate::Span::_new_stable(Span {
-        #[cfg(span_locations)]
-        lo,
-        #[cfg(span_locations)]
-        hi: rest.off,
-    });
-
-    let mut scan_for_bare_cr = comment;
-    while let Some(cr) = scan_for_bare_cr.find('\r') {
-        let rest = &scan_for_bare_cr[cr + 1..];
-        if !rest.starts_with('\n') {
-            return Err(Reject);
-        }
-        scan_for_bare_cr = rest;
-    }
-
-    let mut trees = Vec::new();
-    trees.push(TokenTree::Punct(Punct::new('#', Spacing::Alone)));
-    if inner {
-        trees.push(Punct::new('!', Spacing::Alone).into());
-    }
-    let mut stream = vec![
-        TokenTree::Ident(crate::Ident::new("doc", span)),
-        TokenTree::Punct(Punct::new('=', Spacing::Alone)),
-        TokenTree::Literal(crate::Literal::string(comment)),
-    ];
-    for tt in stream.iter_mut() {
-        tt.set_span(span);
-    }
-    let group = Group::new(Delimiter::Bracket, stream.into_iter().collect());
-    trees.push(crate::Group::_new_stable(group).into());
-    for tt in trees.iter_mut() {
-        tt.set_span(span);
-    }
-    Ok((rest, trees))
-}
-
-fn doc_comment_contents(input: Cursor) -> PResult<(&str, bool)> {
-    if input.starts_with("//!") {
-        let input = input.advance(3);
-        let (input, s) = take_until_newline_or_eof(input);
-        Ok((input, (s, true)))
-    } else if input.starts_with("/*!") {
-        let (input, s) = block_comment(input)?;
-        Ok((input, (&s[3..s.len() - 2], true)))
-    } else if input.starts_with("///") {
-        let input = input.advance(3);
-        if input.starts_with("/") {
-            return Err(Reject);
-        }
-        let (input, s) = take_until_newline_or_eof(input);
-        Ok((input, (s, false)))
-    } else if input.starts_with("/**") && !input.rest[3..].starts_with('*') {
-        let (input, s) = block_comment(input)?;
-        Ok((input, (&s[3..s.len() - 2], false)))
-    } else {
-        Err(Reject)
-    }
-}
-
-fn take_until_newline_or_eof(input: Cursor) -> (Cursor, &str) {
-    let chars = input.char_indices();
-
-    for (i, ch) in chars {
-        if ch == '\n' {
-            return (input.advance(i), &input.rest[..i]);
-        } else if ch == '\r' && input.rest[i + 1..].starts_with('\n') {
-            return (input.advance(i + 1), &input.rest[..i]);
-        }
-    }
-
-    (input.advance(input.len()), input.rest)
-}
diff --git a/vendor/proc-macro2/src/wrapper.rs b/vendor/proc-macro2/src/wrapper.rs
deleted file mode 100644
index dc938736..00000000
--- a/vendor/proc-macro2/src/wrapper.rs
+++ /dev/null
@@ -1,966 +0,0 @@
-use crate::detection::inside_proc_macro;
-use crate::{fallback, Delimiter, Punct, Spacing, TokenTree};
-use std::fmt::{self, Debug, Display};
-use std::iter::FromIterator;
-use std::ops::RangeBounds;
-use std::panic;
-#[cfg(super_unstable)]
-use std::path::PathBuf;
-use std::str::FromStr;
-
-#[derive(Clone)]
-pub(crate) enum TokenStream {
-    Compiler(DeferredTokenStream),
-    Fallback(fallback::TokenStream),
-}
-
-// Work around https://github.com/rust-lang/rust/issues/65080.
-// In `impl Extend<TokenTree> for TokenStream` which is used heavily by quote,
-// we hold on to the appended tokens and do proc_macro::TokenStream::extend as
-// late as possible to batch together consecutive uses of the Extend impl.
-#[derive(Clone)]
-pub(crate) struct DeferredTokenStream {
-    stream: proc_macro::TokenStream,
-    extra: Vec<proc_macro::TokenTree>,
-}
-
-pub(crate) enum LexError {
-    Compiler(proc_macro::LexError),
-    Fallback(fallback::LexError),
-}
-
-impl LexError {
-    fn call_site() -> Self {
-        LexError::Fallback(fallback::LexError {
-            span: fallback::Span::call_site(),
-        })
-    }
-}
-
-fn mismatch() -> ! {
-    panic!("stable/nightly mismatch")
-}
-
-impl DeferredTokenStream {
-    fn new(stream: proc_macro::TokenStream) -> Self {
-        DeferredTokenStream {
-            stream,
-            extra: Vec::new(),
-        }
-    }
-
-    fn is_empty(&self) -> bool {
-        self.stream.is_empty() && self.extra.is_empty()
-    }
-
-    fn evaluate_now(&mut self) {
-        // If-check provides a fast short circuit for the common case of `extra`
-        // being empty, which saves a round trip over the proc macro bridge.
-        // Improves macro expansion time in winrt by 6% in debug mode.
-        if !self.extra.is_empty() {
-            self.stream.extend(self.extra.drain(..));
-        }
-    }
-
-    fn into_token_stream(mut self) -> proc_macro::TokenStream {
-        self.evaluate_now();
-        self.stream
-    }
-}
-
-impl TokenStream {
-    pub fn new() -> TokenStream {
-        if inside_proc_macro() {
-            TokenStream::Compiler(DeferredTokenStream::new(proc_macro::TokenStream::new()))
-        } else {
-            TokenStream::Fallback(fallback::TokenStream::new())
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        match self {
-            TokenStream::Compiler(tts) => tts.is_empty(),
-            TokenStream::Fallback(tts) => tts.is_empty(),
-        }
-    }
-
-    fn unwrap_nightly(self) -> proc_macro::TokenStream {
-        match self {
-            TokenStream::Compiler(s) => s.into_token_stream(),
-            TokenStream::Fallback(_) => mismatch(),
-        }
-    }
-
-    fn unwrap_stable(self) -> fallback::TokenStream {
-        match self {
-            TokenStream::Compiler(_) => mismatch(),
-            TokenStream::Fallback(s) => s,
-        }
-    }
-}
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        if inside_proc_macro() {
-            Ok(TokenStream::Compiler(DeferredTokenStream::new(
-                proc_macro_parse(src)?,
-            )))
-        } else {
-            Ok(TokenStream::Fallback(src.parse()?))
-        }
-    }
-}
-
-// Work around https://github.com/rust-lang/rust/issues/58736.
-fn proc_macro_parse(src: &str) -> Result<proc_macro::TokenStream, LexError> {
-    let result = panic::catch_unwind(|| src.parse().map_err(LexError::Compiler));
-    result.unwrap_or_else(|_| Err(LexError::call_site()))
-}
-
-impl Display for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TokenStream::Compiler(tts) => Display::fmt(&tts.clone().into_token_stream(), f),
-            TokenStream::Fallback(tts) => Display::fmt(tts, f),
-        }
-    }
-}
-
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        TokenStream::Compiler(DeferredTokenStream::new(inner))
-    }
-}
-
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        match inner {
-            TokenStream::Compiler(inner) => inner.into_token_stream(),
-            TokenStream::Fallback(inner) => inner.to_string().parse().unwrap(),
-        }
-    }
-}
-
-impl From<fallback::TokenStream> for TokenStream {
-    fn from(inner: fallback::TokenStream) -> TokenStream {
-        TokenStream::Fallback(inner)
-    }
-}
-
-// Assumes inside_proc_macro().
-fn into_compiler_token(token: TokenTree) -> proc_macro::TokenTree {
-    match token {
-        TokenTree::Group(tt) => tt.inner.unwrap_nightly().into(),
-        TokenTree::Punct(tt) => {
-            let spacing = match tt.spacing() {
-                Spacing::Joint => proc_macro::Spacing::Joint,
-                Spacing::Alone => proc_macro::Spacing::Alone,
-            };
-            let mut punct = proc_macro::Punct::new(tt.as_char(), spacing);
-            punct.set_span(tt.span().inner.unwrap_nightly());
-            punct.into()
-        }
-        TokenTree::Ident(tt) => tt.inner.unwrap_nightly().into(),
-        TokenTree::Literal(tt) => tt.inner.unwrap_nightly().into(),
-    }
-}
-
-impl From<TokenTree> for TokenStream {
-    fn from(token: TokenTree) -> TokenStream {
-        if inside_proc_macro() {
-            TokenStream::Compiler(DeferredTokenStream::new(into_compiler_token(token).into()))
-        } else {
-            TokenStream::Fallback(token.into())
-        }
-    }
-}
-
-impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self {
-        if inside_proc_macro() {
-            TokenStream::Compiler(DeferredTokenStream::new(
-                trees.into_iter().map(into_compiler_token).collect(),
-            ))
-        } else {
-            TokenStream::Fallback(trees.into_iter().collect())
-        }
-    }
-}
-
-impl FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
-        let mut streams = streams.into_iter();
-        match streams.next() {
-            Some(TokenStream::Compiler(mut first)) => {
-                first.evaluate_now();
-                first.stream.extend(streams.map(|s| match s {
-                    TokenStream::Compiler(s) => s.into_token_stream(),
-                    TokenStream::Fallback(_) => mismatch(),
-                }));
-                TokenStream::Compiler(first)
-            }
-            Some(TokenStream::Fallback(mut first)) => {
-                first.extend(streams.map(|s| match s {
-                    TokenStream::Fallback(s) => s,
-                    TokenStream::Compiler(_) => mismatch(),
-                }));
-                TokenStream::Fallback(first)
-            }
-            None => TokenStream::new(),
-        }
-    }
-}
-
-impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, stream: I) {
-        match self {
-            TokenStream::Compiler(tts) => {
-                // Here is the reason for DeferredTokenStream.
-                for token in stream {
-                    tts.extra.push(into_compiler_token(token));
-                }
-            }
-            TokenStream::Fallback(tts) => tts.extend(stream),
-        }
-    }
-}
-
-impl Extend<TokenStream> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
-        match self {
-            TokenStream::Compiler(tts) => {
-                tts.evaluate_now();
-                tts.stream
-                    .extend(streams.into_iter().map(TokenStream::unwrap_nightly));
-            }
-            TokenStream::Fallback(tts) => {
-                tts.extend(streams.into_iter().map(TokenStream::unwrap_stable));
-            }
-        }
-    }
-}
-
-impl Debug for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TokenStream::Compiler(tts) => Debug::fmt(&tts.clone().into_token_stream(), f),
-            TokenStream::Fallback(tts) => Debug::fmt(tts, f),
-        }
-    }
-}
-
-impl LexError {
-    pub(crate) fn span(&self) -> Span {
-        match self {
-            LexError::Compiler(_) => Span::call_site(),
-            LexError::Fallback(e) => Span::Fallback(e.span()),
-        }
-    }
-}
-
-impl From<proc_macro::LexError> for LexError {
-    fn from(e: proc_macro::LexError) -> LexError {
-        LexError::Compiler(e)
-    }
-}
-
-impl From<fallback::LexError> for LexError {
-    fn from(e: fallback::LexError) -> LexError {
-        LexError::Fallback(e)
-    }
-}
-
-impl Debug for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            LexError::Compiler(e) => Debug::fmt(e, f),
-            LexError::Fallback(e) => Debug::fmt(e, f),
-        }
-    }
-}
-
-impl Display for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            #[cfg(lexerror_display)]
-            LexError::Compiler(e) => Display::fmt(e, f),
-            #[cfg(not(lexerror_display))]
-            LexError::Compiler(_e) => Display::fmt(
-                &fallback::LexError {
-                    span: fallback::Span::call_site(),
-                },
-                f,
-            ),
-            LexError::Fallback(e) => Display::fmt(e, f),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) enum TokenTreeIter {
-    Compiler(proc_macro::token_stream::IntoIter),
-    Fallback(fallback::TokenTreeIter),
-}
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = TokenTreeIter;
-
-    fn into_iter(self) -> TokenTreeIter {
-        match self {
-            TokenStream::Compiler(tts) => {
-                TokenTreeIter::Compiler(tts.into_token_stream().into_iter())
-            }
-            TokenStream::Fallback(tts) => TokenTreeIter::Fallback(tts.into_iter()),
-        }
-    }
-}
-
-impl Iterator for TokenTreeIter {
-    type Item = TokenTree;
-
-    fn next(&mut self) -> Option<TokenTree> {
-        let token = match self {
-            TokenTreeIter::Compiler(iter) => iter.next()?,
-            TokenTreeIter::Fallback(iter) => return iter.next(),
-        };
-        Some(match token {
-            proc_macro::TokenTree::Group(tt) => crate::Group::_new(Group::Compiler(tt)).into(),
-            proc_macro::TokenTree::Punct(tt) => {
-                let spacing = match tt.spacing() {
-                    proc_macro::Spacing::Joint => Spacing::Joint,
-                    proc_macro::Spacing::Alone => Spacing::Alone,
-                };
-                let mut o = Punct::new(tt.as_char(), spacing);
-                o.set_span(crate::Span::_new(Span::Compiler(tt.span())));
-                o.into()
-            }
-            proc_macro::TokenTree::Ident(s) => crate::Ident::_new(Ident::Compiler(s)).into(),
-            proc_macro::TokenTree::Literal(l) => crate::Literal::_new(Literal::Compiler(l)).into(),
-        })
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self {
-            TokenTreeIter::Compiler(tts) => tts.size_hint(),
-            TokenTreeIter::Fallback(tts) => tts.size_hint(),
-        }
-    }
-}
-
-impl Debug for TokenTreeIter {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("TokenTreeIter").finish()
-    }
-}
-
-#[derive(Clone, PartialEq, Eq)]
-#[cfg(super_unstable)]
-pub(crate) enum SourceFile {
-    Compiler(proc_macro::SourceFile),
-    Fallback(fallback::SourceFile),
-}
-
-#[cfg(super_unstable)]
-impl SourceFile {
-    fn nightly(sf: proc_macro::SourceFile) -> Self {
-        SourceFile::Compiler(sf)
-    }
-
-    /// Get the path to this source file as a string.
-    pub fn path(&self) -> PathBuf {
-        match self {
-            SourceFile::Compiler(a) => a.path(),
-            SourceFile::Fallback(a) => a.path(),
-        }
-    }
-
-    pub fn is_real(&self) -> bool {
-        match self {
-            SourceFile::Compiler(a) => a.is_real(),
-            SourceFile::Fallback(a) => a.is_real(),
-        }
-    }
-}
-
-#[cfg(super_unstable)]
-impl Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            SourceFile::Compiler(a) => Debug::fmt(a, f),
-            SourceFile::Fallback(a) => Debug::fmt(a, f),
-        }
-    }
-}
-
-#[cfg(any(super_unstable, feature = "span-locations"))]
-pub(crate) struct LineColumn {
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Copy, Clone)]
-pub(crate) enum Span {
-    Compiler(proc_macro::Span),
-    Fallback(fallback::Span),
-}
-
-impl Span {
-    pub fn call_site() -> Span {
-        if inside_proc_macro() {
-            Span::Compiler(proc_macro::Span::call_site())
-        } else {
-            Span::Fallback(fallback::Span::call_site())
-        }
-    }
-
-    #[cfg(hygiene)]
-    pub fn mixed_site() -> Span {
-        if inside_proc_macro() {
-            Span::Compiler(proc_macro::Span::mixed_site())
-        } else {
-            Span::Fallback(fallback::Span::mixed_site())
-        }
-    }
-
-    #[cfg(super_unstable)]
-    pub fn def_site() -> Span {
-        if inside_proc_macro() {
-            Span::Compiler(proc_macro::Span::def_site())
-        } else {
-            Span::Fallback(fallback::Span::def_site())
-        }
-    }
-
-    pub fn resolved_at(&self, other: Span) -> Span {
-        match (self, other) {
-            #[cfg(hygiene)]
-            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.resolved_at(b)),
-
-            // Name resolution affects semantics, but location is only cosmetic
-            #[cfg(not(hygiene))]
-            (Span::Compiler(_), Span::Compiler(_)) => other,
-
-            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.resolved_at(b)),
-            _ => mismatch(),
-        }
-    }
-
-    pub fn located_at(&self, other: Span) -> Span {
-        match (self, other) {
-            #[cfg(hygiene)]
-            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.located_at(b)),
-
-            // Name resolution affects semantics, but location is only cosmetic
-            #[cfg(not(hygiene))]
-            (Span::Compiler(_), Span::Compiler(_)) => *self,
-
-            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.located_at(b)),
-            _ => mismatch(),
-        }
-    }
-
-    pub fn unwrap(self) -> proc_macro::Span {
-        match self {
-            Span::Compiler(s) => s,
-            Span::Fallback(_) => panic!("proc_macro::Span is only available in procedural macros"),
-        }
-    }
-
-    #[cfg(super_unstable)]
-    pub fn source_file(&self) -> SourceFile {
-        match self {
-            Span::Compiler(s) => SourceFile::nightly(s.source_file()),
-            Span::Fallback(s) => SourceFile::Fallback(s.source_file()),
-        }
-    }
-
-    #[cfg(any(super_unstable, feature = "span-locations"))]
-    pub fn start(&self) -> LineColumn {
-        match self {
-            #[cfg(proc_macro_span)]
-            Span::Compiler(s) => {
-                let proc_macro::LineColumn { line, column } = s.start();
-                LineColumn { line, column }
-            }
-            #[cfg(not(proc_macro_span))]
-            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
-            Span::Fallback(s) => {
-                let fallback::LineColumn { line, column } = s.start();
-                LineColumn { line, column }
-            }
-        }
-    }
-
-    #[cfg(any(super_unstable, feature = "span-locations"))]
-    pub fn end(&self) -> LineColumn {
-        match self {
-            #[cfg(proc_macro_span)]
-            Span::Compiler(s) => {
-                let proc_macro::LineColumn { line, column } = s.end();
-                LineColumn { line, column }
-            }
-            #[cfg(not(proc_macro_span))]
-            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
-            Span::Fallback(s) => {
-                let fallback::LineColumn { line, column } = s.end();
-                LineColumn { line, column }
-            }
-        }
-    }
-
-    pub fn join(&self, other: Span) -> Option<Span> {
-        let ret = match (self, other) {
-            #[cfg(proc_macro_span)]
-            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.join(b)?),
-            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.join(b)?),
-            _ => return None,
-        };
-        Some(ret)
-    }
-
-    #[cfg(super_unstable)]
-    pub fn eq(&self, other: &Span) -> bool {
-        match (self, other) {
-            (Span::Compiler(a), Span::Compiler(b)) => a.eq(b),
-            (Span::Fallback(a), Span::Fallback(b)) => a.eq(b),
-            _ => false,
-        }
-    }
-
-    fn unwrap_nightly(self) -> proc_macro::Span {
-        match self {
-            Span::Compiler(s) => s,
-            Span::Fallback(_) => mismatch(),
-        }
-    }
-}
-
-impl From<proc_macro::Span> for crate::Span {
-    fn from(proc_span: proc_macro::Span) -> crate::Span {
-        crate::Span::_new(Span::Compiler(proc_span))
-    }
-}
-
-impl From<fallback::Span> for Span {
-    fn from(inner: fallback::Span) -> Span {
-        Span::Fallback(inner)
-    }
-}
-
-impl Debug for Span {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Span::Compiler(s) => Debug::fmt(s, f),
-            Span::Fallback(s) => Debug::fmt(s, f),
-        }
-    }
-}
-
-pub(crate) fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
-    match span {
-        Span::Compiler(s) => {
-            debug.field("span", &s);
-        }
-        Span::Fallback(s) => fallback::debug_span_field_if_nontrivial(debug, s),
-    }
-}
-
-#[derive(Clone)]
-pub(crate) enum Group {
-    Compiler(proc_macro::Group),
-    Fallback(fallback::Group),
-}
-
-impl Group {
-    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
-        match stream {
-            TokenStream::Compiler(tts) => {
-                let delimiter = match delimiter {
-                    Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
-                    Delimiter::Bracket => proc_macro::Delimiter::Bracket,
-                    Delimiter::Brace => proc_macro::Delimiter::Brace,
-                    Delimiter::None => proc_macro::Delimiter::None,
-                };
-                Group::Compiler(proc_macro::Group::new(delimiter, tts.into_token_stream()))
-            }
-            TokenStream::Fallback(stream) => {
-                Group::Fallback(fallback::Group::new(delimiter, stream))
-            }
-        }
-    }
-
-    pub fn delimiter(&self) -> Delimiter {
-        match self {
-            Group::Compiler(g) => match g.delimiter() {
-                proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
-                proc_macro::Delimiter::Bracket => Delimiter::Bracket,
-                proc_macro::Delimiter::Brace => Delimiter::Brace,
-                proc_macro::Delimiter::None => Delimiter::None,
-            },
-            Group::Fallback(g) => g.delimiter(),
-        }
-    }
-
-    pub fn stream(&self) -> TokenStream {
-        match self {
-            Group::Compiler(g) => TokenStream::Compiler(DeferredTokenStream::new(g.stream())),
-            Group::Fallback(g) => TokenStream::Fallback(g.stream()),
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        match self {
-            Group::Compiler(g) => Span::Compiler(g.span()),
-            Group::Fallback(g) => Span::Fallback(g.span()),
-        }
-    }
-
-    pub fn span_open(&self) -> Span {
-        match self {
-            #[cfg(proc_macro_span)]
-            Group::Compiler(g) => Span::Compiler(g.span_open()),
-            #[cfg(not(proc_macro_span))]
-            Group::Compiler(g) => Span::Compiler(g.span()),
-            Group::Fallback(g) => Span::Fallback(g.span_open()),
-        }
-    }
-
-    pub fn span_close(&self) -> Span {
-        match self {
-            #[cfg(proc_macro_span)]
-            Group::Compiler(g) => Span::Compiler(g.span_close()),
-            #[cfg(not(proc_macro_span))]
-            Group::Compiler(g) => Span::Compiler(g.span()),
-            Group::Fallback(g) => Span::Fallback(g.span_close()),
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        match (self, span) {
-            (Group::Compiler(g), Span::Compiler(s)) => g.set_span(s),
-            (Group::Fallback(g), Span::Fallback(s)) => g.set_span(s),
-            _ => mismatch(),
-        }
-    }
-
-    fn unwrap_nightly(self) -> proc_macro::Group {
-        match self {
-            Group::Compiler(g) => g,
-            Group::Fallback(_) => mismatch(),
-        }
-    }
-}
-
-impl From<fallback::Group> for Group {
-    fn from(g: fallback::Group) -> Self {
-        Group::Fallback(g)
-    }
-}
-
-impl Display for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Group::Compiler(group) => Display::fmt(group, formatter),
-            Group::Fallback(group) => Display::fmt(group, formatter),
-        }
-    }
-}
-
-impl Debug for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Group::Compiler(group) => Debug::fmt(group, formatter),
-            Group::Fallback(group) => Debug::fmt(group, formatter),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) enum Ident {
-    Compiler(proc_macro::Ident),
-    Fallback(fallback::Ident),
-}
-
-impl Ident {
-    pub fn new(string: &str, span: Span) -> Ident {
-        match span {
-            Span::Compiler(s) => Ident::Compiler(proc_macro::Ident::new(string, s)),
-            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new(string, s)),
-        }
-    }
-
-    pub fn new_raw(string: &str, span: Span) -> Ident {
-        match span {
-            Span::Compiler(s) => {
-                let p: proc_macro::TokenStream = string.parse().unwrap();
-                let ident = match p.into_iter().next() {
-                    Some(proc_macro::TokenTree::Ident(mut i)) => {
-                        i.set_span(s);
-                        i
-                    }
-                    _ => panic!(),
-                };
-                Ident::Compiler(ident)
-            }
-            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new_raw(string, s)),
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        match self {
-            Ident::Compiler(t) => Span::Compiler(t.span()),
-            Ident::Fallback(t) => Span::Fallback(t.span()),
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        match (self, span) {
-            (Ident::Compiler(t), Span::Compiler(s)) => t.set_span(s),
-            (Ident::Fallback(t), Span::Fallback(s)) => t.set_span(s),
-            _ => mismatch(),
-        }
-    }
-
-    fn unwrap_nightly(self) -> proc_macro::Ident {
-        match self {
-            Ident::Compiler(s) => s,
-            Ident::Fallback(_) => mismatch(),
-        }
-    }
-}
-
-impl PartialEq for Ident {
-    fn eq(&self, other: &Ident) -> bool {
-        match (self, other) {
-            (Ident::Compiler(t), Ident::Compiler(o)) => t.to_string() == o.to_string(),
-            (Ident::Fallback(t), Ident::Fallback(o)) => t == o,
-            _ => mismatch(),
-        }
-    }
-}
-
-impl<T> PartialEq<T> for Ident
-where
-    T: ?Sized + AsRef<str>,
-{
-    fn eq(&self, other: &T) -> bool {
-        let other = other.as_ref();
-        match self {
-            Ident::Compiler(t) => t.to_string() == other,
-            Ident::Fallback(t) => t == other,
-        }
-    }
-}
-
-impl Display for Ident {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Ident::Compiler(t) => Display::fmt(t, f),
-            Ident::Fallback(t) => Display::fmt(t, f),
-        }
-    }
-}
-
-impl Debug for Ident {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Ident::Compiler(t) => Debug::fmt(t, f),
-            Ident::Fallback(t) => Debug::fmt(t, f),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) enum Literal {
-    Compiler(proc_macro::Literal),
-    Fallback(fallback::Literal),
-}
-
-macro_rules! suffixed_numbers {
-    ($($name:ident => $kind:ident,)*) => ($(
-        pub fn $name(n: $kind) -> Literal {
-            if inside_proc_macro() {
-                Literal::Compiler(proc_macro::Literal::$name(n))
-            } else {
-                Literal::Fallback(fallback::Literal::$name(n))
-            }
-        }
-    )*)
-}
-
-macro_rules! unsuffixed_integers {
-    ($($name:ident => $kind:ident,)*) => ($(
-        pub fn $name(n: $kind) -> Literal {
-            if inside_proc_macro() {
-                Literal::Compiler(proc_macro::Literal::$name(n))
-            } else {
-                Literal::Fallback(fallback::Literal::$name(n))
-            }
-        }
-    )*)
-}
-
-impl Literal {
-    suffixed_numbers! {
-        u8_suffixed => u8,
-        u16_suffixed => u16,
-        u32_suffixed => u32,
-        u64_suffixed => u64,
-        u128_suffixed => u128,
-        usize_suffixed => usize,
-        i8_suffixed => i8,
-        i16_suffixed => i16,
-        i32_suffixed => i32,
-        i64_suffixed => i64,
-        i128_suffixed => i128,
-        isize_suffixed => isize,
-
-        f32_suffixed => f32,
-        f64_suffixed => f64,
-    }
-
-    unsuffixed_integers! {
-        u8_unsuffixed => u8,
-        u16_unsuffixed => u16,
-        u32_unsuffixed => u32,
-        u64_unsuffixed => u64,
-        u128_unsuffixed => u128,
-        usize_unsuffixed => usize,
-        i8_unsuffixed => i8,
-        i16_unsuffixed => i16,
-        i32_unsuffixed => i32,
-        i64_unsuffixed => i64,
-        i128_unsuffixed => i128,
-        isize_unsuffixed => isize,
-    }
-
-    pub fn f32_unsuffixed(f: f32) -> Literal {
-        if inside_proc_macro() {
-            Literal::Compiler(proc_macro::Literal::f32_unsuffixed(f))
-        } else {
-            Literal::Fallback(fallback::Literal::f32_unsuffixed(f))
-        }
-    }
-
-    pub fn f64_unsuffixed(f: f64) -> Literal {
-        if inside_proc_macro() {
-            Literal::Compiler(proc_macro::Literal::f64_unsuffixed(f))
-        } else {
-            Literal::Fallback(fallback::Literal::f64_unsuffixed(f))
-        }
-    }
-
-    pub fn string(t: &str) -> Literal {
-        if inside_proc_macro() {
-            Literal::Compiler(proc_macro::Literal::string(t))
-        } else {
-            Literal::Fallback(fallback::Literal::string(t))
-        }
-    }
-
-    pub fn character(t: char) -> Literal {
-        if inside_proc_macro() {
-            Literal::Compiler(proc_macro::Literal::character(t))
-        } else {
-            Literal::Fallback(fallback::Literal::character(t))
-        }
-    }
-
-    pub fn byte_string(bytes: &[u8]) -> Literal {
-        if inside_proc_macro() {
-            Literal::Compiler(proc_macro::Literal::byte_string(bytes))
-        } else {
-            Literal::Fallback(fallback::Literal::byte_string(bytes))
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        match self {
-            Literal::Compiler(lit) => Span::Compiler(lit.span()),
-            Literal::Fallback(lit) => Span::Fallback(lit.span()),
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        match (self, span) {
-            (Literal::Compiler(lit), Span::Compiler(s)) => lit.set_span(s),
-            (Literal::Fallback(lit), Span::Fallback(s)) => lit.set_span(s),
-            _ => mismatch(),
-        }
-    }
-
-    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        match self {
-            #[cfg(proc_macro_span)]
-            Literal::Compiler(lit) => lit.subspan(range).map(Span::Compiler),
-            #[cfg(not(proc_macro_span))]
-            Literal::Compiler(_lit) => None,
-            Literal::Fallback(lit) => lit.subspan(range).map(Span::Fallback),
-        }
-    }
-
-    fn unwrap_nightly(self) -> proc_macro::Literal {
-        match self {
-            Literal::Compiler(s) => s,
-            Literal::Fallback(_) => mismatch(),
-        }
-    }
-}
-
-impl From<fallback::Literal> for Literal {
-    fn from(s: fallback::Literal) -> Literal {
-        Literal::Fallback(s)
-    }
-}
-
-impl FromStr for Literal {
-    type Err = LexError;
-
-    fn from_str(repr: &str) -> Result<Self, Self::Err> {
-        if inside_proc_macro() {
-            #[cfg(literal_from_str)]
-            {
-                proc_macro::Literal::from_str(repr)
-                    .map(Literal::Compiler)
-                    .map_err(LexError::Compiler)
-            }
-            #[cfg(not(literal_from_str))]
-            {
-                let tokens = proc_macro_parse(repr)?;
-                let mut iter = tokens.into_iter();
-                if let (Some(proc_macro::TokenTree::Literal(literal)), None) =
-                    (iter.next(), iter.next())
-                {
-                    if literal.to_string().len() == repr.len() {
-                        return Ok(Literal::Compiler(literal));
-                    }
-                }
-                Err(LexError::call_site())
-            }
-        } else {
-            let literal = fallback::Literal::from_str(repr)?;
-            Ok(Literal::Fallback(literal))
-        }
-    }
-}
-
-impl Display for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Literal::Compiler(t) => Display::fmt(t, f),
-            Literal::Fallback(t) => Display::fmt(t, f),
-        }
-    }
-}
-
-impl Debug for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Literal::Compiler(t) => Debug::fmt(t, f),
-            Literal::Fallback(t) => Debug::fmt(t, f),
-        }
-    }
-}
diff --git a/vendor/proc-macro2/tests/comments.rs b/vendor/proc-macro2/tests/comments.rs
deleted file mode 100644
index 708cccb8..00000000
--- a/vendor/proc-macro2/tests/comments.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use proc_macro2::{Delimiter, Literal, Spacing, TokenStream, TokenTree};
-
-// #[doc = "..."] -> "..."
-fn lit_of_outer_doc_comment(tokens: TokenStream) -> Literal {
-    lit_of_doc_comment(tokens, false)
-}
-
-// #![doc = "..."] -> "..."
-fn lit_of_inner_doc_comment(tokens: TokenStream) -> Literal {
-    lit_of_doc_comment(tokens, true)
-}
-
-fn lit_of_doc_comment(tokens: TokenStream, inner: bool) -> Literal {
-    let mut iter = tokens.clone().into_iter();
-    match iter.next().unwrap() {
-        TokenTree::Punct(punct) => {
-            assert_eq!(punct.as_char(), '#');
-            assert_eq!(punct.spacing(), Spacing::Alone);
-        }
-        _ => panic!("wrong token {:?}", tokens),
-    }
-    if inner {
-        match iter.next().unwrap() {
-            TokenTree::Punct(punct) => {
-                assert_eq!(punct.as_char(), '!');
-                assert_eq!(punct.spacing(), Spacing::Alone);
-            }
-            _ => panic!("wrong token {:?}", tokens),
-        }
-    }
-    iter = match iter.next().unwrap() {
-        TokenTree::Group(group) => {
-            assert_eq!(group.delimiter(), Delimiter::Bracket);
-            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
-            group.stream().into_iter()
-        }
-        _ => panic!("wrong token {:?}", tokens),
-    };
-    match iter.next().unwrap() {
-        TokenTree::Ident(ident) => assert_eq!(ident.to_string(), "doc"),
-        _ => panic!("wrong token {:?}", tokens),
-    }
-    match iter.next().unwrap() {
-        TokenTree::Punct(punct) => {
-            assert_eq!(punct.as_char(), '=');
-            assert_eq!(punct.spacing(), Spacing::Alone);
-        }
-        _ => panic!("wrong token {:?}", tokens),
-    }
-    match iter.next().unwrap() {
-        TokenTree::Literal(literal) => {
-            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
-            literal
-        }
-        _ => panic!("wrong token {:?}", tokens),
-    }
-}
-
-#[test]
-fn closed_immediately() {
-    let stream = "/**/".parse::<TokenStream>().unwrap();
-    let tokens = stream.into_iter().collect::<Vec<_>>();
-    assert!(tokens.is_empty(), "not empty -- {:?}", tokens);
-}
-
-#[test]
-fn incomplete() {
-    assert!("/*/".parse::<TokenStream>().is_err());
-}
-
-#[test]
-fn lit() {
-    let stream = "/// doc".parse::<TokenStream>().unwrap();
-    let lit = lit_of_outer_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\" doc\"");
-
-    let stream = "//! doc".parse::<TokenStream>().unwrap();
-    let lit = lit_of_inner_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\" doc\"");
-
-    let stream = "/** doc */".parse::<TokenStream>().unwrap();
-    let lit = lit_of_outer_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\" doc \"");
-
-    let stream = "/*! doc */".parse::<TokenStream>().unwrap();
-    let lit = lit_of_inner_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\" doc \"");
-}
-
-#[test]
-fn carriage_return() {
-    let stream = "///\r\n".parse::<TokenStream>().unwrap();
-    let lit = lit_of_outer_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\"\"");
-
-    let stream = "/**\r\n*/".parse::<TokenStream>().unwrap();
-    let lit = lit_of_outer_doc_comment(stream);
-    assert_eq!(lit.to_string(), "\"\\r\\n\"");
-
-    "///\r".parse::<TokenStream>().unwrap_err();
-    "///\r \n".parse::<TokenStream>().unwrap_err();
-    "/**\r \n*/".parse::<TokenStream>().unwrap_err();
-}
diff --git a/vendor/proc-macro2/tests/features.rs b/vendor/proc-macro2/tests/features.rs
deleted file mode 100644
index 073f6e60..00000000
--- a/vendor/proc-macro2/tests/features.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#[test]
-#[ignore]
-fn make_sure_no_proc_macro() {
-    assert!(
-        !cfg!(feature = "proc-macro"),
-        "still compiled with proc_macro?"
-    );
-}
diff --git a/vendor/proc-macro2/tests/marker.rs b/vendor/proc-macro2/tests/marker.rs
deleted file mode 100644
index 70e57677..00000000
--- a/vendor/proc-macro2/tests/marker.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use proc_macro2::*;
-
-macro_rules! assert_impl {
-    ($ty:ident is $($marker:ident) and +) => {
-        #[test]
-        #[allow(non_snake_case)]
-        fn $ty() {
-            fn assert_implemented<T: $($marker +)+>() {}
-            assert_implemented::<$ty>();
-        }
-    };
-
-    ($ty:ident is not $($marker:ident) or +) => {
-        #[test]
-        #[allow(non_snake_case)]
-        fn $ty() {
-            $(
-                {
-                    // Implemented for types that implement $marker.
-                    trait IsNotImplemented {
-                        fn assert_not_implemented() {}
-                    }
-                    impl<T: $marker> IsNotImplemented for T {}
-
-                    // Implemented for the type being tested.
-                    trait IsImplemented {
-                        fn assert_not_implemented() {}
-                    }
-                    impl IsImplemented for $ty {}
-
-                    // If $ty does not implement $marker, there is no ambiguity
-                    // in the following trait method call.
-                    <$ty>::assert_not_implemented();
-                }
-            )+
-        }
-    };
-}
-
-assert_impl!(Delimiter is Send and Sync);
-assert_impl!(Spacing is Send and Sync);
-
-assert_impl!(Group is not Send or Sync);
-assert_impl!(Ident is not Send or Sync);
-assert_impl!(LexError is not Send or Sync);
-assert_impl!(Literal is not Send or Sync);
-assert_impl!(Punct is not Send or Sync);
-assert_impl!(Span is not Send or Sync);
-assert_impl!(TokenStream is not Send or Sync);
-assert_impl!(TokenTree is not Send or Sync);
-
-#[cfg(procmacro2_semver_exempt)]
-mod semver_exempt {
-    use super::*;
-
-    assert_impl!(LineColumn is Send and Sync);
-
-    assert_impl!(SourceFile is not Send or Sync);
-}
-
-#[cfg(not(no_libprocmacro_unwind_safe))]
-mod unwind_safe {
-    use super::*;
-    use std::panic::{RefUnwindSafe, UnwindSafe};
-
-    macro_rules! assert_unwind_safe {
-        ($($types:ident)*) => {
-            $(
-                assert_impl!($types is UnwindSafe and RefUnwindSafe);
-            )*
-        };
-    }
-
-    assert_unwind_safe! {
-        Delimiter
-        Group
-        Ident
-        LexError
-        Literal
-        Punct
-        Spacing
-        Span
-        TokenStream
-        TokenTree
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    assert_unwind_safe! {
-        LineColumn
-        SourceFile
-    }
-}
diff --git a/vendor/proc-macro2/tests/test.rs b/vendor/proc-macro2/tests/test.rs
deleted file mode 100644
index 75a880f5..00000000
--- a/vendor/proc-macro2/tests/test.rs
+++ /dev/null
@@ -1,562 +0,0 @@
-use proc_macro2::{Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
-use std::panic;
-use std::str::{self, FromStr};
-
-#[test]
-fn idents() {
-    assert_eq!(
-        Ident::new("String", Span::call_site()).to_string(),
-        "String"
-    );
-    assert_eq!(Ident::new("fn", Span::call_site()).to_string(), "fn");
-    assert_eq!(Ident::new("_", Span::call_site()).to_string(), "_");
-}
-
-#[test]
-#[cfg(procmacro2_semver_exempt)]
-fn raw_idents() {
-    assert_eq!(
-        Ident::new_raw("String", Span::call_site()).to_string(),
-        "r#String"
-    );
-    assert_eq!(Ident::new_raw("fn", Span::call_site()).to_string(), "r#fn");
-    assert_eq!(Ident::new_raw("_", Span::call_site()).to_string(), "r#_");
-}
-
-#[test]
-#[should_panic(expected = "Ident is not allowed to be empty; use Option<Ident>")]
-fn ident_empty() {
-    Ident::new("", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "Ident cannot be a number; use Literal instead")]
-fn ident_number() {
-    Ident::new("255", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "\"a#\" is not a valid Ident")]
-fn ident_invalid() {
-    Ident::new("a#", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "not a valid Ident")]
-fn raw_ident_empty() {
-    Ident::new("r#", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "not a valid Ident")]
-fn raw_ident_number() {
-    Ident::new("r#255", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "\"r#a#\" is not a valid Ident")]
-fn raw_ident_invalid() {
-    Ident::new("r#a#", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "not a valid Ident")]
-fn lifetime_empty() {
-    Ident::new("'", Span::call_site());
-}
-
-#[test]
-#[should_panic(expected = "not a valid Ident")]
-fn lifetime_number() {
-    Ident::new("'255", Span::call_site());
-}
-
-#[test]
-fn lifetime_invalid() {
-    let result = panic::catch_unwind(|| Ident::new("'a#", Span::call_site()));
-    match result {
-        Err(box_any) => {
-            let message = box_any.downcast_ref::<String>().unwrap();
-            let expected1 = r#""\'a#" is not a valid Ident"#; // 1.31.0 .. 1.53.0
-            let expected2 = r#""'a#" is not a valid Ident"#; // 1.53.0 ..
-            assert!(
-                message == expected1 || message == expected2,
-                "panic message does not match expected string\n\
-                 \x20   panic message: `{:?}`\n\
-                 \x20expected message: `{:?}`",
-                message,
-                expected2,
-            );
-        }
-        Ok(_) => panic!("test did not panic as expected"),
-    }
-}
-
-#[test]
-fn literal_string() {
-    assert_eq!(Literal::string("foo").to_string(), "\"foo\"");
-    assert_eq!(Literal::string("\"").to_string(), "\"\\\"\"");
-    assert_eq!(Literal::string("didn't").to_string(), "\"didn't\"");
-}
-
-#[test]
-fn literal_raw_string() {
-    "r\"\r\n\"".parse::<TokenStream>().unwrap();
-}
-
-#[test]
-fn literal_character() {
-    assert_eq!(Literal::character('x').to_string(), "'x'");
-    assert_eq!(Literal::character('\'').to_string(), "'\\''");
-    assert_eq!(Literal::character('"').to_string(), "'\"'");
-}
-
-#[test]
-fn literal_float() {
-    assert_eq!(Literal::f32_unsuffixed(10.0).to_string(), "10.0");
-}
-
-#[test]
-fn literal_suffix() {
-    fn token_count(p: &str) -> usize {
-        p.parse::<TokenStream>().unwrap().into_iter().count()
-    }
-
-    assert_eq!(token_count("999u256"), 1);
-    assert_eq!(token_count("999r#u256"), 3);
-    assert_eq!(token_count("1."), 1);
-    assert_eq!(token_count("1.f32"), 3);
-    assert_eq!(token_count("1.0_0"), 1);
-    assert_eq!(token_count("1._0"), 3);
-    assert_eq!(token_count("1._m"), 3);
-    assert_eq!(token_count("\"\"s"), 1);
-    assert_eq!(token_count("r\"\"r"), 1);
-    assert_eq!(token_count("b\"\"b"), 1);
-    assert_eq!(token_count("br\"\"br"), 1);
-    assert_eq!(token_count("r#\"\"#r"), 1);
-    assert_eq!(token_count("'c'c"), 1);
-    assert_eq!(token_count("b'b'b"), 1);
-    assert_eq!(token_count("0E"), 1);
-    assert_eq!(token_count("0o0A"), 1);
-    assert_eq!(token_count("0E--0"), 4);
-    assert_eq!(token_count("0.0ECMA"), 1);
-}
-
-#[test]
-fn literal_iter_negative() {
-    let negative_literal = Literal::i32_suffixed(-3);
-    let tokens = TokenStream::from(TokenTree::Literal(negative_literal));
-    let mut iter = tokens.into_iter();
-    match iter.next().unwrap() {
-        TokenTree::Punct(punct) => {
-            assert_eq!(punct.as_char(), '-');
-            assert_eq!(punct.spacing(), Spacing::Alone);
-        }
-        unexpected => panic!("unexpected token {:?}", unexpected),
-    }
-    match iter.next().unwrap() {
-        TokenTree::Literal(literal) => {
-            assert_eq!(literal.to_string(), "3i32");
-        }
-        unexpected => panic!("unexpected token {:?}", unexpected),
-    }
-    assert!(iter.next().is_none());
-}
-
-#[test]
-fn literal_parse() {
-    assert!("1".parse::<Literal>().is_ok());
-    assert!("1.0".parse::<Literal>().is_ok());
-    assert!("'a'".parse::<Literal>().is_ok());
-    assert!("\"\n\"".parse::<Literal>().is_ok());
-    assert!("0 1".parse::<Literal>().is_err());
-    assert!(" 0".parse::<Literal>().is_err());
-    assert!("0 ".parse::<Literal>().is_err());
-    assert!("/* comment */0".parse::<Literal>().is_err());
-    assert!("0/* comment */".parse::<Literal>().is_err());
-    assert!("0// comment".parse::<Literal>().is_err());
-}
-
-#[test]
-fn roundtrip() {
-    fn roundtrip(p: &str) {
-        println!("parse: {}", p);
-        let s = p.parse::<TokenStream>().unwrap().to_string();
-        println!("first: {}", s);
-        let s2 = s.to_string().parse::<TokenStream>().unwrap().to_string();
-        assert_eq!(s, s2);
-    }
-    roundtrip("a");
-    roundtrip("<<");
-    roundtrip("<<=");
-    roundtrip(
-        "
-        1
-        1.0
-        1f32
-        2f64
-        1usize
-        4isize
-        4e10
-        1_000
-        1_0i32
-        8u8
-        9
-        0
-        0xffffffffffffffffffffffffffffffff
-        1x
-        1u80
-        1f320
-    ",
-    );
-    roundtrip("'a");
-    roundtrip("'_");
-    roundtrip("'static");
-    roundtrip("'\\u{10__FFFF}'");
-    roundtrip("\"\\u{10_F0FF__}foo\\u{1_0_0_0__}\"");
-}
-
-#[test]
-fn fail() {
-    fn fail(p: &str) {
-        if let Ok(s) = p.parse::<TokenStream>() {
-            panic!("should have failed to parse: {}\n{:#?}", p, s);
-        }
-    }
-    fail("' static");
-    fail("r#1");
-    fail("r#_");
-    fail("\"\\u{0000000}\""); // overlong unicode escape (rust allows at most 6 hex digits)
-    fail("\"\\u{999999}\""); // outside of valid range of char
-    fail("\"\\u{_0}\""); // leading underscore
-    fail("\"\\u{}\""); // empty
-    fail("b\"\r\""); // bare carriage return in byte string
-    fail("r\"\r\""); // bare carriage return in raw string
-    fail("\"\\\r  \""); // backslash carriage return
-    fail("'aa'aa");
-    fail("br##\"\"#");
-    fail("\"\\\n\u{85}\r\"");
-}
-
-#[cfg(span_locations)]
-#[test]
-fn span_test() {
-    check_spans(
-        "\
-/// This is a document comment
-testing 123
-{
-  testing 234
-}",
-        &[
-            (1, 0, 1, 30),  // #
-            (1, 0, 1, 30),  // [ ... ]
-            (1, 0, 1, 30),  // doc
-            (1, 0, 1, 30),  // =
-            (1, 0, 1, 30),  // "This is..."
-            (2, 0, 2, 7),   // testing
-            (2, 8, 2, 11),  // 123
-            (3, 0, 5, 1),   // { ... }
-            (4, 2, 4, 9),   // testing
-            (4, 10, 4, 13), // 234
-        ],
-    );
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[cfg(not(nightly))]
-#[test]
-fn default_span() {
-    let start = Span::call_site().start();
-    assert_eq!(start.line, 1);
-    assert_eq!(start.column, 0);
-    let end = Span::call_site().end();
-    assert_eq!(end.line, 1);
-    assert_eq!(end.column, 0);
-    let source_file = Span::call_site().source_file();
-    assert_eq!(source_file.path().to_string_lossy(), "<unspecified>");
-    assert!(!source_file.is_real());
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[test]
-fn span_join() {
-    let source1 = "aaa\nbbb"
-        .parse::<TokenStream>()
-        .unwrap()
-        .into_iter()
-        .collect::<Vec<_>>();
-    let source2 = "ccc\nddd"
-        .parse::<TokenStream>()
-        .unwrap()
-        .into_iter()
-        .collect::<Vec<_>>();
-
-    assert!(source1[0].span().source_file() != source2[0].span().source_file());
-    assert_eq!(
-        source1[0].span().source_file(),
-        source1[1].span().source_file()
-    );
-
-    let joined1 = source1[0].span().join(source1[1].span());
-    let joined2 = source1[0].span().join(source2[0].span());
-    assert!(joined1.is_some());
-    assert!(joined2.is_none());
-
-    let start = joined1.unwrap().start();
-    let end = joined1.unwrap().end();
-    assert_eq!(start.line, 1);
-    assert_eq!(start.column, 0);
-    assert_eq!(end.line, 2);
-    assert_eq!(end.column, 3);
-
-    assert_eq!(
-        joined1.unwrap().source_file(),
-        source1[0].span().source_file()
-    );
-}
-
-#[test]
-fn no_panic() {
-    let s = str::from_utf8(b"b\'\xc2\x86  \x00\x00\x00^\"").unwrap();
-    assert!(s.parse::<TokenStream>().is_err());
-}
-
-#[test]
-fn punct_before_comment() {
-    let mut tts = TokenStream::from_str("~// comment").unwrap().into_iter();
-    match tts.next().unwrap() {
-        TokenTree::Punct(tt) => {
-            assert_eq!(tt.as_char(), '~');
-            assert_eq!(tt.spacing(), Spacing::Alone);
-        }
-        wrong => panic!("wrong token {:?}", wrong),
-    }
-}
-
-#[test]
-fn joint_last_token() {
-    // This test verifies that we match the behavior of libproc_macro *not* in
-    // the range nightly-2020-09-06 through nightly-2020-09-10, in which this
-    // behavior was temporarily broken.
-    // See https://github.com/rust-lang/rust/issues/76399
-
-    let joint_punct = Punct::new(':', Spacing::Joint);
-    let stream = TokenStream::from(TokenTree::Punct(joint_punct));
-    let punct = match stream.into_iter().next().unwrap() {
-        TokenTree::Punct(punct) => punct,
-        _ => unreachable!(),
-    };
-    assert_eq!(punct.spacing(), Spacing::Joint);
-}
-
-#[test]
-fn raw_identifier() {
-    let mut tts = TokenStream::from_str("r#dyn").unwrap().into_iter();
-    match tts.next().unwrap() {
-        TokenTree::Ident(raw) => assert_eq!("r#dyn", raw.to_string()),
-        wrong => panic!("wrong token {:?}", wrong),
-    }
-    assert!(tts.next().is_none());
-}
-
-#[test]
-fn test_debug_ident() {
-    let ident = Ident::new("proc_macro", Span::call_site());
-
-    #[cfg(not(span_locations))]
-    let expected = "Ident(proc_macro)";
-
-    #[cfg(span_locations)]
-    let expected = "Ident { sym: proc_macro }";
-
-    assert_eq!(expected, format!("{:?}", ident));
-}
-
-#[test]
-fn test_debug_tokenstream() {
-    let tts = TokenStream::from_str("[a + 1]").unwrap();
-
-    #[cfg(not(span_locations))]
-    let expected = "\
-TokenStream [
-    Group {
-        delimiter: Bracket,
-        stream: TokenStream [
-            Ident {
-                sym: a,
-            },
-            Punct {
-                char: '+',
-                spacing: Alone,
-            },
-            Literal {
-                lit: 1,
-            },
-        ],
-    },
-]\
-    ";
-
-    #[cfg(not(span_locations))]
-    let expected_before_trailing_commas = "\
-TokenStream [
-    Group {
-        delimiter: Bracket,
-        stream: TokenStream [
-            Ident {
-                sym: a
-            },
-            Punct {
-                char: '+',
-                spacing: Alone
-            },
-            Literal {
-                lit: 1
-            }
-        ]
-    }
-]\
-    ";
-
-    #[cfg(span_locations)]
-    let expected = "\
-TokenStream [
-    Group {
-        delimiter: Bracket,
-        stream: TokenStream [
-            Ident {
-                sym: a,
-                span: bytes(2..3),
-            },
-            Punct {
-                char: '+',
-                spacing: Alone,
-                span: bytes(4..5),
-            },
-            Literal {
-                lit: 1,
-                span: bytes(6..7),
-            },
-        ],
-        span: bytes(1..8),
-    },
-]\
-    ";
-
-    #[cfg(span_locations)]
-    let expected_before_trailing_commas = "\
-TokenStream [
-    Group {
-        delimiter: Bracket,
-        stream: TokenStream [
-            Ident {
-                sym: a,
-                span: bytes(2..3)
-            },
-            Punct {
-                char: '+',
-                spacing: Alone,
-                span: bytes(4..5)
-            },
-            Literal {
-                lit: 1,
-                span: bytes(6..7)
-            }
-        ],
-        span: bytes(1..8)
-    }
-]\
-    ";
-
-    let actual = format!("{:#?}", tts);
-    if actual.ends_with(",\n]") {
-        assert_eq!(expected, actual);
-    } else {
-        assert_eq!(expected_before_trailing_commas, actual);
-    }
-}
-
-#[test]
-fn default_tokenstream_is_empty() {
-    let default_token_stream: TokenStream = Default::default();
-
-    assert!(default_token_stream.is_empty());
-}
-
-#[test]
-fn tuple_indexing() {
-    // This behavior may change depending on https://github.com/rust-lang/rust/pull/71322
-    let mut tokens = "tuple.0.0".parse::<TokenStream>().unwrap().into_iter();
-    assert_eq!("tuple", tokens.next().unwrap().to_string());
-    assert_eq!(".", tokens.next().unwrap().to_string());
-    assert_eq!("0.0", tokens.next().unwrap().to_string());
-    assert!(tokens.next().is_none());
-}
-
-#[cfg(span_locations)]
-#[test]
-fn non_ascii_tokens() {
-    check_spans("// abc", &[]);
-    check_spans("// ábc", &[]);
-    check_spans("// abc x", &[]);
-    check_spans("// ábc x", &[]);
-    check_spans("/* abc */ x", &[(1, 10, 1, 11)]);
-    check_spans("/* ábc */ x", &[(1, 10, 1, 11)]);
-    check_spans("/* ab\nc */ x", &[(2, 5, 2, 6)]);
-    check_spans("/* áb\nc */ x", &[(2, 5, 2, 6)]);
-    check_spans("/*** abc */ x", &[(1, 12, 1, 13)]);
-    check_spans("/*** ábc */ x", &[(1, 12, 1, 13)]);
-    check_spans(r#""abc""#, &[(1, 0, 1, 5)]);
-    check_spans(r#""ábc""#, &[(1, 0, 1, 5)]);
-    check_spans(r###"r#"abc"#"###, &[(1, 0, 1, 8)]);
-    check_spans(r###"r#"ábc"#"###, &[(1, 0, 1, 8)]);
-    check_spans("r#\"a\nc\"#", &[(1, 0, 2, 3)]);
-    check_spans("r#\"á\nc\"#", &[(1, 0, 2, 3)]);
-    check_spans("'a'", &[(1, 0, 1, 3)]);
-    check_spans("'á'", &[(1, 0, 1, 3)]);
-    check_spans("//! abc", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
-    check_spans("//! ábc", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
-    check_spans("//! abc\n", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
-    check_spans("//! ábc\n", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
-    check_spans("/*! abc */", &[(1, 0, 1, 10), (1, 0, 1, 10), (1, 0, 1, 10)]);
-    check_spans("/*! ábc */", &[(1, 0, 1, 10), (1, 0, 1, 10), (1, 0, 1, 10)]);
-    check_spans("/*! a\nc */", &[(1, 0, 2, 4), (1, 0, 2, 4), (1, 0, 2, 4)]);
-    check_spans("/*! á\nc */", &[(1, 0, 2, 4), (1, 0, 2, 4), (1, 0, 2, 4)]);
-    check_spans("abc", &[(1, 0, 1, 3)]);
-    check_spans("ábc", &[(1, 0, 1, 3)]);
-    check_spans("ábć", &[(1, 0, 1, 3)]);
-    check_spans("abc// foo", &[(1, 0, 1, 3)]);
-    check_spans("ábc// foo", &[(1, 0, 1, 3)]);
-    check_spans("ábć// foo", &[(1, 0, 1, 3)]);
-    check_spans("b\"a\\\n c\"", &[(1, 0, 2, 3)]);
-    check_spans("b\"a\\\n\u{00a0}c\"", &[(1, 0, 2, 3)]);
-}
-
-#[cfg(span_locations)]
-fn check_spans(p: &str, mut lines: &[(usize, usize, usize, usize)]) {
-    let ts = p.parse::<TokenStream>().unwrap();
-    check_spans_internal(ts, &mut lines);
-    assert!(lines.is_empty(), "leftover ranges: {:?}", lines);
-}
-
-#[cfg(span_locations)]
-fn check_spans_internal(ts: TokenStream, lines: &mut &[(usize, usize, usize, usize)]) {
-    for i in ts {
-        if let Some((&(sline, scol, eline, ecol), rest)) = lines.split_first() {
-            *lines = rest;
-
-            let start = i.span().start();
-            assert_eq!(start.line, sline, "sline did not match for {}", i);
-            assert_eq!(start.column, scol, "scol did not match for {}", i);
-
-            let end = i.span().end();
-            assert_eq!(end.line, eline, "eline did not match for {}", i);
-            assert_eq!(end.column, ecol, "ecol did not match for {}", i);
-
-            if let TokenTree::Group(g) = i {
-                check_spans_internal(g.stream().clone(), lines);
-            }
-        }
-    }
-}
diff --git a/vendor/proc-macro2/tests/test_fmt.rs b/vendor/proc-macro2/tests/test_fmt.rs
deleted file mode 100644
index 99a0aee5..00000000
--- a/vendor/proc-macro2/tests/test_fmt.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
-use std::iter::{self, FromIterator};
-
-#[test]
-fn test_fmt_group() {
-    let ident = Ident::new("x", Span::call_site());
-    let inner = TokenStream::from_iter(iter::once(TokenTree::Ident(ident)));
-    let parens_empty = Group::new(Delimiter::Parenthesis, TokenStream::new());
-    let parens_nonempty = Group::new(Delimiter::Parenthesis, inner.clone());
-    let brackets_empty = Group::new(Delimiter::Bracket, TokenStream::new());
-    let brackets_nonempty = Group::new(Delimiter::Bracket, inner.clone());
-    let braces_empty = Group::new(Delimiter::Brace, TokenStream::new());
-    let braces_nonempty = Group::new(Delimiter::Brace, inner.clone());
-    let none_empty = Group::new(Delimiter::None, TokenStream::new());
-    let none_nonempty = Group::new(Delimiter::None, inner.clone());
-
-    // Matches libproc_macro.
-    assert_eq!("()", parens_empty.to_string());
-    assert_eq!("(x)", parens_nonempty.to_string());
-    assert_eq!("[]", brackets_empty.to_string());
-    assert_eq!("[x]", brackets_nonempty.to_string());
-    assert_eq!("{ }", braces_empty.to_string());
-    assert_eq!("{ x }", braces_nonempty.to_string());
-    assert_eq!("", none_empty.to_string());
-    assert_eq!("x", none_nonempty.to_string());
-}
diff --git a/vendor/quote/.cargo-checksum.json b/vendor/quote/.cargo-checksum.json
deleted file mode 100644
index 768055df..00000000
--- a/vendor/quote/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"d1e6bb8b4ac54b84f367a4e1b46e7dca3b1a744017d8f7fa2f4c11a8730e657a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"9209682116de84bb9cc7be6ccf44478b46b909c7857f9e186d90bcff522af864","src/ext.rs":"a9fed3a1a4c9d3f2de717ba808af99291b995db2cbf8067f4b6927c39cc62bc6","src/format.rs":"a9c3e3a333c6dacf6e330d02b4c726862e273df1c2c6be6da199049cd1e521db","src/ident_fragment.rs":"e66a63f6e9020f2639a71f120d627bc6cfd60081a6caf8a1d735b59ee2413d29","src/lib.rs":"2500b1955d139e5b467df046cda4f2837fb1edace838aa190020752ab79314c4","src/runtime.rs":"f2d1fa6084764d98f98b96344cf675886a79b46a845c592e604f96bbde9aca07","src/spanned.rs":"adc0ed742ad17327c375879472d435cea168c208c303f53eb93cb2c0f10f3650","src/to_tokens.rs":"e589c1643479a9003d4dd1d9fa63714042b106f1b16d8ea3903cfe2f73a020f5","tests/compiletest.rs":"0a52a44786aea1c299c695bf948b2ed2081e4cc344e5c2cadceab4eb03d0010d","tests/test.rs":"6eb200350fa78405d4fd920ecf71d226e258c61aa88f850750efa99e065f06d6","tests/ui/does-not-have-iter-interpolated-dup.rs":"ad13eea21d4cdd2ab6c082f633392e1ff20fb0d1af5f2177041e0bf7f30da695","tests/ui/does-not-have-iter-interpolated.rs":"83a5b3f240651adcbe4b6e51076d76d653ad439b37442cf4054f1fd3c073f3b7","tests/ui/does-not-have-iter-separated.rs":"fe413c48331d5e3a7ae5fef6a5892a90c72f610d54595879eb49d0a94154ba3f","tests/ui/does-not-have-iter.rs":"09dc9499d861b63cebb0848b855b78e2dc9497bfde37ba6339f3625ae009a62f","tests/ui/not-quotable.rs":"5759d0884943417609f28faadc70254a3e2fd3d9bd6ff7297a3fb70a77fafd8a","tests/ui/not-repeatable.rs":"a4b115c04e4e41049a05f5b69450503fbffeba031218b4189cb931839f7f9a9c","tests/ui/wrong-type-span.rs":"5f310cb7fde3ef51bad01e7f286d244e3b6e67396cd2ea7eab77275c9d902699"},"package":"c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"}
\ No newline at end of file
diff --git a/vendor/quote/Cargo.toml b/vendor/quote/Cargo.toml
deleted file mode 100644
index 411f943a..00000000
--- a/vendor/quote/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "quote"
-version = "1.0.9"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-description = "Quasi-quoting macro quote!(...)"
-documentation = "https://docs.rs/quote/"
-readme = "README.md"
-keywords = ["syn"]
-categories = ["development-tools::procedural-macro-helpers"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/dtolnay/quote"
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-[dependencies.proc-macro2]
-version = "1.0.20"
-default-features = false
-[dev-dependencies.rustversion]
-version = "1.0"
-
-[dev-dependencies.trybuild]
-version = "1.0.19"
-features = ["diff"]
-
-[features]
-default = ["proc-macro"]
-proc-macro = ["proc-macro2/proc-macro"]
diff --git a/vendor/quote/LICENSE-APACHE b/vendor/quote/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/quote/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/quote/LICENSE-MIT b/vendor/quote/LICENSE-MIT
deleted file mode 100644
index 40b8817a..00000000
--- a/vendor/quote/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2016 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/quote/README.md b/vendor/quote/README.md
deleted file mode 100644
index 57b2a629..00000000
--- a/vendor/quote/README.md
+++ /dev/null
@@ -1,261 +0,0 @@
-Rust Quasi-Quoting
-==================
-
-[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/quote-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/quote)
-[<img alt="crates.io" src="https://img.shields.io/crates/v/quote.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/quote)
-[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-quote-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K" height="20">](https://docs.rs/quote)
-[<img alt="build status" src="https://img.shields.io/github/workflow/status/dtolnay/quote/CI/master?style=for-the-badge" height="20">](https://github.com/dtolnay/quote/actions?query=branch%3Amaster)
-
-This crate provides the [`quote!`] macro for turning Rust syntax tree data
-structures into tokens of source code.
-
-[`quote!`]: https://docs.rs/quote/1.0/quote/macro.quote.html
-
-Procedural macros in Rust receive a stream of tokens as input, execute arbitrary
-Rust code to determine how to manipulate those tokens, and produce a stream of
-tokens to hand back to the compiler to compile into the caller's crate.
-Quasi-quoting is a solution to one piece of that &mdash; producing tokens to
-return to the compiler.
-
-The idea of quasi-quoting is that we write *code* that we treat as *data*.
-Within the `quote!` macro, we can write what looks like code to our text editor
-or IDE. We get all the benefits of the editor's brace matching, syntax
-highlighting, indentation, and maybe autocompletion. But rather than compiling
-that as code into the current crate, we can treat it as data, pass it around,
-mutate it, and eventually hand it back to the compiler as tokens to compile into
-the macro caller's crate.
-
-This crate is motivated by the procedural macro use case, but is a
-general-purpose Rust quasi-quoting library and is not specific to procedural
-macros.
-
-```toml
-[dependencies]
-quote = "1.0"
-```
-
-*Version requirement: Quote supports rustc 1.31 and up.*<br>
-[*Release notes*](https://github.com/dtolnay/quote/releases)
-
-<br>
-
-## Syntax
-
-The quote crate provides a [`quote!`] macro within which you can write Rust code
-that gets packaged into a [`TokenStream`] and can be treated as data. You should
-think of `TokenStream` as representing a fragment of Rust source code.
-
-[`TokenStream`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.TokenStream.html
-
-Within the `quote!` macro, interpolation is done with `#var`. Any type
-implementing the [`quote::ToTokens`] trait can be interpolated. This includes
-most Rust primitive types as well as most of the syntax tree types from [`syn`].
-
-[`quote::ToTokens`]: https://docs.rs/quote/1.0/quote/trait.ToTokens.html
-[`syn`]: https://github.com/dtolnay/syn
-
-```rust
-let tokens = quote! {
-    struct SerializeWith #generics #where_clause {
-        value: &'a #field_ty,
-        phantom: core::marker::PhantomData<#item_ty>,
-    }
-
-    impl #generics serde::Serialize for SerializeWith #generics #where_clause {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            #path(self.value, serializer)
-        }
-    }
-
-    SerializeWith {
-        value: #value,
-        phantom: core::marker::PhantomData::<#item_ty>,
-    }
-};
-```
-
-<br>
-
-## Repetition
-
-Repetition is done using `#(...)*` or `#(...),*` similar to `macro_rules!`. This
-iterates through the elements of any variable interpolated within the repetition
-and inserts a copy of the repetition body for each one. The variables in an
-interpolation may be anything that implements `IntoIterator`, including `Vec` or
-a pre-existing iterator.
-
-- `#(#var)*` — no separators
-- `#(#var),*` — the character before the asterisk is used as a separator
-- `#( struct #var; )*` — the repetition can contain other things
-- `#( #k => println!("{}", #v), )*` — even multiple interpolations
-
-Note that there is a difference between `#(#var ,)*` and `#(#var),*`—the latter
-does not produce a trailing comma. This matches the behavior of delimiters in
-`macro_rules!`.
-
-<br>
-
-## Returning tokens to the compiler
-
-The `quote!` macro evaluates to an expression of type
-`proc_macro2::TokenStream`. Meanwhile Rust procedural macros are expected to
-return the type `proc_macro::TokenStream`.
-
-The difference between the two types is that `proc_macro` types are entirely
-specific to procedural macros and cannot ever exist in code outside of a
-procedural macro, while `proc_macro2` types may exist anywhere including tests
-and non-macro code like main.rs and build.rs. This is why even the procedural
-macro ecosystem is largely built around `proc_macro2`, because that ensures the
-libraries are unit testable and accessible in non-macro contexts.
-
-There is a [`From`]-conversion in both directions so returning the output of
-`quote!` from a procedural macro usually looks like `tokens.into()` or
-`proc_macro::TokenStream::from(tokens)`.
-
-[`From`]: https://doc.rust-lang.org/std/convert/trait.From.html
-
-<br>
-
-## Examples
-
-### Combining quoted fragments
-
-Usually you don't end up constructing an entire final `TokenStream` in one
-piece. Different parts may come from different helper functions. The tokens
-produced by `quote!` themselves implement `ToTokens` and so can be interpolated
-into later `quote!` invocations to build up a final result.
-
-```rust
-let type_definition = quote! {...};
-let methods = quote! {...};
-
-let tokens = quote! {
-    #type_definition
-    #methods
-};
-```
-
-### Constructing identifiers
-
-Suppose we have an identifier `ident` which came from somewhere in a macro
-input and we need to modify it in some way for the macro output. Let's consider
-prepending the identifier with an underscore.
-
-Simply interpolating the identifier next to an underscore will not have the
-behavior of concatenating them. The underscore and the identifier will continue
-to be two separate tokens as if you had written `_ x`.
-
-```rust
-// incorrect
-quote! {
-    let mut _#ident = 0;
-}
-```
-
-The solution is to build a new identifier token with the correct value. As this
-is such a common case, the `format_ident!` macro provides a convenient utility
-for doing so correctly.
-
-```rust
-let varname = format_ident!("_{}", ident);
-quote! {
-    let mut #varname = 0;
-}
-```
-
-Alternatively, the APIs provided by Syn and proc-macro2 can be used to directly
-build the identifier. This is roughly equivalent to the above, but will not
-handle `ident` being a raw identifier.
-
-```rust
-let concatenated = format!("_{}", ident);
-let varname = syn::Ident::new(&concatenated, ident.span());
-quote! {
-    let mut #varname = 0;
-}
-```
-
-### Making method calls
-
-Let's say our macro requires some type specified in the macro input to have a
-constructor called `new`. We have the type in a variable called `field_type` of
-type `syn::Type` and want to invoke the constructor.
-
-```rust
-// incorrect
-quote! {
-    let value = #field_type::new();
-}
-```
-
-This works only sometimes. If `field_type` is `String`, the expanded code
-contains `String::new()` which is fine. But if `field_type` is something like
-`Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid syntax.
-Ordinarily in handwritten Rust we would write `Vec::<i32>::new()` but for macros
-often the following is more convenient.
-
-```rust
-quote! {
-    let value = <#field_type>::new();
-}
-```
-
-This expands to `<Vec<i32>>::new()` which behaves correctly.
-
-A similar pattern is appropriate for trait methods.
-
-```rust
-quote! {
-    let value = <#field_type as core::default::Default>::default();
-}
-```
-
-<br>
-
-## Hygiene
-
-Any interpolated tokens preserve the `Span` information provided by their
-`ToTokens` implementation. Tokens that originate within a `quote!` invocation
-are spanned with [`Span::call_site()`].
-
-[`Span::call_site()`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html#method.call_site
-
-A different span can be provided explicitly through the [`quote_spanned!`]
-macro.
-
-[`quote_spanned!`]: https://docs.rs/quote/1.0/quote/macro.quote_spanned.html
-
-<br>
-
-## Non-macro code generators
-
-When using `quote` in a build.rs or main.rs and writing the output out to a
-file, consider having the code generator pass the tokens through [rustfmt]
-before writing (either by shelling out to the `rustfmt` binary or by pulling in
-the `rustfmt` library as a dependency). This way if an error occurs in the
-generated code it is convenient for a human to read and debug.
-
-Be aware that no kind of hygiene or span information is retained when tokens are
-written to a file; the conversion from tokens to source code is lossy.
-
-[rustfmt]: https://github.com/rust-lang/rustfmt
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/quote/src/ext.rs b/vendor/quote/src/ext.rs
deleted file mode 100644
index 9e9b4a50..00000000
--- a/vendor/quote/src/ext.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use super::ToTokens;
-
-use std::iter;
-
-use proc_macro2::{TokenStream, TokenTree};
-
-/// TokenStream extension trait with methods for appending tokens.
-///
-/// This trait is sealed and cannot be implemented outside of the `quote` crate.
-pub trait TokenStreamExt: private::Sealed {
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends the token specified to this list of tokens.
-    fn append<U>(&mut self, token: U)
-    where
-        U: Into<TokenTree>;
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// ```
-    /// # use quote::{quote, TokenStreamExt, ToTokens};
-    /// # use proc_macro2::TokenStream;
-    /// #
-    /// struct X;
-    ///
-    /// impl ToTokens for X {
-    ///     fn to_tokens(&self, tokens: &mut TokenStream) {
-    ///         tokens.append_all(&[true, false]);
-    ///     }
-    /// }
-    ///
-    /// let tokens = quote!(#X);
-    /// assert_eq!(tokens.to_string(), "true false");
-    /// ```
-    fn append_all<I>(&mut self, iter: I)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens;
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all of the items in the iterator `I`, separated by the tokens
-    /// `U`.
-    fn append_separated<I, U>(&mut self, iter: I, op: U)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens,
-        U: ToTokens;
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all tokens in the iterator `I`, appending `U` after each
-    /// element, including after the last element of the iterator.
-    fn append_terminated<I, U>(&mut self, iter: I, term: U)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens,
-        U: ToTokens;
-}
-
-impl TokenStreamExt for TokenStream {
-    fn append<U>(&mut self, token: U)
-    where
-        U: Into<TokenTree>,
-    {
-        self.extend(iter::once(token.into()));
-    }
-
-    fn append_all<I>(&mut self, iter: I)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens,
-    {
-        for token in iter {
-            token.to_tokens(self);
-        }
-    }
-
-    fn append_separated<I, U>(&mut self, iter: I, op: U)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens,
-        U: ToTokens,
-    {
-        for (i, token) in iter.into_iter().enumerate() {
-            if i > 0 {
-                op.to_tokens(self);
-            }
-            token.to_tokens(self);
-        }
-    }
-
-    fn append_terminated<I, U>(&mut self, iter: I, term: U)
-    where
-        I: IntoIterator,
-        I::Item: ToTokens,
-        U: ToTokens,
-    {
-        for token in iter {
-            token.to_tokens(self);
-            term.to_tokens(self);
-        }
-    }
-}
-
-mod private {
-    use proc_macro2::TokenStream;
-
-    pub trait Sealed {}
-
-    impl Sealed for TokenStream {}
-}
diff --git a/vendor/quote/src/format.rs b/vendor/quote/src/format.rs
deleted file mode 100644
index 745cb5d2..00000000
--- a/vendor/quote/src/format.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-/// Formatting macro for constructing `Ident`s.
-///
-/// <br>
-///
-/// # Syntax
-///
-/// Syntax is copied from the [`format!`] macro, supporting both positional and
-/// named arguments.
-///
-/// Only a limited set of formatting traits are supported. The current mapping
-/// of format types to traits is:
-///
-/// * `{}` ⇒ [`IdentFragment`]
-/// * `{:o}` ⇒ [`Octal`](`std::fmt::Octal`)
-/// * `{:x}` ⇒ [`LowerHex`](`std::fmt::LowerHex`)
-/// * `{:X}` ⇒ [`UpperHex`](`std::fmt::UpperHex`)
-/// * `{:b}` ⇒ [`Binary`](`std::fmt::Binary`)
-///
-/// See [`std::fmt`] for more information.
-///
-/// <br>
-///
-/// # IdentFragment
-///
-/// Unlike `format!`, this macro uses the [`IdentFragment`] formatting trait by
-/// default. This trait is like `Display`, with a few differences:
-///
-/// * `IdentFragment` is only implemented for a limited set of types, such as
-///    unsigned integers and strings.
-/// * [`Ident`] arguments will have their `r#` prefixes stripped, if present.
-///
-/// [`Ident`]: `proc_macro2::Ident`
-///
-/// <br>
-///
-/// # Hygiene
-///
-/// The [`Span`] of the first `Ident` argument is used as the span of the final
-/// identifier, falling back to [`Span::call_site`] when no identifiers are
-/// provided.
-///
-/// ```
-/// # use quote::format_ident;
-/// # let ident = format_ident!("Ident");
-/// // If `ident` is an Ident, the span of `my_ident` will be inherited from it.
-/// let my_ident = format_ident!("My{}{}", ident, "IsCool");
-/// assert_eq!(my_ident, "MyIdentIsCool");
-/// ```
-///
-/// Alternatively, the span can be overridden by passing the `span` named
-/// argument.
-///
-/// ```
-/// # use quote::format_ident;
-/// # const IGNORE_TOKENS: &'static str = stringify! {
-/// let my_span = /* ... */;
-/// # };
-/// # let my_span = proc_macro2::Span::call_site();
-/// format_ident!("MyIdent", span = my_span);
-/// ```
-///
-/// [`Span`]: `proc_macro2::Span`
-/// [`Span::call_site`]: `proc_macro2::Span::call_site`
-///
-/// <p><br></p>
-///
-/// # Panics
-///
-/// This method will panic if the resulting formatted string is not a valid
-/// identifier.
-///
-/// <br>
-///
-/// # Examples
-///
-/// Composing raw and non-raw identifiers:
-/// ```
-/// # use quote::format_ident;
-/// let my_ident = format_ident!("My{}", "Ident");
-/// assert_eq!(my_ident, "MyIdent");
-///
-/// let raw = format_ident!("r#Raw");
-/// assert_eq!(raw, "r#Raw");
-///
-/// let my_ident_raw = format_ident!("{}Is{}", my_ident, raw);
-/// assert_eq!(my_ident_raw, "MyIdentIsRaw");
-/// ```
-///
-/// Integer formatting options:
-/// ```
-/// # use quote::format_ident;
-/// let num: u32 = 10;
-///
-/// let decimal = format_ident!("Id_{}", num);
-/// assert_eq!(decimal, "Id_10");
-///
-/// let octal = format_ident!("Id_{:o}", num);
-/// assert_eq!(octal, "Id_12");
-///
-/// let binary = format_ident!("Id_{:b}", num);
-/// assert_eq!(binary, "Id_1010");
-///
-/// let lower_hex = format_ident!("Id_{:x}", num);
-/// assert_eq!(lower_hex, "Id_a");
-///
-/// let upper_hex = format_ident!("Id_{:X}", num);
-/// assert_eq!(upper_hex, "Id_A");
-/// ```
-#[macro_export]
-macro_rules! format_ident {
-    ($fmt:expr) => {
-        $crate::format_ident_impl!([
-            ::std::option::Option::None,
-            $fmt
-        ])
-    };
-
-    ($fmt:expr, $($rest:tt)*) => {
-        $crate::format_ident_impl!([
-            ::std::option::Option::None,
-            $fmt
-        ] $($rest)*)
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! format_ident_impl {
-    // Final state
-    ([$span:expr, $($fmt:tt)*]) => {
-        $crate::__private::mk_ident(&format!($($fmt)*), $span)
-    };
-
-    // Span argument
-    ([$old:expr, $($fmt:tt)*] span = $span:expr) => {
-        $crate::format_ident_impl!([$old, $($fmt)*] span = $span,)
-    };
-    ([$old:expr, $($fmt:tt)*] span = $span:expr, $($rest:tt)*) => {
-        $crate::format_ident_impl!([
-            ::std::option::Option::Some::<$crate::__private::Span>($span),
-            $($fmt)*
-        ] $($rest)*)
-    };
-
-    // Named argument
-    ([$span:expr, $($fmt:tt)*] $name:ident = $arg:expr) => {
-        $crate::format_ident_impl!([$span, $($fmt)*] $name = $arg,)
-    };
-    ([$span:expr, $($fmt:tt)*] $name:ident = $arg:expr, $($rest:tt)*) => {
-        match $crate::__private::IdentFragmentAdapter(&$arg) {
-            arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt)*, $name = arg] $($rest)*),
-        }
-    };
-
-    // Positional argument
-    ([$span:expr, $($fmt:tt)*] $arg:expr) => {
-        $crate::format_ident_impl!([$span, $($fmt)*] $arg,)
-    };
-    ([$span:expr, $($fmt:tt)*] $arg:expr, $($rest:tt)*) => {
-        match $crate::__private::IdentFragmentAdapter(&$arg) {
-            arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt)*, arg] $($rest)*),
-        }
-    };
-}
diff --git a/vendor/quote/src/ident_fragment.rs b/vendor/quote/src/ident_fragment.rs
deleted file mode 100644
index e7472fe1..00000000
--- a/vendor/quote/src/ident_fragment.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use proc_macro2::{Ident, Span};
-use std::borrow::Cow;
-use std::fmt;
-
-/// Specialized formatting trait used by `format_ident!`.
-///
-/// [`Ident`] arguments formatted using this trait will have their `r#` prefix
-/// stripped, if present.
-///
-/// See [`format_ident!`] for more information.
-pub trait IdentFragment {
-    /// Format this value as an identifier fragment.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result;
-
-    /// Span associated with this `IdentFragment`.
-    ///
-    /// If non-`None`, may be inherited by formatted identifiers.
-    fn span(&self) -> Option<Span> {
-        None
-    }
-}
-
-impl<T: IdentFragment + ?Sized> IdentFragment for &T {
-    fn span(&self) -> Option<Span> {
-        <T as IdentFragment>::span(*self)
-    }
-
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        IdentFragment::fmt(*self, f)
-    }
-}
-
-impl<T: IdentFragment + ?Sized> IdentFragment for &mut T {
-    fn span(&self) -> Option<Span> {
-        <T as IdentFragment>::span(*self)
-    }
-
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        IdentFragment::fmt(*self, f)
-    }
-}
-
-impl IdentFragment for Ident {
-    fn span(&self) -> Option<Span> {
-        Some(self.span())
-    }
-
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let id = self.to_string();
-        if id.starts_with("r#") {
-            fmt::Display::fmt(&id[2..], f)
-        } else {
-            fmt::Display::fmt(&id[..], f)
-        }
-    }
-}
-
-impl<T> IdentFragment for Cow<'_, T>
-where
-    T: IdentFragment + ToOwned + ?Sized,
-{
-    fn span(&self) -> Option<Span> {
-        T::span(self)
-    }
-
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        T::fmt(self, f)
-    }
-}
-
-// Limited set of types which this is implemented for, as we want to avoid types
-// which will often include non-identifier characters in their `Display` impl.
-macro_rules! ident_fragment_display {
-    ($($T:ty),*) => {
-        $(
-            impl IdentFragment for $T {
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    fmt::Display::fmt(self, f)
-                }
-            }
-        )*
-    }
-}
-
-ident_fragment_display!(bool, str, String, char);
-ident_fragment_display!(u8, u16, u32, u64, u128, usize);
diff --git a/vendor/quote/src/lib.rs b/vendor/quote/src/lib.rs
deleted file mode 100644
index 356e43a0..00000000
--- a/vendor/quote/src/lib.rs
+++ /dev/null
@@ -1,1267 +0,0 @@
-//! [![github]](https://github.com/dtolnay/quote)&ensp;[![crates-io]](https://crates.io/crates/quote)&ensp;[![docs-rs]](https://docs.rs/quote)
-//!
-//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
-//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
-//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K
-//!
-//! <br>
-//!
-//! This crate provides the [`quote!`] macro for turning Rust syntax tree data
-//! structures into tokens of source code.
-//!
-//! [`quote!`]: macro.quote.html
-//!
-//! Procedural macros in Rust receive a stream of tokens as input, execute
-//! arbitrary Rust code to determine how to manipulate those tokens, and produce
-//! a stream of tokens to hand back to the compiler to compile into the caller's
-//! crate. Quasi-quoting is a solution to one piece of that &mdash; producing
-//! tokens to return to the compiler.
-//!
-//! The idea of quasi-quoting is that we write *code* that we treat as *data*.
-//! Within the `quote!` macro, we can write what looks like code to our text
-//! editor or IDE. We get all the benefits of the editor's brace matching,
-//! syntax highlighting, indentation, and maybe autocompletion. But rather than
-//! compiling that as code into the current crate, we can treat it as data, pass
-//! it around, mutate it, and eventually hand it back to the compiler as tokens
-//! to compile into the macro caller's crate.
-//!
-//! This crate is motivated by the procedural macro use case, but is a
-//! general-purpose Rust quasi-quoting library and is not specific to procedural
-//! macros.
-//!
-//! ```toml
-//! [dependencies]
-//! quote = "1.0"
-//! ```
-//!
-//! <br>
-//!
-//! # Example
-//!
-//! The following quasi-quoted block of code is something you might find in [a]
-//! procedural macro having to do with data structure serialization. The `#var`
-//! syntax performs interpolation of runtime variables into the quoted tokens.
-//! Check out the documentation of the [`quote!`] macro for more detail about
-//! the syntax. See also the [`quote_spanned!`] macro which is important for
-//! implementing hygienic procedural macros.
-//!
-//! [a]: https://serde.rs/
-//! [`quote_spanned!`]: macro.quote_spanned.html
-//!
-//! ```
-//! # use quote::quote;
-//! #
-//! # let generics = "";
-//! # let where_clause = "";
-//! # let field_ty = "";
-//! # let item_ty = "";
-//! # let path = "";
-//! # let value = "";
-//! #
-//! let tokens = quote! {
-//!     struct SerializeWith #generics #where_clause {
-//!         value: &'a #field_ty,
-//!         phantom: core::marker::PhantomData<#item_ty>,
-//!     }
-//!
-//!     impl #generics serde::Serialize for SerializeWith #generics #where_clause {
-//!         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-//!         where
-//!             S: serde::Serializer,
-//!         {
-//!             #path(self.value, serializer)
-//!         }
-//!     }
-//!
-//!     SerializeWith {
-//!         value: #value,
-//!         phantom: core::marker::PhantomData::<#item_ty>,
-//!     }
-//! };
-//! ```
-
-// Quote types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/quote/1.0.9")]
-#![allow(
-    clippy::doc_markdown,
-    clippy::missing_errors_doc,
-    clippy::missing_panics_doc,
-    clippy::module_name_repetitions
-)]
-
-#[cfg(all(
-    not(all(target_arch = "wasm32", target_os = "unknown")),
-    feature = "proc-macro"
-))]
-extern crate proc_macro;
-
-mod ext;
-mod format;
-mod ident_fragment;
-mod to_tokens;
-
-// Not public API.
-#[doc(hidden)]
-#[path = "runtime.rs"]
-pub mod __private;
-
-pub use crate::ext::TokenStreamExt;
-pub use crate::ident_fragment::IdentFragment;
-pub use crate::to_tokens::ToTokens;
-
-// Not public API.
-#[doc(hidden)]
-pub mod spanned;
-
-/// The whole point.
-///
-/// Performs variable interpolation against the input and produces it as
-/// [`proc_macro2::TokenStream`].
-///
-/// Note: for returning tokens to the compiler in a procedural macro, use
-/// `.into()` on the result to convert to [`proc_macro::TokenStream`].
-///
-/// [`TokenStream`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.TokenStream.html
-///
-/// <br>
-///
-/// # Interpolation
-///
-/// Variable interpolation is done with `#var` (similar to `$var` in
-/// `macro_rules!` macros). This grabs the `var` variable that is currently in
-/// scope and inserts it in that location in the output tokens. Any type
-/// implementing the [`ToTokens`] trait can be interpolated. This includes most
-/// Rust primitive types as well as most of the syntax tree types from the [Syn]
-/// crate.
-///
-/// [`ToTokens`]: trait.ToTokens.html
-/// [Syn]: https://github.com/dtolnay/syn
-///
-/// Repetition is done using `#(...)*` or `#(...),*` again similar to
-/// `macro_rules!`. This iterates through the elements of any variable
-/// interpolated within the repetition and inserts a copy of the repetition body
-/// for each one. The variables in an interpolation may be a `Vec`, slice,
-/// `BTreeSet`, or any `Iterator`.
-///
-/// - `#(#var)*` — no separators
-/// - `#(#var),*` — the character before the asterisk is used as a separator
-/// - `#( struct #var; )*` — the repetition can contain other tokens
-/// - `#( #k => println!("{}", #v), )*` — even multiple interpolations
-///
-/// <br>
-///
-/// # Hygiene
-///
-/// Any interpolated tokens preserve the `Span` information provided by their
-/// `ToTokens` implementation. Tokens that originate within the `quote!`
-/// invocation are spanned with [`Span::call_site()`].
-///
-/// [`Span::call_site()`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html#method.call_site
-///
-/// A different span can be provided through the [`quote_spanned!`] macro.
-///
-/// [`quote_spanned!`]: macro.quote_spanned.html
-///
-/// <br>
-///
-/// # Return type
-///
-/// The macro evaluates to an expression of type `proc_macro2::TokenStream`.
-/// Meanwhile Rust procedural macros are expected to return the type
-/// `proc_macro::TokenStream`.
-///
-/// The difference between the two types is that `proc_macro` types are entirely
-/// specific to procedural macros and cannot ever exist in code outside of a
-/// procedural macro, while `proc_macro2` types may exist anywhere including
-/// tests and non-macro code like main.rs and build.rs. This is why even the
-/// procedural macro ecosystem is largely built around `proc_macro2`, because
-/// that ensures the libraries are unit testable and accessible in non-macro
-/// contexts.
-///
-/// There is a [`From`]-conversion in both directions so returning the output of
-/// `quote!` from a procedural macro usually looks like `tokens.into()` or
-/// `proc_macro::TokenStream::from(tokens)`.
-///
-/// [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html
-///
-/// <br>
-///
-/// # Examples
-///
-/// ### Procedural macro
-///
-/// The structure of a basic procedural macro is as follows. Refer to the [Syn]
-/// crate for further useful guidance on using `quote!` as part of a procedural
-/// macro.
-///
-/// [Syn]: https://github.com/dtolnay/syn
-///
-/// ```
-/// # #[cfg(any())]
-/// extern crate proc_macro;
-/// # extern crate proc_macro2;
-///
-/// # #[cfg(any())]
-/// use proc_macro::TokenStream;
-/// # use proc_macro2::TokenStream;
-/// use quote::quote;
-///
-/// # const IGNORE_TOKENS: &'static str = stringify! {
-/// #[proc_macro_derive(HeapSize)]
-/// # };
-/// pub fn derive_heap_size(input: TokenStream) -> TokenStream {
-///     // Parse the input and figure out what implementation to generate...
-///     # const IGNORE_TOKENS: &'static str = stringify! {
-///     let name = /* ... */;
-///     let expr = /* ... */;
-///     # };
-///     #
-///     # let name = 0;
-///     # let expr = 0;
-///
-///     let expanded = quote! {
-///         // The generated impl.
-///         impl heapsize::HeapSize for #name {
-///             fn heap_size_of_children(&self) -> usize {
-///                 #expr
-///             }
-///         }
-///     };
-///
-///     // Hand the output tokens back to the compiler.
-///     TokenStream::from(expanded)
-/// }
-/// ```
-///
-/// <p><br></p>
-///
-/// ### Combining quoted fragments
-///
-/// Usually you don't end up constructing an entire final `TokenStream` in one
-/// piece. Different parts may come from different helper functions. The tokens
-/// produced by `quote!` themselves implement `ToTokens` and so can be
-/// interpolated into later `quote!` invocations to build up a final result.
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// let type_definition = quote! {...};
-/// let methods = quote! {...};
-///
-/// let tokens = quote! {
-///     #type_definition
-///     #methods
-/// };
-/// ```
-///
-/// <p><br></p>
-///
-/// ### Constructing identifiers
-///
-/// Suppose we have an identifier `ident` which came from somewhere in a macro
-/// input and we need to modify it in some way for the macro output. Let's
-/// consider prepending the identifier with an underscore.
-///
-/// Simply interpolating the identifier next to an underscore will not have the
-/// behavior of concatenating them. The underscore and the identifier will
-/// continue to be two separate tokens as if you had written `_ x`.
-///
-/// ```
-/// # use proc_macro2::{self as syn, Span};
-/// # use quote::quote;
-/// #
-/// # let ident = syn::Ident::new("i", Span::call_site());
-/// #
-/// // incorrect
-/// quote! {
-///     let mut _#ident = 0;
-/// }
-/// # ;
-/// ```
-///
-/// The solution is to build a new identifier token with the correct value. As
-/// this is such a common case, the [`format_ident!`] macro provides a
-/// convenient utility for doing so correctly.
-///
-/// ```
-/// # use proc_macro2::{Ident, Span};
-/// # use quote::{format_ident, quote};
-/// #
-/// # let ident = Ident::new("i", Span::call_site());
-/// #
-/// let varname = format_ident!("_{}", ident);
-/// quote! {
-///     let mut #varname = 0;
-/// }
-/// # ;
-/// ```
-///
-/// Alternatively, the APIs provided by Syn and proc-macro2 can be used to
-/// directly build the identifier. This is roughly equivalent to the above, but
-/// will not handle `ident` being a raw identifier.
-///
-/// ```
-/// # use proc_macro2::{self as syn, Span};
-/// # use quote::quote;
-/// #
-/// # let ident = syn::Ident::new("i", Span::call_site());
-/// #
-/// let concatenated = format!("_{}", ident);
-/// let varname = syn::Ident::new(&concatenated, ident.span());
-/// quote! {
-///     let mut #varname = 0;
-/// }
-/// # ;
-/// ```
-///
-/// <p><br></p>
-///
-/// ### Making method calls
-///
-/// Let's say our macro requires some type specified in the macro input to have
-/// a constructor called `new`. We have the type in a variable called
-/// `field_type` of type `syn::Type` and want to invoke the constructor.
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// # let field_type = quote!(...);
-/// #
-/// // incorrect
-/// quote! {
-///     let value = #field_type::new();
-/// }
-/// # ;
-/// ```
-///
-/// This works only sometimes. If `field_type` is `String`, the expanded code
-/// contains `String::new()` which is fine. But if `field_type` is something
-/// like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid
-/// syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()`
-/// but for macros often the following is more convenient.
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// # let field_type = quote!(...);
-/// #
-/// quote! {
-///     let value = <#field_type>::new();
-/// }
-/// # ;
-/// ```
-///
-/// This expands to `<Vec<i32>>::new()` which behaves correctly.
-///
-/// A similar pattern is appropriate for trait methods.
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// # let field_type = quote!(...);
-/// #
-/// quote! {
-///     let value = <#field_type as core::default::Default>::default();
-/// }
-/// # ;
-/// ```
-///
-/// <p><br></p>
-///
-/// ### Interpolating text inside of doc comments
-///
-/// Neither doc comments nor string literals get interpolation behavior in
-/// quote:
-///
-/// ```compile_fail
-/// quote! {
-///     /// try to interpolate: #ident
-///     ///
-///     /// ...
-/// }
-/// ```
-///
-/// ```compile_fail
-/// quote! {
-///     #[doc = "try to interpolate: #ident"]
-/// }
-/// ```
-///
-/// Macro calls in a doc attribute are not valid syntax:
-///
-/// ```compile_fail
-/// quote! {
-///     #[doc = concat!("try to interpolate: ", stringify!(#ident))]
-/// }
-/// ```
-///
-/// Instead the best way to build doc comments that involve variables is by
-/// formatting the doc string literal outside of quote.
-///
-/// ```rust
-/// # use proc_macro2::{Ident, Span};
-/// # use quote::quote;
-/// #
-/// # const IGNORE: &str = stringify! {
-/// let msg = format!(...);
-/// # };
-/// #
-/// # let ident = Ident::new("var", Span::call_site());
-/// # let msg = format!("try to interpolate: {}", ident);
-/// quote! {
-///     #[doc = #msg]
-///     ///
-///     /// ...
-/// }
-/// # ;
-/// ```
-///
-/// <p><br></p>
-///
-/// ### Indexing into a tuple struct
-///
-/// When interpolating indices of a tuple or tuple struct, we need them not to
-/// appears suffixed as integer literals by interpolating them as [`syn::Index`]
-/// instead.
-///
-/// [`syn::Index`]: https://docs.rs/syn/1.0/syn/struct.Index.html
-///
-/// ```compile_fail
-/// let i = 0usize..self.fields.len();
-///
-/// // expands to 0 + self.0usize.heap_size() + self.1usize.heap_size() + ...
-/// // which is not valid syntax
-/// quote! {
-///     0 #( + self.#i.heap_size() )*
-/// }
-/// ```
-///
-/// ```
-/// # use proc_macro2::{Ident, TokenStream};
-/// # use quote::quote;
-/// #
-/// # mod syn {
-/// #     use proc_macro2::{Literal, TokenStream};
-/// #     use quote::{ToTokens, TokenStreamExt};
-/// #
-/// #     pub struct Index(usize);
-/// #
-/// #     impl From<usize> for Index {
-/// #         fn from(i: usize) -> Self {
-/// #             Index(i)
-/// #         }
-/// #     }
-/// #
-/// #     impl ToTokens for Index {
-/// #         fn to_tokens(&self, tokens: &mut TokenStream) {
-/// #             tokens.append(Literal::usize_unsuffixed(self.0));
-/// #         }
-/// #     }
-/// # }
-/// #
-/// # struct Struct {
-/// #     fields: Vec<Ident>,
-/// # }
-/// #
-/// # impl Struct {
-/// #     fn example(&self) -> TokenStream {
-/// let i = (0..self.fields.len()).map(syn::Index::from);
-///
-/// // expands to 0 + self.0.heap_size() + self.1.heap_size() + ...
-/// quote! {
-///     0 #( + self.#i.heap_size() )*
-/// }
-/// #     }
-/// # }
-/// ```
-#[macro_export]
-macro_rules! quote {
-    () => {
-        $crate::__private::TokenStream::new()
-    };
-    ($($tt:tt)*) => {{
-        let mut _s = $crate::__private::TokenStream::new();
-        $crate::quote_each_token!(_s $($tt)*);
-        _s
-    }};
-}
-
-/// Same as `quote!`, but applies a given span to all tokens originating within
-/// the macro invocation.
-///
-/// <br>
-///
-/// # Syntax
-///
-/// A span expression of type [`Span`], followed by `=>`, followed by the tokens
-/// to quote. The span expression should be brief &mdash; use a variable for
-/// anything more than a few characters. There should be no space before the
-/// `=>` token.
-///
-/// [`Span`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html
-///
-/// ```
-/// # use proc_macro2::Span;
-/// # use quote::quote_spanned;
-/// #
-/// # const IGNORE_TOKENS: &'static str = stringify! {
-/// let span = /* ... */;
-/// # };
-/// # let span = Span::call_site();
-/// # let init = 0;
-///
-/// // On one line, use parentheses.
-/// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init)));
-///
-/// // On multiple lines, place the span at the top and use braces.
-/// let tokens = quote_spanned! {span=>
-///     Box::into_raw(Box::new(#init))
-/// };
-/// ```
-///
-/// The lack of space before the `=>` should look jarring to Rust programmers
-/// and this is intentional. The formatting is designed to be visibly
-/// off-balance and draw the eye a particular way, due to the span expression
-/// being evaluated in the context of the procedural macro and the remaining
-/// tokens being evaluated in the generated code.
-///
-/// <br>
-///
-/// # Hygiene
-///
-/// Any interpolated tokens preserve the `Span` information provided by their
-/// `ToTokens` implementation. Tokens that originate within the `quote_spanned!`
-/// invocation are spanned with the given span argument.
-///
-/// <br>
-///
-/// # Example
-///
-/// The following procedural macro code uses `quote_spanned!` to assert that a
-/// particular Rust type implements the [`Sync`] trait so that references can be
-/// safely shared between threads.
-///
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-///
-/// ```
-/// # use quote::{quote_spanned, TokenStreamExt, ToTokens};
-/// # use proc_macro2::{Span, TokenStream};
-/// #
-/// # struct Type;
-/// #
-/// # impl Type {
-/// #     fn span(&self) -> Span {
-/// #         Span::call_site()
-/// #     }
-/// # }
-/// #
-/// # impl ToTokens for Type {
-/// #     fn to_tokens(&self, _tokens: &mut TokenStream) {}
-/// # }
-/// #
-/// # let ty = Type;
-/// # let call_site = Span::call_site();
-/// #
-/// let ty_span = ty.span();
-/// let assert_sync = quote_spanned! {ty_span=>
-///     struct _AssertSync where #ty: Sync;
-/// };
-/// ```
-///
-/// If the assertion fails, the user will see an error like the following. The
-/// input span of their type is highlighted in the error.
-///
-/// ```text
-/// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied
-///   --> src/main.rs:10:21
-///    |
-/// 10 |     static ref PTR: *const () = &();
-///    |                     ^^^^^^^^^ `*const ()` cannot be shared between threads safely
-/// ```
-///
-/// In this example it is important for the where-clause to be spanned with the
-/// line/column information of the user's input type so that error messages are
-/// placed appropriately by the compiler.
-#[macro_export]
-macro_rules! quote_spanned {
-    ($span:expr=>) => {{
-        let _: $crate::__private::Span = $span;
-        $crate::__private::TokenStream::new()
-    }};
-    ($span:expr=> $($tt:tt)*) => {{
-        let mut _s = $crate::__private::TokenStream::new();
-        let _span: $crate::__private::Span = $span;
-        $crate::quote_each_token_spanned!(_s _span $($tt)*);
-        _s
-    }};
-}
-
-// Extract the names of all #metavariables and pass them to the $call macro.
-//
-// in:   pounded_var_names!(then!(...) a #b c #( #d )* #e)
-// out:  then!(... b);
-//       then!(... d);
-//       then!(... e);
-#[macro_export]
-#[doc(hidden)]
-macro_rules! pounded_var_names {
-    ($call:ident! $extra:tt $($tts:tt)*) => {
-        $crate::pounded_var_names_with_context!($call! $extra
-            (@ $($tts)*)
-            ($($tts)* @)
-        )
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! pounded_var_names_with_context {
-    ($call:ident! $extra:tt ($($b1:tt)*) ($($curr:tt)*)) => {
-        $(
-            $crate::pounded_var_with_context!($call! $extra $b1 $curr);
-        )*
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! pounded_var_with_context {
-    ($call:ident! $extra:tt $b1:tt ( $($inner:tt)* )) => {
-        $crate::pounded_var_names!($call! $extra $($inner)*);
-    };
-
-    ($call:ident! $extra:tt $b1:tt [ $($inner:tt)* ]) => {
-        $crate::pounded_var_names!($call! $extra $($inner)*);
-    };
-
-    ($call:ident! $extra:tt $b1:tt { $($inner:tt)* }) => {
-        $crate::pounded_var_names!($call! $extra $($inner)*);
-    };
-
-    ($call:ident!($($extra:tt)*) # $var:ident) => {
-        $crate::$call!($($extra)* $var);
-    };
-
-    ($call:ident! $extra:tt $b1:tt $curr:tt) => {};
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_bind_into_iter {
-    ($has_iter:ident $var:ident) => {
-        // `mut` may be unused if $var occurs multiple times in the list.
-        #[allow(unused_mut)]
-        let (mut $var, i) = $var.quote_into_iter();
-        let $has_iter = $has_iter | i;
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_bind_next_or_break {
-    ($var:ident) => {
-        let $var = match $var.next() {
-            Some(_x) => $crate::__private::RepInterp(_x),
-            None => break,
-        };
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_each_token {
-    ($tokens:ident $($tts:tt)*) => {
-        $crate::quote_tokens_with_context!($tokens
-            (@ @ @ @ @ @ $($tts)*)
-            (@ @ @ @ @ $($tts)* @)
-            (@ @ @ @ $($tts)* @ @)
-            (@ @ @ $(($tts))* @ @ @)
-            (@ @ $($tts)* @ @ @ @)
-            (@ $($tts)* @ @ @ @ @)
-            ($($tts)* @ @ @ @ @ @)
-        );
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_each_token_spanned {
-    ($tokens:ident $span:ident $($tts:tt)*) => {
-        $crate::quote_tokens_with_context_spanned!($tokens $span
-            (@ @ @ @ @ @ $($tts)*)
-            (@ @ @ @ @ $($tts)* @)
-            (@ @ @ @ $($tts)* @ @)
-            (@ @ @ $(($tts))* @ @ @)
-            (@ @ $($tts)* @ @ @ @)
-            (@ $($tts)* @ @ @ @ @)
-            ($($tts)* @ @ @ @ @ @)
-        );
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_tokens_with_context {
-    ($tokens:ident
-        ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*)
-        ($($curr:tt)*)
-        ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*)
-    ) => {
-        $(
-            $crate::quote_token_with_context!($tokens $b3 $b2 $b1 $curr $a1 $a2 $a3);
-        )*
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_tokens_with_context_spanned {
-    ($tokens:ident $span:ident
-        ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*)
-        ($($curr:tt)*)
-        ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*)
-    ) => {
-        $(
-            $crate::quote_token_with_context_spanned!($tokens $span $b3 $b2 $b1 $curr $a1 $a2 $a3);
-        )*
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_token_with_context {
-    ($tokens:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{
-        use $crate::__private::ext::*;
-        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
-        $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__private::HasIterator = has_iter;
-        // This is `while true` instead of `loop` because if there are no
-        // iterators used inside of this repetition then the body would not
-        // contain any `break`, so the compiler would emit unreachable code
-        // warnings on anything below the loop. We use has_iter to detect and
-        // fail to compile when there are no iterators, so here we just work
-        // around the unneeded extra warning.
-        while true {
-            $crate::pounded_var_names!(quote_bind_next_or_break!() () $($inner)*);
-            $crate::quote_each_token!($tokens $($inner)*);
-        }
-    }};
-    ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {};
-    ($tokens:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{
-        use $crate::__private::ext::*;
-        let mut _i = 0usize;
-        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
-        $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__private::HasIterator = has_iter;
-        while true {
-            $crate::pounded_var_names!(quote_bind_next_or_break!() () $($inner)*);
-            if _i > 0 {
-                $crate::quote_token!($tokens $sep);
-            }
-            _i += 1;
-            $crate::quote_each_token!($tokens $($inner)*);
-        }
-    }};
-    ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {};
-    ($tokens:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {};
-    ($tokens:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => {
-        // https://github.com/dtolnay/quote/issues/130
-        $crate::quote_token!($tokens *);
-    };
-    ($tokens:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => {
-        $crate::ToTokens::to_tokens(&$var, &mut $tokens);
-    };
-    ($tokens:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
-    ($tokens:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => {
-        $crate::quote_token!($tokens $curr);
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_token_with_context_spanned {
-    ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{
-        use $crate::__private::ext::*;
-        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
-        $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__private::HasIterator = has_iter;
-        // This is `while true` instead of `loop` because if there are no
-        // iterators used inside of this repetition then the body would not
-        // contain any `break`, so the compiler would emit unreachable code
-        // warnings on anything below the loop. We use has_iter to detect and
-        // fail to compile when there are no iterators, so here we just work
-        // around the unneeded extra warning.
-        while true {
-            $crate::pounded_var_names!(quote_bind_next_or_break!() () $($inner)*);
-            $crate::quote_each_token_spanned!($tokens $span $($inner)*);
-        }
-    }};
-    ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {};
-    ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{
-        use $crate::__private::ext::*;
-        let mut _i = 0usize;
-        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
-        $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__private::HasIterator = has_iter;
-        while true {
-            $crate::pounded_var_names!(quote_bind_next_or_break!() () $($inner)*);
-            if _i > 0 {
-                $crate::quote_token_spanned!($tokens $span $sep);
-            }
-            _i += 1;
-            $crate::quote_each_token_spanned!($tokens $span $($inner)*);
-        }
-    }};
-    ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {};
-    ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {};
-    ($tokens:ident $span:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => {
-        // https://github.com/dtolnay/quote/issues/130
-        $crate::quote_token_spanned!($tokens $span *);
-    };
-    ($tokens:ident $span:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
-
-    ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => {
-        $crate::ToTokens::to_tokens(&$var, &mut $tokens);
-    };
-    ($tokens:ident $span:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
-    ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => {
-        $crate::quote_token_spanned!($tokens $span $curr);
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_token {
-    ($tokens:ident ( $($inner:tt)* )) => {
-        $crate::__private::push_group(
-            &mut $tokens,
-            $crate::__private::Delimiter::Parenthesis,
-            $crate::quote!($($inner)*),
-        );
-    };
-
-    ($tokens:ident [ $($inner:tt)* ]) => {
-        $crate::__private::push_group(
-            &mut $tokens,
-            $crate::__private::Delimiter::Bracket,
-            $crate::quote!($($inner)*),
-        );
-    };
-
-    ($tokens:ident { $($inner:tt)* }) => {
-        $crate::__private::push_group(
-            &mut $tokens,
-            $crate::__private::Delimiter::Brace,
-            $crate::quote!($($inner)*),
-        );
-    };
-
-    ($tokens:ident +) => {
-        $crate::__private::push_add(&mut $tokens);
-    };
-
-    ($tokens:ident +=) => {
-        $crate::__private::push_add_eq(&mut $tokens);
-    };
-
-    ($tokens:ident &) => {
-        $crate::__private::push_and(&mut $tokens);
-    };
-
-    ($tokens:ident &&) => {
-        $crate::__private::push_and_and(&mut $tokens);
-    };
-
-    ($tokens:ident &=) => {
-        $crate::__private::push_and_eq(&mut $tokens);
-    };
-
-    ($tokens:ident @) => {
-        $crate::__private::push_at(&mut $tokens);
-    };
-
-    ($tokens:ident !) => {
-        $crate::__private::push_bang(&mut $tokens);
-    };
-
-    ($tokens:ident ^) => {
-        $crate::__private::push_caret(&mut $tokens);
-    };
-
-    ($tokens:ident ^=) => {
-        $crate::__private::push_caret_eq(&mut $tokens);
-    };
-
-    ($tokens:ident :) => {
-        $crate::__private::push_colon(&mut $tokens);
-    };
-
-    ($tokens:ident ::) => {
-        $crate::__private::push_colon2(&mut $tokens);
-    };
-
-    ($tokens:ident ,) => {
-        $crate::__private::push_comma(&mut $tokens);
-    };
-
-    ($tokens:ident /) => {
-        $crate::__private::push_div(&mut $tokens);
-    };
-
-    ($tokens:ident /=) => {
-        $crate::__private::push_div_eq(&mut $tokens);
-    };
-
-    ($tokens:ident .) => {
-        $crate::__private::push_dot(&mut $tokens);
-    };
-
-    ($tokens:ident ..) => {
-        $crate::__private::push_dot2(&mut $tokens);
-    };
-
-    ($tokens:ident ...) => {
-        $crate::__private::push_dot3(&mut $tokens);
-    };
-
-    ($tokens:ident ..=) => {
-        $crate::__private::push_dot_dot_eq(&mut $tokens);
-    };
-
-    ($tokens:ident =) => {
-        $crate::__private::push_eq(&mut $tokens);
-    };
-
-    ($tokens:ident ==) => {
-        $crate::__private::push_eq_eq(&mut $tokens);
-    };
-
-    ($tokens:ident >=) => {
-        $crate::__private::push_ge(&mut $tokens);
-    };
-
-    ($tokens:ident >) => {
-        $crate::__private::push_gt(&mut $tokens);
-    };
-
-    ($tokens:ident <=) => {
-        $crate::__private::push_le(&mut $tokens);
-    };
-
-    ($tokens:ident <) => {
-        $crate::__private::push_lt(&mut $tokens);
-    };
-
-    ($tokens:ident *=) => {
-        $crate::__private::push_mul_eq(&mut $tokens);
-    };
-
-    ($tokens:ident !=) => {
-        $crate::__private::push_ne(&mut $tokens);
-    };
-
-    ($tokens:ident |) => {
-        $crate::__private::push_or(&mut $tokens);
-    };
-
-    ($tokens:ident |=) => {
-        $crate::__private::push_or_eq(&mut $tokens);
-    };
-
-    ($tokens:ident ||) => {
-        $crate::__private::push_or_or(&mut $tokens);
-    };
-
-    ($tokens:ident #) => {
-        $crate::__private::push_pound(&mut $tokens);
-    };
-
-    ($tokens:ident ?) => {
-        $crate::__private::push_question(&mut $tokens);
-    };
-
-    ($tokens:ident ->) => {
-        $crate::__private::push_rarrow(&mut $tokens);
-    };
-
-    ($tokens:ident <-) => {
-        $crate::__private::push_larrow(&mut $tokens);
-    };
-
-    ($tokens:ident %) => {
-        $crate::__private::push_rem(&mut $tokens);
-    };
-
-    ($tokens:ident %=) => {
-        $crate::__private::push_rem_eq(&mut $tokens);
-    };
-
-    ($tokens:ident =>) => {
-        $crate::__private::push_fat_arrow(&mut $tokens);
-    };
-
-    ($tokens:ident ;) => {
-        $crate::__private::push_semi(&mut $tokens);
-    };
-
-    ($tokens:ident <<) => {
-        $crate::__private::push_shl(&mut $tokens);
-    };
-
-    ($tokens:ident <<=) => {
-        $crate::__private::push_shl_eq(&mut $tokens);
-    };
-
-    ($tokens:ident >>) => {
-        $crate::__private::push_shr(&mut $tokens);
-    };
-
-    ($tokens:ident >>=) => {
-        $crate::__private::push_shr_eq(&mut $tokens);
-    };
-
-    ($tokens:ident *) => {
-        $crate::__private::push_star(&mut $tokens);
-    };
-
-    ($tokens:ident -) => {
-        $crate::__private::push_sub(&mut $tokens);
-    };
-
-    ($tokens:ident -=) => {
-        $crate::__private::push_sub_eq(&mut $tokens);
-    };
-
-    ($tokens:ident $ident:ident) => {
-        $crate::__private::push_ident(&mut $tokens, stringify!($ident));
-    };
-
-    ($tokens:ident $other:tt) => {
-        $crate::__private::parse(&mut $tokens, stringify!($other));
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_token_spanned {
-    ($tokens:ident $span:ident ( $($inner:tt)* )) => {
-        $crate::__private::push_group_spanned(
-            &mut $tokens,
-            $span,
-            $crate::__private::Delimiter::Parenthesis,
-            $crate::quote_spanned!($span=> $($inner)*),
-        );
-    };
-
-    ($tokens:ident $span:ident [ $($inner:tt)* ]) => {
-        $crate::__private::push_group_spanned(
-            &mut $tokens,
-            $span,
-            $crate::__private::Delimiter::Bracket,
-            $crate::quote_spanned!($span=> $($inner)*),
-        );
-    };
-
-    ($tokens:ident $span:ident { $($inner:tt)* }) => {
-        $crate::__private::push_group_spanned(
-            &mut $tokens,
-            $span,
-            $crate::__private::Delimiter::Brace,
-            $crate::quote_spanned!($span=> $($inner)*),
-        );
-    };
-
-    ($tokens:ident $span:ident +) => {
-        $crate::__private::push_add_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident +=) => {
-        $crate::__private::push_add_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident &) => {
-        $crate::__private::push_and_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident &&) => {
-        $crate::__private::push_and_and_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident &=) => {
-        $crate::__private::push_and_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident @) => {
-        $crate::__private::push_at_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident !) => {
-        $crate::__private::push_bang_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ^) => {
-        $crate::__private::push_caret_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ^=) => {
-        $crate::__private::push_caret_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident :) => {
-        $crate::__private::push_colon_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ::) => {
-        $crate::__private::push_colon2_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ,) => {
-        $crate::__private::push_comma_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident /) => {
-        $crate::__private::push_div_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident /=) => {
-        $crate::__private::push_div_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident .) => {
-        $crate::__private::push_dot_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ..) => {
-        $crate::__private::push_dot2_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ...) => {
-        $crate::__private::push_dot3_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ..=) => {
-        $crate::__private::push_dot_dot_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident =) => {
-        $crate::__private::push_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ==) => {
-        $crate::__private::push_eq_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident >=) => {
-        $crate::__private::push_ge_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident >) => {
-        $crate::__private::push_gt_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident <=) => {
-        $crate::__private::push_le_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident <) => {
-        $crate::__private::push_lt_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident *=) => {
-        $crate::__private::push_mul_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident !=) => {
-        $crate::__private::push_ne_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident |) => {
-        $crate::__private::push_or_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident |=) => {
-        $crate::__private::push_or_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ||) => {
-        $crate::__private::push_or_or_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident #) => {
-        $crate::__private::push_pound_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ?) => {
-        $crate::__private::push_question_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ->) => {
-        $crate::__private::push_rarrow_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident <-) => {
-        $crate::__private::push_larrow_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident %) => {
-        $crate::__private::push_rem_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident %=) => {
-        $crate::__private::push_rem_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident =>) => {
-        $crate::__private::push_fat_arrow_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident ;) => {
-        $crate::__private::push_semi_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident <<) => {
-        $crate::__private::push_shl_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident <<=) => {
-        $crate::__private::push_shl_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident >>) => {
-        $crate::__private::push_shr_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident >>=) => {
-        $crate::__private::push_shr_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident *) => {
-        $crate::__private::push_star_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident -) => {
-        $crate::__private::push_sub_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident -=) => {
-        $crate::__private::push_sub_eq_spanned(&mut $tokens, $span);
-    };
-
-    ($tokens:ident $span:ident $ident:ident) => {
-        $crate::__private::push_ident_spanned(&mut $tokens, $span, stringify!($ident));
-    };
-
-    ($tokens:ident $span:ident $other:tt) => {
-        $crate::__private::parse_spanned(&mut $tokens, $span, stringify!($other));
-    };
-}
diff --git a/vendor/quote/src/runtime.rs b/vendor/quote/src/runtime.rs
deleted file mode 100644
index db3b6a93..00000000
--- a/vendor/quote/src/runtime.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-use crate::{IdentFragment, ToTokens, TokenStreamExt};
-use std::fmt;
-use std::ops::BitOr;
-
-pub use proc_macro2::*;
-
-pub struct HasIterator; // True
-pub struct ThereIsNoIteratorInRepetition; // False
-
-impl BitOr<ThereIsNoIteratorInRepetition> for ThereIsNoIteratorInRepetition {
-    type Output = ThereIsNoIteratorInRepetition;
-    fn bitor(self, _rhs: ThereIsNoIteratorInRepetition) -> ThereIsNoIteratorInRepetition {
-        ThereIsNoIteratorInRepetition
-    }
-}
-
-impl BitOr<ThereIsNoIteratorInRepetition> for HasIterator {
-    type Output = HasIterator;
-    fn bitor(self, _rhs: ThereIsNoIteratorInRepetition) -> HasIterator {
-        HasIterator
-    }
-}
-
-impl BitOr<HasIterator> for ThereIsNoIteratorInRepetition {
-    type Output = HasIterator;
-    fn bitor(self, _rhs: HasIterator) -> HasIterator {
-        HasIterator
-    }
-}
-
-impl BitOr<HasIterator> for HasIterator {
-    type Output = HasIterator;
-    fn bitor(self, _rhs: HasIterator) -> HasIterator {
-        HasIterator
-    }
-}
-
-/// Extension traits used by the implementation of `quote!`. These are defined
-/// in separate traits, rather than as a single trait due to ambiguity issues.
-///
-/// These traits expose a `quote_into_iter` method which should allow calling
-/// whichever impl happens to be applicable. Calling that method repeatedly on
-/// the returned value should be idempotent.
-pub mod ext {
-    use super::RepInterp;
-    use super::{HasIterator as HasIter, ThereIsNoIteratorInRepetition as DoesNotHaveIter};
-    use crate::ToTokens;
-    use std::collections::btree_set::{self, BTreeSet};
-    use std::slice;
-
-    /// Extension trait providing the `quote_into_iter` method on iterators.
-    pub trait RepIteratorExt: Iterator + Sized {
-        fn quote_into_iter(self) -> (Self, HasIter) {
-            (self, HasIter)
-        }
-    }
-
-    impl<T: Iterator> RepIteratorExt for T {}
-
-    /// Extension trait providing the `quote_into_iter` method for
-    /// non-iterable types. These types interpolate the same value in each
-    /// iteration of the repetition.
-    pub trait RepToTokensExt {
-        /// Pretend to be an iterator for the purposes of `quote_into_iter`.
-        /// This allows repeated calls to `quote_into_iter` to continue
-        /// correctly returning DoesNotHaveIter.
-        fn next(&self) -> Option<&Self> {
-            Some(self)
-        }
-
-        fn quote_into_iter(&self) -> (&Self, DoesNotHaveIter) {
-            (self, DoesNotHaveIter)
-        }
-    }
-
-    impl<T: ToTokens + ?Sized> RepToTokensExt for T {}
-
-    /// Extension trait providing the `quote_into_iter` method for types that
-    /// can be referenced as an iterator.
-    pub trait RepAsIteratorExt<'q> {
-        type Iter: Iterator;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter);
-    }
-
-    impl<'q, 'a, T: RepAsIteratorExt<'q> + ?Sized> RepAsIteratorExt<'q> for &'a T {
-        type Iter = T::Iter;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            <T as RepAsIteratorExt>::quote_into_iter(*self)
-        }
-    }
-
-    impl<'q, 'a, T: RepAsIteratorExt<'q> + ?Sized> RepAsIteratorExt<'q> for &'a mut T {
-        type Iter = T::Iter;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            <T as RepAsIteratorExt>::quote_into_iter(*self)
-        }
-    }
-
-    impl<'q, T: 'q> RepAsIteratorExt<'q> for [T] {
-        type Iter = slice::Iter<'q, T>;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            (self.iter(), HasIter)
-        }
-    }
-
-    impl<'q, T: 'q> RepAsIteratorExt<'q> for Vec<T> {
-        type Iter = slice::Iter<'q, T>;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            (self.iter(), HasIter)
-        }
-    }
-
-    impl<'q, T: 'q> RepAsIteratorExt<'q> for BTreeSet<T> {
-        type Iter = btree_set::Iter<'q, T>;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            (self.iter(), HasIter)
-        }
-    }
-
-    macro_rules! array_rep_slice {
-        ($($l:tt)*) => {
-            $(
-                impl<'q, T: 'q> RepAsIteratorExt<'q> for [T; $l] {
-                    type Iter = slice::Iter<'q, T>;
-
-                    fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-                        (self.iter(), HasIter)
-                    }
-                }
-            )*
-        }
-    }
-
-    array_rep_slice!(
-        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
-        17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
-    );
-
-    impl<'q, T: RepAsIteratorExt<'q>> RepAsIteratorExt<'q> for RepInterp<T> {
-        type Iter = T::Iter;
-
-        fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) {
-            self.0.quote_into_iter()
-        }
-    }
-}
-
-// Helper type used within interpolations to allow for repeated binding names.
-// Implements the relevant traits, and exports a dummy `next()` method.
-#[derive(Copy, Clone)]
-pub struct RepInterp<T>(pub T);
-
-impl<T> RepInterp<T> {
-    // This method is intended to look like `Iterator::next`, and is called when
-    // a name is bound multiple times, as the previous binding will shadow the
-    // original `Iterator` object. This allows us to avoid advancing the
-    // iterator multiple times per iteration.
-    pub fn next(self) -> Option<T> {
-        Some(self.0)
-    }
-}
-
-impl<T: Iterator> Iterator for RepInterp<T> {
-    type Item = T::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
-
-impl<T: ToTokens> ToTokens for RepInterp<T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        self.0.to_tokens(tokens);
-    }
-}
-
-pub fn push_group(tokens: &mut TokenStream, delimiter: Delimiter, inner: TokenStream) {
-    tokens.append(Group::new(delimiter, inner));
-}
-
-pub fn push_group_spanned(
-    tokens: &mut TokenStream,
-    span: Span,
-    delimiter: Delimiter,
-    inner: TokenStream,
-) {
-    let mut g = Group::new(delimiter, inner);
-    g.set_span(span);
-    tokens.append(g);
-}
-
-pub fn parse(tokens: &mut TokenStream, s: &str) {
-    let s: TokenStream = s.parse().expect("invalid token stream");
-    tokens.extend(s);
-}
-
-pub fn parse_spanned(tokens: &mut TokenStream, span: Span, s: &str) {
-    let s: TokenStream = s.parse().expect("invalid token stream");
-    tokens.extend(s.into_iter().map(|mut t| {
-        t.set_span(span);
-        t
-    }));
-}
-
-pub fn push_ident(tokens: &mut TokenStream, s: &str) {
-    // Optimization over `mk_ident`, as `s` is guaranteed to be a valid ident.
-    //
-    // FIXME: When `Ident::new_raw` becomes stable, this method should be
-    // updated to call it when available.
-    if s.starts_with("r#") {
-        parse(tokens, s);
-    } else {
-        tokens.append(Ident::new(s, Span::call_site()));
-    }
-}
-
-pub fn push_ident_spanned(tokens: &mut TokenStream, span: Span, s: &str) {
-    // Optimization over `mk_ident`, as `s` is guaranteed to be a valid ident.
-    //
-    // FIXME: When `Ident::new_raw` becomes stable, this method should be
-    // updated to call it when available.
-    if s.starts_with("r#") {
-        parse_spanned(tokens, span, s);
-    } else {
-        tokens.append(Ident::new(s, span));
-    }
-}
-
-macro_rules! push_punct {
-    ($name:ident $spanned:ident $char1:tt) => {
-        pub fn $name(tokens: &mut TokenStream) {
-            tokens.append(Punct::new($char1, Spacing::Alone));
-        }
-        pub fn $spanned(tokens: &mut TokenStream, span: Span) {
-            let mut punct = Punct::new($char1, Spacing::Alone);
-            punct.set_span(span);
-            tokens.append(punct);
-        }
-    };
-    ($name:ident $spanned:ident $char1:tt $char2:tt) => {
-        pub fn $name(tokens: &mut TokenStream) {
-            tokens.append(Punct::new($char1, Spacing::Joint));
-            tokens.append(Punct::new($char2, Spacing::Alone));
-        }
-        pub fn $spanned(tokens: &mut TokenStream, span: Span) {
-            let mut punct = Punct::new($char1, Spacing::Joint);
-            punct.set_span(span);
-            tokens.append(punct);
-            let mut punct = Punct::new($char2, Spacing::Alone);
-            punct.set_span(span);
-            tokens.append(punct);
-        }
-    };
-    ($name:ident $spanned:ident $char1:tt $char2:tt $char3:tt) => {
-        pub fn $name(tokens: &mut TokenStream) {
-            tokens.append(Punct::new($char1, Spacing::Joint));
-            tokens.append(Punct::new($char2, Spacing::Joint));
-            tokens.append(Punct::new($char3, Spacing::Alone));
-        }
-        pub fn $spanned(tokens: &mut TokenStream, span: Span) {
-            let mut punct = Punct::new($char1, Spacing::Joint);
-            punct.set_span(span);
-            tokens.append(punct);
-            let mut punct = Punct::new($char2, Spacing::Joint);
-            punct.set_span(span);
-            tokens.append(punct);
-            let mut punct = Punct::new($char3, Spacing::Alone);
-            punct.set_span(span);
-            tokens.append(punct);
-        }
-    };
-}
-
-push_punct!(push_add push_add_spanned '+');
-push_punct!(push_add_eq push_add_eq_spanned '+' '=');
-push_punct!(push_and push_and_spanned '&');
-push_punct!(push_and_and push_and_and_spanned '&' '&');
-push_punct!(push_and_eq push_and_eq_spanned '&' '=');
-push_punct!(push_at push_at_spanned '@');
-push_punct!(push_bang push_bang_spanned '!');
-push_punct!(push_caret push_caret_spanned '^');
-push_punct!(push_caret_eq push_caret_eq_spanned '^' '=');
-push_punct!(push_colon push_colon_spanned ':');
-push_punct!(push_colon2 push_colon2_spanned ':' ':');
-push_punct!(push_comma push_comma_spanned ',');
-push_punct!(push_div push_div_spanned '/');
-push_punct!(push_div_eq push_div_eq_spanned '/' '=');
-push_punct!(push_dot push_dot_spanned '.');
-push_punct!(push_dot2 push_dot2_spanned '.' '.');
-push_punct!(push_dot3 push_dot3_spanned '.' '.' '.');
-push_punct!(push_dot_dot_eq push_dot_dot_eq_spanned '.' '.' '=');
-push_punct!(push_eq push_eq_spanned '=');
-push_punct!(push_eq_eq push_eq_eq_spanned '=' '=');
-push_punct!(push_ge push_ge_spanned '>' '=');
-push_punct!(push_gt push_gt_spanned '>');
-push_punct!(push_le push_le_spanned '<' '=');
-push_punct!(push_lt push_lt_spanned '<');
-push_punct!(push_mul_eq push_mul_eq_spanned '*' '=');
-push_punct!(push_ne push_ne_spanned '!' '=');
-push_punct!(push_or push_or_spanned '|');
-push_punct!(push_or_eq push_or_eq_spanned '|' '=');
-push_punct!(push_or_or push_or_or_spanned '|' '|');
-push_punct!(push_pound push_pound_spanned '#');
-push_punct!(push_question push_question_spanned '?');
-push_punct!(push_rarrow push_rarrow_spanned '-' '>');
-push_punct!(push_larrow push_larrow_spanned '<' '-');
-push_punct!(push_rem push_rem_spanned '%');
-push_punct!(push_rem_eq push_rem_eq_spanned '%' '=');
-push_punct!(push_fat_arrow push_fat_arrow_spanned '=' '>');
-push_punct!(push_semi push_semi_spanned ';');
-push_punct!(push_shl push_shl_spanned '<' '<');
-push_punct!(push_shl_eq push_shl_eq_spanned '<' '<' '=');
-push_punct!(push_shr push_shr_spanned '>' '>');
-push_punct!(push_shr_eq push_shr_eq_spanned '>' '>' '=');
-push_punct!(push_star push_star_spanned '*');
-push_punct!(push_sub push_sub_spanned '-');
-push_punct!(push_sub_eq push_sub_eq_spanned '-' '=');
-
-// Helper method for constructing identifiers from the `format_ident!` macro,
-// handling `r#` prefixes.
-//
-// Directly parsing the input string may produce a valid identifier,
-// although the input string was invalid, due to ignored characters such as
-// whitespace and comments. Instead, we always create a non-raw identifier
-// to validate that the string is OK, and only parse again if needed.
-pub fn mk_ident(id: &str, span: Option<Span>) -> Ident {
-    let span = span.unwrap_or_else(Span::call_site);
-
-    let is_raw = id.starts_with("r#");
-    let unraw = Ident::new(if is_raw { &id[2..] } else { id }, span);
-    if !is_raw {
-        return unraw;
-    }
-
-    // At this point, the identifier is raw, and the unraw-ed version of it was
-    // successfully converted into an identifier. Try to produce a valid raw
-    // identifier by running the `TokenStream` parser, and unwrapping the first
-    // token as an `Ident`.
-    //
-    // FIXME: When `Ident::new_raw` becomes stable, this method should be
-    // updated to call it when available.
-    if let Ok(ts) = id.parse::<TokenStream>() {
-        let mut iter = ts.into_iter();
-        if let (Some(TokenTree::Ident(mut id)), None) = (iter.next(), iter.next()) {
-            id.set_span(span);
-            return id;
-        }
-    }
-
-    panic!("not allowed as a raw identifier: `{}`", id);
-}
-
-// Adapts from `IdentFragment` to `fmt::Display` for use by the `format_ident!`
-// macro, and exposes span information from these fragments.
-//
-// This struct also has forwarding implementations of the formatting traits
-// `Octal`, `LowerHex`, `UpperHex`, and `Binary` to allow for their use within
-// `format_ident!`.
-#[derive(Copy, Clone)]
-pub struct IdentFragmentAdapter<T: IdentFragment>(pub T);
-
-impl<T: IdentFragment> IdentFragmentAdapter<T> {
-    pub fn span(&self) -> Option<Span> {
-        self.0.span()
-    }
-}
-
-impl<T: IdentFragment> fmt::Display for IdentFragmentAdapter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        IdentFragment::fmt(&self.0, f)
-    }
-}
-
-impl<T: IdentFragment + fmt::Octal> fmt::Octal for IdentFragmentAdapter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Octal::fmt(&self.0, f)
-    }
-}
-
-impl<T: IdentFragment + fmt::LowerHex> fmt::LowerHex for IdentFragmentAdapter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::LowerHex::fmt(&self.0, f)
-    }
-}
-
-impl<T: IdentFragment + fmt::UpperHex> fmt::UpperHex for IdentFragmentAdapter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::UpperHex::fmt(&self.0, f)
-    }
-}
-
-impl<T: IdentFragment + fmt::Binary> fmt::Binary for IdentFragmentAdapter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Binary::fmt(&self.0, f)
-    }
-}
diff --git a/vendor/quote/src/spanned.rs b/vendor/quote/src/spanned.rs
deleted file mode 100644
index 55168bdd..00000000
--- a/vendor/quote/src/spanned.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use crate::ToTokens;
-use proc_macro2::{Span, TokenStream};
-
-pub trait Spanned {
-    fn __span(&self) -> Span;
-}
-
-impl Spanned for Span {
-    fn __span(&self) -> Span {
-        *self
-    }
-}
-
-impl<T: ?Sized + ToTokens> Spanned for T {
-    fn __span(&self) -> Span {
-        join_spans(self.into_token_stream())
-    }
-}
-
-fn join_spans(tokens: TokenStream) -> Span {
-    let mut iter = tokens.into_iter().filter_map(|tt| {
-        // FIXME: This shouldn't be required, since optimally spans should
-        // never be invalid. This filter_map can probably be removed when
-        // https://github.com/rust-lang/rust/issues/43081 is resolved.
-        let span = tt.span();
-        let debug = format!("{:?}", span);
-        if debug.ends_with("bytes(0..0)") {
-            None
-        } else {
-            Some(span)
-        }
-    });
-
-    let first = match iter.next() {
-        Some(span) => span,
-        None => return Span::call_site(),
-    };
-
-    iter.fold(None, |_prev, next| Some(next))
-        .and_then(|last| first.join(last))
-        .unwrap_or(first)
-}
diff --git a/vendor/quote/src/to_tokens.rs b/vendor/quote/src/to_tokens.rs
deleted file mode 100644
index 7f980839..00000000
--- a/vendor/quote/src/to_tokens.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use super::TokenStreamExt;
-
-use std::borrow::Cow;
-use std::iter;
-use std::rc::Rc;
-
-use proc_macro2::{Group, Ident, Literal, Punct, Span, TokenStream, TokenTree};
-
-/// Types that can be interpolated inside a `quote!` invocation.
-///
-/// [`quote!`]: macro.quote.html
-pub trait ToTokens {
-    /// Write `self` to the given `TokenStream`.
-    ///
-    /// The token append methods provided by the [`TokenStreamExt`] extension
-    /// trait may be useful for implementing `ToTokens`.
-    ///
-    /// [`TokenStreamExt`]: trait.TokenStreamExt.html
-    ///
-    /// # Example
-    ///
-    /// Example implementation for a struct representing Rust paths like
-    /// `std::cmp::PartialEq`:
-    ///
-    /// ```
-    /// use proc_macro2::{TokenTree, Spacing, Span, Punct, TokenStream};
-    /// use quote::{TokenStreamExt, ToTokens};
-    ///
-    /// pub struct Path {
-    ///     pub global: bool,
-    ///     pub segments: Vec<PathSegment>,
-    /// }
-    ///
-    /// impl ToTokens for Path {
-    ///     fn to_tokens(&self, tokens: &mut TokenStream) {
-    ///         for (i, segment) in self.segments.iter().enumerate() {
-    ///             if i > 0 || self.global {
-    ///                 // Double colon `::`
-    ///                 tokens.append(Punct::new(':', Spacing::Joint));
-    ///                 tokens.append(Punct::new(':', Spacing::Alone));
-    ///             }
-    ///             segment.to_tokens(tokens);
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # pub struct PathSegment;
-    /// #
-    /// # impl ToTokens for PathSegment {
-    /// #     fn to_tokens(&self, tokens: &mut TokenStream) {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// ```
-    fn to_tokens(&self, tokens: &mut TokenStream);
-
-    /// Convert `self` directly into a `TokenStream` object.
-    ///
-    /// This method is implicitly implemented using `to_tokens`, and acts as a
-    /// convenience method for consumers of the `ToTokens` trait.
-    fn to_token_stream(&self) -> TokenStream {
-        let mut tokens = TokenStream::new();
-        self.to_tokens(&mut tokens);
-        tokens
-    }
-
-    /// Convert `self` directly into a `TokenStream` object.
-    ///
-    /// This method is implicitly implemented using `to_tokens`, and acts as a
-    /// convenience method for consumers of the `ToTokens` trait.
-    fn into_token_stream(self) -> TokenStream
-    where
-        Self: Sized,
-    {
-        self.to_token_stream()
-    }
-}
-
-impl<'a, T: ?Sized + ToTokens> ToTokens for &'a T {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<'a, T: ?Sized + ToTokens> ToTokens for &'a mut T {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<'a, T: ?Sized + ToOwned + ToTokens> ToTokens for Cow<'a, T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<T: ?Sized + ToTokens> ToTokens for Box<T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<T: ?Sized + ToTokens> ToTokens for Rc<T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<T: ToTokens> ToTokens for Option<T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        if let Some(ref t) = *self {
-            t.to_tokens(tokens);
-        }
-    }
-}
-
-impl ToTokens for str {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(Literal::string(self));
-    }
-}
-
-impl ToTokens for String {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        self.as_str().to_tokens(tokens);
-    }
-}
-
-macro_rules! primitive {
-    ($($t:ident => $name:ident)*) => ($(
-        impl ToTokens for $t {
-            fn to_tokens(&self, tokens: &mut TokenStream) {
-                tokens.append(Literal::$name(*self));
-            }
-        }
-    )*)
-}
-
-primitive! {
-    i8 => i8_suffixed
-    i16 => i16_suffixed
-    i32 => i32_suffixed
-    i64 => i64_suffixed
-    i128 => i128_suffixed
-    isize => isize_suffixed
-
-    u8 => u8_suffixed
-    u16 => u16_suffixed
-    u32 => u32_suffixed
-    u64 => u64_suffixed
-    u128 => u128_suffixed
-    usize => usize_suffixed
-
-    f32 => f32_suffixed
-    f64 => f64_suffixed
-}
-
-impl ToTokens for char {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(Literal::character(*self));
-    }
-}
-
-impl ToTokens for bool {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let word = if *self { "true" } else { "false" };
-        tokens.append(Ident::new(word, Span::call_site()));
-    }
-}
-
-impl ToTokens for Group {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(self.clone());
-    }
-}
-
-impl ToTokens for Ident {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(self.clone());
-    }
-}
-
-impl ToTokens for Punct {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(self.clone());
-    }
-}
-
-impl ToTokens for Literal {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(self.clone());
-    }
-}
-
-impl ToTokens for TokenTree {
-    fn to_tokens(&self, dst: &mut TokenStream) {
-        dst.append(self.clone());
-    }
-}
-
-impl ToTokens for TokenStream {
-    fn to_tokens(&self, dst: &mut TokenStream) {
-        dst.extend(iter::once(self.clone()));
-    }
-
-    fn into_token_stream(self) -> TokenStream {
-        self
-    }
-}
diff --git a/vendor/quote/tests/compiletest.rs b/vendor/quote/tests/compiletest.rs
deleted file mode 100644
index f9aea23b..00000000
--- a/vendor/quote/tests/compiletest.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#[rustversion::attr(not(nightly), ignore)]
-#[test]
-fn ui() {
-    let t = trybuild::TestCases::new();
-    t.compile_fail("tests/ui/*.rs");
-}
diff --git a/vendor/quote/tests/test.rs b/vendor/quote/tests/test.rs
deleted file mode 100644
index d5a3490c..00000000
--- a/vendor/quote/tests/test.rs
+++ /dev/null
@@ -1,459 +0,0 @@
-#![cfg_attr(feature = "cargo-clippy", allow(blacklisted_name))]
-
-use std::borrow::Cow;
-use std::collections::BTreeSet;
-
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::{format_ident, quote, quote_spanned, TokenStreamExt};
-
-struct X;
-
-impl quote::ToTokens for X {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(Ident::new("X", Span::call_site()));
-    }
-}
-
-#[test]
-fn test_quote_impl() {
-    let tokens = quote! {
-        impl<'a, T: ToTokens> ToTokens for &'a T {
-            fn to_tokens(&self, tokens: &mut TokenStream) {
-                (**self).to_tokens(tokens)
-            }
-        }
-    };
-
-    let expected = concat!(
-        "impl < 'a , T : ToTokens > ToTokens for & 'a T { ",
-        "fn to_tokens (& self , tokens : & mut TokenStream) { ",
-        "(* * self) . to_tokens (tokens) ",
-        "} ",
-        "}"
-    );
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_quote_spanned_impl() {
-    let span = Span::call_site();
-    let tokens = quote_spanned! {span=>
-        impl<'a, T: ToTokens> ToTokens for &'a T {
-            fn to_tokens(&self, tokens: &mut TokenStream) {
-                (**self).to_tokens(tokens)
-            }
-        }
-    };
-
-    let expected = concat!(
-        "impl < 'a , T : ToTokens > ToTokens for & 'a T { ",
-        "fn to_tokens (& self , tokens : & mut TokenStream) { ",
-        "(* * self) . to_tokens (tokens) ",
-        "} ",
-        "}"
-    );
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_substitution() {
-    let x = X;
-    let tokens = quote!(#x <#x> (#x) [#x] {#x});
-
-    let expected = "X < X > (X) [X] { X }";
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_iter() {
-    let primes = &[X, X, X, X];
-
-    assert_eq!("X X X X", quote!(#(#primes)*).to_string());
-
-    assert_eq!("X , X , X , X ,", quote!(#(#primes,)*).to_string());
-
-    assert_eq!("X , X , X , X", quote!(#(#primes),*).to_string());
-}
-
-#[test]
-fn test_advanced() {
-    let generics = quote!( <'a, T> );
-
-    let where_clause = quote!( where T: Serialize );
-
-    let field_ty = quote!(String);
-
-    let item_ty = quote!(Cow<'a, str>);
-
-    let path = quote!(SomeTrait::serialize_with);
-
-    let value = quote!(self.x);
-
-    let tokens = quote! {
-        struct SerializeWith #generics #where_clause {
-            value: &'a #field_ty,
-            phantom: ::std::marker::PhantomData<#item_ty>,
-        }
-
-        impl #generics ::serde::Serialize for SerializeWith #generics #where_clause {
-            fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
-                where S: ::serde::Serializer
-            {
-                #path(self.value, s)
-            }
-        }
-
-        SerializeWith {
-            value: #value,
-            phantom: ::std::marker::PhantomData::<#item_ty>,
-        }
-    };
-
-    let expected = concat!(
-        "struct SerializeWith < 'a , T > where T : Serialize { ",
-        "value : & 'a String , ",
-        "phantom : :: std :: marker :: PhantomData < Cow < 'a , str > > , ",
-        "} ",
-        "impl < 'a , T > :: serde :: Serialize for SerializeWith < 'a , T > where T : Serialize { ",
-        "fn serialize < S > (& self , s : & mut S) -> Result < () , S :: Error > ",
-        "where S : :: serde :: Serializer ",
-        "{ ",
-        "SomeTrait :: serialize_with (self . value , s) ",
-        "} ",
-        "} ",
-        "SerializeWith { ",
-        "value : self . x , ",
-        "phantom : :: std :: marker :: PhantomData :: < Cow < 'a , str > > , ",
-        "}"
-    );
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_integer() {
-    let ii8 = -1i8;
-    let ii16 = -1i16;
-    let ii32 = -1i32;
-    let ii64 = -1i64;
-    let ii128 = -1i128;
-    let iisize = -1isize;
-    let uu8 = 1u8;
-    let uu16 = 1u16;
-    let uu32 = 1u32;
-    let uu64 = 1u64;
-    let uu128 = 1u128;
-    let uusize = 1usize;
-
-    let tokens = quote! {
-        #ii8 #ii16 #ii32 #ii64 #ii128 #iisize
-        #uu8 #uu16 #uu32 #uu64 #uu128 #uusize
-    };
-    let expected = "- 1i8 - 1i16 - 1i32 - 1i64 - 1i128 - 1isize 1u8 1u16 1u32 1u64 1u128 1usize";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_floating() {
-    let e32 = 2.345f32;
-
-    let e64 = 2.345f64;
-
-    let tokens = quote! {
-        #e32
-        #e64
-    };
-    let expected = concat!("2.345f32 2.345f64");
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_char() {
-    let zero = '\0';
-    let pound = '#';
-    let quote = '"';
-    let apost = '\'';
-    let newline = '\n';
-    let heart = '\u{2764}';
-
-    let tokens = quote! {
-        #zero #pound #quote #apost #newline #heart
-    };
-    let expected = "'\\u{0}' '#' '\"' '\\'' '\\n' '\u{2764}'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_str() {
-    let s = "\0 a 'b \" c";
-    let tokens = quote!(#s);
-    let expected = "\"\\u{0} a 'b \\\" c\"";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_string() {
-    let s = "\0 a 'b \" c".to_string();
-    let tokens = quote!(#s);
-    let expected = "\"\\u{0} a 'b \\\" c\"";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_ident() {
-    let foo = Ident::new("Foo", Span::call_site());
-    let bar = Ident::new(&format!("Bar{}", 7), Span::call_site());
-    let tokens = quote!(struct #foo; enum #bar {});
-    let expected = "struct Foo ; enum Bar7 { }";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_duplicate() {
-    let ch = 'x';
-
-    let tokens = quote!(#ch #ch);
-
-    let expected = "'x' 'x'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_fancy_repetition() {
-    let foo = vec!["a", "b"];
-    let bar = vec![true, false];
-
-    let tokens = quote! {
-        #(#foo: #bar),*
-    };
-
-    let expected = r#""a" : true , "b" : false"#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_nested_fancy_repetition() {
-    let nested = vec![vec!['a', 'b', 'c'], vec!['x', 'y', 'z']];
-
-    let tokens = quote! {
-        #(
-            #(#nested)*
-        ),*
-    };
-
-    let expected = "'a' 'b' 'c' , 'x' 'y' 'z'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_duplicate_name_repetition() {
-    let foo = &["a", "b"];
-
-    let tokens = quote! {
-        #(#foo: #foo),*
-        #(#foo: #foo),*
-    };
-
-    let expected = r#""a" : "a" , "b" : "b" "a" : "a" , "b" : "b""#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_duplicate_name_repetition_no_copy() {
-    let foo = vec!["a".to_owned(), "b".to_owned()];
-
-    let tokens = quote! {
-        #(#foo: #foo),*
-    };
-
-    let expected = r#""a" : "a" , "b" : "b""#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_btreeset_repetition() {
-    let mut set = BTreeSet::new();
-    set.insert("a".to_owned());
-    set.insert("b".to_owned());
-
-    let tokens = quote! {
-        #(#set: #set),*
-    };
-
-    let expected = r#""a" : "a" , "b" : "b""#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_variable_name_conflict() {
-    // The implementation of `#(...),*` uses the variable `_i` but it should be
-    // fine, if a little confusing when debugging.
-    let _i = vec!['a', 'b'];
-    let tokens = quote! { #(#_i),* };
-    let expected = "'a' , 'b'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_nonrep_in_repetition() {
-    let rep = vec!["a", "b"];
-    let nonrep = "c";
-
-    let tokens = quote! {
-        #(#rep #rep : #nonrep #nonrep),*
-    };
-
-    let expected = r#""a" "a" : "c" "c" , "b" "b" : "c" "c""#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_empty_quote() {
-    let tokens = quote!();
-    assert_eq!("", tokens.to_string());
-}
-
-#[test]
-fn test_box_str() {
-    let b = "str".to_owned().into_boxed_str();
-    let tokens = quote! { #b };
-    assert_eq!("\"str\"", tokens.to_string());
-}
-
-#[test]
-fn test_cow() {
-    let owned: Cow<Ident> = Cow::Owned(Ident::new("owned", Span::call_site()));
-
-    let ident = Ident::new("borrowed", Span::call_site());
-    let borrowed = Cow::Borrowed(&ident);
-
-    let tokens = quote! { #owned #borrowed };
-    assert_eq!("owned borrowed", tokens.to_string());
-}
-
-#[test]
-fn test_closure() {
-    fn field_i(i: usize) -> Ident {
-        format_ident!("__field{}", i)
-    }
-
-    let fields = (0usize..3)
-        .map(field_i as fn(_) -> _)
-        .map(|var| quote! { #var });
-
-    let tokens = quote! { #(#fields)* };
-    assert_eq!("__field0 __field1 __field2", tokens.to_string());
-}
-
-#[test]
-fn test_append_tokens() {
-    let mut a = quote!(a);
-    let b = quote!(b);
-    a.append_all(b);
-    assert_eq!("a b", a.to_string());
-}
-
-#[test]
-fn test_format_ident() {
-    let id0 = format_ident!("Aa");
-    let id1 = format_ident!("Hello{x}", x = id0);
-    let id2 = format_ident!("Hello{x}", x = 5usize);
-    let id3 = format_ident!("Hello{}_{x}", id0, x = 10usize);
-    let id4 = format_ident!("Aa", span = Span::call_site());
-    let id5 = format_ident!("Hello{}", Cow::Borrowed("World"));
-
-    assert_eq!(id0, "Aa");
-    assert_eq!(id1, "HelloAa");
-    assert_eq!(id2, "Hello5");
-    assert_eq!(id3, "HelloAa_10");
-    assert_eq!(id4, "Aa");
-    assert_eq!(id5, "HelloWorld");
-}
-
-#[test]
-fn test_format_ident_strip_raw() {
-    let id = format_ident!("r#struct");
-    let my_id = format_ident!("MyId{}", id);
-    let raw_my_id = format_ident!("r#MyId{}", id);
-
-    assert_eq!(id, "r#struct");
-    assert_eq!(my_id, "MyIdstruct");
-    assert_eq!(raw_my_id, "r#MyIdstruct");
-}
-
-#[test]
-fn test_outer_line_comment() {
-    let tokens = quote! {
-        /// doc
-    };
-    let expected = "# [doc = r\" doc\"]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_inner_line_comment() {
-    let tokens = quote! {
-        //! doc
-    };
-    let expected = "# ! [doc = r\" doc\"]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_outer_block_comment() {
-    let tokens = quote! {
-        /** doc */
-    };
-    let expected = "# [doc = r\" doc \"]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_inner_block_comment() {
-    let tokens = quote! {
-        /*! doc */
-    };
-    let expected = "# ! [doc = r\" doc \"]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_outer_attr() {
-    let tokens = quote! {
-        #[inline]
-    };
-    let expected = "# [inline]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_inner_attr() {
-    let tokens = quote! {
-        #![no_std]
-    };
-    let expected = "# ! [no_std]";
-    assert_eq!(expected, tokens.to_string());
-}
-
-// https://github.com/dtolnay/quote/issues/130
-#[test]
-fn test_star_after_repetition() {
-    let c = vec!['0', '1'];
-    let tokens = quote! {
-        #(
-            f(#c);
-        )*
-        *out = None;
-    };
-    let expected = "f ('0') ; f ('1') ; * out = None ;";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_quote_raw_id() {
-    let id = quote!(r#raw_id);
-    assert_eq!(id.to_string(), "r#raw_id");
-}
diff --git a/vendor/quote/tests/ui/does-not-have-iter-interpolated-dup.rs b/vendor/quote/tests/ui/does-not-have-iter-interpolated-dup.rs
deleted file mode 100644
index 0a39f415..00000000
--- a/vendor/quote/tests/ui/does-not-have-iter-interpolated-dup.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use quote::quote;
-
-fn main() {
-    let nonrep = "";
-
-    // Without some protection against repetitions with no iterator somewhere
-    // inside, this would loop infinitely.
-    quote!(#(#nonrep #nonrep)*);
-}
diff --git a/vendor/quote/tests/ui/does-not-have-iter-interpolated.rs b/vendor/quote/tests/ui/does-not-have-iter-interpolated.rs
deleted file mode 100644
index 2c740cc0..00000000
--- a/vendor/quote/tests/ui/does-not-have-iter-interpolated.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use quote::quote;
-
-fn main() {
-    let nonrep = "";
-
-    // Without some protection against repetitions with no iterator somewhere
-    // inside, this would loop infinitely.
-    quote!(#(#nonrep)*);
-}
diff --git a/vendor/quote/tests/ui/does-not-have-iter-separated.rs b/vendor/quote/tests/ui/does-not-have-iter-separated.rs
deleted file mode 100644
index c027243d..00000000
--- a/vendor/quote/tests/ui/does-not-have-iter-separated.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use quote::quote;
-
-fn main() {
-    quote!(#(a b),*);
-}
diff --git a/vendor/quote/tests/ui/does-not-have-iter.rs b/vendor/quote/tests/ui/does-not-have-iter.rs
deleted file mode 100644
index 8908353b..00000000
--- a/vendor/quote/tests/ui/does-not-have-iter.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use quote::quote;
-
-fn main() {
-    quote!(#(a b)*);
-}
diff --git a/vendor/quote/tests/ui/not-quotable.rs b/vendor/quote/tests/ui/not-quotable.rs
deleted file mode 100644
index f991c188..00000000
--- a/vendor/quote/tests/ui/not-quotable.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use quote::quote;
-use std::net::Ipv4Addr;
-
-fn main() {
-    let ip = Ipv4Addr::LOCALHOST;
-    let _ = quote! { #ip };
-}
diff --git a/vendor/quote/tests/ui/not-repeatable.rs b/vendor/quote/tests/ui/not-repeatable.rs
deleted file mode 100644
index a8f0fe77..00000000
--- a/vendor/quote/tests/ui/not-repeatable.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use quote::quote;
-
-struct Ipv4Addr;
-
-fn main() {
-    let ip = Ipv4Addr;
-    let _ = quote! { #(#ip)* };
-}
diff --git a/vendor/quote/tests/ui/wrong-type-span.rs b/vendor/quote/tests/ui/wrong-type-span.rs
deleted file mode 100644
index 1ce391c8..00000000
--- a/vendor/quote/tests/ui/wrong-type-span.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use quote::quote_spanned;
-
-fn main() {
-    let span = "";
-    let x = 0;
-    quote_spanned!(span=> #x);
-}
diff --git a/vendor/serde/.cargo-checksum.json b/vendor/serde/.cargo-checksum.json
deleted file mode 100644
index d44c6da7..00000000
--- a/vendor/serde/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"6d29815d77bf771150eb70b68cb7e153c745d4933fee235555204f92bb340c7a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"5cf9d2158d70048a2916360ad59d9079f6233c6f68781a7a792e70f8b772d8ce","build.rs":"adfdafeb547084efb49f2845325b97f7105e48fa9e8c5045d0bf6c3597d28d14","crates-io.md":"25ed421fe25d0f6f74c4b78674144bef2843a5f78bf552d0a8ec633be69d282b","src/de/ignored_any.rs":"c69d6071191c2075372218442e9e73991335c6b4be18736a7a789f04bb305525","src/de/impls.rs":"8505b47b4fa97e426bedf97082005ee2d5700bfac0da41da9127c9826004c163","src/de/mod.rs":"5c176d8d909910a100f67eb26de8228c3e6465886100cdc3bcc146c16aec111e","src/de/seed.rs":"e8cf0233afe0af5b8fb9e4c94f301c92729c5ba417280af9e2201b732e374a72","src/de/utf8.rs":"f17524ee0af98ec3abcfd7d0b812fbd1033263bd8e2ce2f57c1e1999ce153558","src/de/value.rs":"82d530d0bc50cba75a095c819b4269d58229a7384043f7f6e674891cc6dae7bb","src/integer128.rs":"12f6ce6a513c1c293398db38cf1d3ea7c0c5a6717152621bcba61f49abc7b5b1","src/lib.rs":"5d3bbac10e459e7c4001cc790bdad2acfc660214d9be1e41ebd63a9056541a75","src/macros.rs":"3d695a51f0a07f9f719dcb5620012c21a1b084c06a6283349cabf574ceba8123","src/private/de.rs":"abcd02697fc887d6a9c450dfa1ceb640e069683532998ed4ba3c0b859b4744d7","src/private/doc.rs":"e9801a43c3088fccd5f1fac76416698f948e65b647024aa9da17d673e1e8c217","src/private/mod.rs":"761d198c739508117beeaae44ae4e11769aaa6c2e9a4acf584eb9adc1952879f","src/private/ser.rs":"3a90dfb5c17e81bf1d959fed60a9477713498e9d0934463627c98709132f066e","src/private/size_hint.rs":"605521227e9ba3100fbb9d5ea7fd5853385097c35015ce6908bd5f1ea20d59ad","src/ser/fmt.rs":"7827ed07fd8897e6324f75625ba0c926a4c4e7ec2914cd067391ce54d942ac7b","src/ser/impls.rs":"c99000b33b2b7cb1c9b275f769f0cb5dd6ecb3caf260b66f2d0157e6faf04d96","src/ser/impossible.rs":"db17913522c1c27389c5a085113911353b9813c1b116518681362e7c8b692c3a","src/ser/mod.rs":"4f686acd03f310a966194ef225a0cec5f96810bf73f636f670601c3d2d9018c6","src/std_error.rs":"3aac687856c035517fae44ed2906dd4a1e3184bae4bf613adcdeb73f74126c57"},"package":"8b9875c23cf305cd1fd7eb77234cbb705f21ea6a72c637a5c6db5fe4b8e7f008"}
\ No newline at end of file
diff --git a/vendor/serde/Cargo.toml b/vendor/serde/Cargo.toml
deleted file mode 100644
index b119a61a..00000000
--- a/vendor/serde/Cargo.toml
+++ /dev/null
@@ -1,44 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-rust-version = "1.15"
-name = "serde"
-version = "1.0.132"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-build = "build.rs"
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-description = "A generic serialization/deserialization framework"
-homepage = "https://serde.rs"
-documentation = "https://docs.serde.rs/serde/"
-readme = "crates-io.md"
-keywords = ["serde", "serialization", "no_std"]
-categories = ["encoding"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/serde-rs/serde"
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[package.metadata.playground]
-features = ["derive", "rc"]
-[dependencies.serde_derive]
-version = "=1.0.132"
-optional = true
-[dev-dependencies.serde_derive]
-version = "1.0"
-
-[features]
-alloc = []
-default = ["std"]
-derive = ["serde_derive"]
-rc = []
-std = []
-unstable = []
diff --git a/vendor/serde/LICENSE-APACHE b/vendor/serde/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/serde/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/serde/LICENSE-MIT b/vendor/serde/LICENSE-MIT
deleted file mode 100644
index 31aa7938..00000000
--- a/vendor/serde/LICENSE-MIT
+++ /dev/null
@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/serde/README.md b/vendor/serde/README.md
deleted file mode 100644
index 14b00982..00000000
--- a/vendor/serde/README.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
-
-[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/serde/CI/master
-[actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
-[Latest Version]: https://img.shields.io/crates/v/serde.svg
-[crates.io]: https://crates.io/crates/serde
-[serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
-[serde_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-rustc_1.31+-lightgray.svg
-[Rust 1.13]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
-[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-You may be looking for:
-
-- [An overview of Serde](https://serde.rs/)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-<details>
-<summary>
-Click to show Cargo.toml.
-<a href="https://play.rust-lang.org/?edition=2018&gist=72755f28f99afc95e01d63174b28c1f5" target="_blank">Run this code in the playground.</a>
-</summary>
-
-```toml
-[dependencies]
-
-# The core APIs, including the Serialize and Deserialize traits. Always
-# required when using Serde. The "derive" feature is only required when
-# using #[derive(Serialize, Deserialize)] to make Serde work with structs
-# and enums defined in your crate.
-serde = { version = "1.0", features = ["derive"] }
-
-# Each data format lives in its own crate; the sample code below uses JSON
-# but you may be using a different one.
-serde_json = "1.0"
-```
-
-</details>
-<p></p>
-
-```rust
-use serde::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
-}
-```
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
-
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/serde/build.rs b/vendor/serde/build.rs
deleted file mode 100644
index c5307ab4..00000000
--- a/vendor/serde/build.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use std::env;
-use std::process::Command;
-use std::str::{self, FromStr};
-
-// The rustc-cfg strings below are *not* public API. Please let us know by
-// opening a GitHub issue if your build environment requires some way to enable
-// these cfgs other than by executing our build script.
-fn main() {
-    let minor = match rustc_minor_version() {
-        Some(minor) => minor,
-        None => return,
-    };
-
-    let target = env::var("TARGET").unwrap();
-    let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten";
-
-    // std::collections::Bound was stabilized in Rust 1.17
-    // but it was moved to core::ops later in Rust 1.26:
-    // https://doc.rust-lang.org/core/ops/enum.Bound.html
-    if minor >= 26 {
-        println!("cargo:rustc-cfg=ops_bound");
-    } else if minor >= 17 && cfg!(feature = "std") {
-        println!("cargo:rustc-cfg=collections_bound");
-    }
-
-    // core::cmp::Reverse stabilized in Rust 1.19:
-    // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
-    if minor >= 19 {
-        println!("cargo:rustc-cfg=core_reverse");
-    }
-
-    // CString::into_boxed_c_str and PathBuf::into_boxed_path stabilized in Rust 1.20:
-    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
-    // https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.into_boxed_path
-    if minor >= 20 {
-        println!("cargo:rustc-cfg=de_boxed_c_str");
-        println!("cargo:rustc-cfg=de_boxed_path");
-    }
-
-    // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
-    // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
-    // https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-From<Box<T>>
-    if minor >= 21 {
-        println!("cargo:rustc-cfg=de_rc_dst");
-    }
-
-    // Duration available in core since Rust 1.25:
-    // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
-    if minor >= 25 {
-        println!("cargo:rustc-cfg=core_duration");
-    }
-
-    // 128-bit integers stabilized in Rust 1.26:
-    // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
-    //
-    // Disabled on Emscripten targets before Rust 1.40 since
-    // Emscripten did not support 128-bit integers until Rust 1.40
-    // (https://github.com/rust-lang/rust/pull/65251)
-    if minor >= 26 && (!emscripten || minor >= 40) {
-        println!("cargo:rustc-cfg=integer128");
-    }
-
-    // Inclusive ranges methods stabilized in Rust 1.27:
-    // https://github.com/rust-lang/rust/pull/50758
-    // Also Iterator::try_for_each:
-    // https://blog.rust-lang.org/2018/06/21/Rust-1.27.html#library-stabilizations
-    if minor >= 27 {
-        println!("cargo:rustc-cfg=range_inclusive");
-        println!("cargo:rustc-cfg=iterator_try_fold");
-    }
-
-    // Non-zero integers stabilized in Rust 1.28:
-    // https://blog.rust-lang.org/2018/08/02/Rust-1.28.html#library-stabilizations
-    if minor >= 28 {
-        println!("cargo:rustc-cfg=num_nonzero");
-    }
-
-    // Current minimum supported version of serde_derive crate is Rust 1.31.
-    if minor >= 31 {
-        println!("cargo:rustc-cfg=serde_derive");
-    }
-
-    // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
-    // stabilized in Rust 1.34:
-    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
-    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
-    if minor >= 34 {
-        println!("cargo:rustc-cfg=core_try_from");
-        println!("cargo:rustc-cfg=num_nonzero_signed");
-        println!("cargo:rustc-cfg=systemtime_checked_add");
-
-        // Whitelist of archs that support std::sync::atomic module. Ideally we
-        // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
-        // Instead this is based on rustc's compiler/rustc_target/src/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el")
-            || target.starts_with("riscv64");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if has_atomic64 {
-            println!("cargo:rustc-cfg=std_atomic64");
-        }
-        if has_atomic32 {
-            println!("cargo:rustc-cfg=std_atomic");
-        }
-    }
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = match env::var_os("RUSTC") {
-        Some(rustc) => rustc,
-        None => return None,
-    };
-
-    let output = match Command::new(rustc).arg("--version").output() {
-        Ok(output) => output,
-        Err(_) => return None,
-    };
-
-    let version = match str::from_utf8(&output.stdout) {
-        Ok(version) => version,
-        Err(_) => return None,
-    };
-
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-
-    let next = match pieces.next() {
-        Some(next) => next,
-        None => return None,
-    };
-
-    u32::from_str(next).ok()
-}
diff --git a/vendor/serde/crates-io.md b/vendor/serde/crates-io.md
deleted file mode 100644
index 07757614..00000000
--- a/vendor/serde/crates-io.md
+++ /dev/null
@@ -1,62 +0,0 @@
-<!-- Serde readme rendered on crates.io -->
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-You may be looking for:
-
-- [An overview of Serde](https://serde.rs/)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-```rust
-use serde::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
-}
-```
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
-
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
diff --git a/vendor/serde/src/de/ignored_any.rs b/vendor/serde/src/de/ignored_any.rs
deleted file mode 100644
index 1d50f5ec..00000000
--- a/vendor/serde/src/de/ignored_any.rs
+++ /dev/null
@@ -1,243 +0,0 @@
-use lib::*;
-
-use de::{
-    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
-};
-
-/// An efficient way of discarding data from a deserializer.
-///
-/// Think of this like `serde_json::Value` in that it can be deserialized from
-/// any type, except that it does not store any information about the data that
-/// gets deserialized.
-///
-/// ```edition2018
-/// use std::fmt;
-/// use std::marker::PhantomData;
-///
-/// use serde::de::{
-///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
-/// };
-///
-/// /// A seed that can be used to deserialize only the `n`th element of a sequence
-/// /// while efficiently discarding elements of any type before or after index `n`.
-/// ///
-/// /// For example to deserialize only the element at index 3:
-/// ///
-/// /// ```
-/// /// NthElement::new(3).deserialize(deserializer)
-/// /// ```
-/// pub struct NthElement<T> {
-///     n: usize,
-///     marker: PhantomData<T>,
-/// }
-///
-/// impl<T> NthElement<T> {
-///     pub fn new(n: usize) -> Self {
-///         NthElement {
-///             n: n,
-///             marker: PhantomData,
-///         }
-///     }
-/// }
-///
-/// impl<'de, T> Visitor<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(
-///             formatter,
-///             "a sequence in which we care about element {}",
-///             self.n
-///         )
-///     }
-///
-///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-///     where
-///         A: SeqAccess<'de>,
-///     {
-///         // Skip over the first `n` elements.
-///         for i in 0..self.n {
-///             // It is an error if the sequence ends before we get to element `n`.
-///             if seq.next_element::<IgnoredAny>()?.is_none() {
-///                 return Err(de::Error::invalid_length(i, &self));
-///             }
-///         }
-///
-///         // Deserialize the one we care about.
-///         let nth = match seq.next_element()? {
-///             Some(nth) => nth,
-///             None => {
-///                 return Err(de::Error::invalid_length(self.n, &self));
-///             }
-///         };
-///
-///         // Skip over any remaining elements in the sequence after `n`.
-///         while let Some(IgnoredAny) = seq.next_element()? {
-///             // ignore
-///         }
-///
-///         Ok(nth)
-///     }
-/// }
-///
-/// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///     where
-///         D: Deserializer<'de>,
-///     {
-///         deserializer.deserialize_seq(self)
-///     }
-/// }
-///
-/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// # where
-/// #     D: Deserializer<'de>,
-/// # {
-/// // Deserialize only the sequence element at index 3 from this deserializer.
-/// // The element at index 3 is required to be a string. Elements before and
-/// // after index 3 are allowed to be of any type.
-/// let s: String = NthElement::new(3).deserialize(deserializer)?;
-/// #     Ok(())
-/// # }
-/// ```
-#[derive(Copy, Clone, Debug, Default)]
-pub struct IgnoredAny;
-
-impl<'de> Visitor<'de> for IgnoredAny {
-    type Value = IgnoredAny;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("anything at all")
-    }
-
-    #[inline]
-    fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    serde_if_integer128! {
-        #[inline]
-        fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
-    }
-
-    #[inline]
-    fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    serde_if_integer128! {
-        #[inline]
-        fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
-    }
-
-    #[inline]
-    fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = s;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_none<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        while let Some(IgnoredAny) = try!(seq.next_element()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-    where
-        A: MapAccess<'de>,
-    {
-        while let Some((IgnoredAny, IgnoredAny)) = try!(map.next_entry()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = bytes;
-        Ok(IgnoredAny)
-    }
-
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        data.variant::<IgnoredAny>()?.1.newtype_variant()
-    }
-}
-
-impl<'de> Deserialize<'de> for IgnoredAny {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_ignored_any(IgnoredAny)
-    }
-}
diff --git a/vendor/serde/src/de/impls.rs b/vendor/serde/src/de/impls.rs
deleted file mode 100644
index 59d90d2c..00000000
--- a/vendor/serde/src/de/impls.rs
+++ /dev/null
@@ -1,2664 +0,0 @@
-use lib::*;
-
-use de::{
-    Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
-};
-
-#[cfg(any(core_duration, feature = "std", feature = "alloc"))]
-use de::MapAccess;
-
-use seed::InPlaceSeed;
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-use __private::size_hint;
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct UnitVisitor;
-
-impl<'de> Visitor<'de> for UnitVisitor {
-    type Value = ();
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("unit")
-    }
-
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(())
-    }
-}
-
-impl<'de> Deserialize<'de> for () {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_unit(UnitVisitor)
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl<'de> Deserialize<'de> for ! {
-    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Err(Error::custom("cannot deserialize `!`"))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct BoolVisitor;
-
-impl<'de> Visitor<'de> for BoolVisitor {
-    type Value = bool;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a boolean")
-    }
-
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-}
-
-impl<'de> Deserialize<'de> for bool {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_bool(BoolVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! impl_deserialize_num {
-    ($ty:ident, $deserialize:ident $($methods:tt)*) => {
-        impl<'de> Deserialize<'de> for $ty {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct PrimitiveVisitor;
-
-                impl<'de> Visitor<'de> for PrimitiveVisitor {
-                    type Value = $ty;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str(stringify!($ty))
-                    }
-
-                    $($methods)*
-                }
-
-                deserializer.$deserialize(PrimitiveVisitor)
-            }
-        }
-    };
-}
-
-macro_rules! num_self {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(v)
-        }
-    };
-}
-
-macro_rules! num_as_self {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                Ok(v as Self::Value)
-            }
-        )*
-    };
-}
-
-macro_rules! int_to_int {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if Self::Value::min_value() as i64 <= v as i64 && v as i64 <= Self::Value::max_value() as i64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! int_to_uint {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if 0 <= v && v as u64 <= Self::Value::max_value() as u64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! uint_to_self {
-    ($($ty:ident : $visit:ident)*) => {
-        $(
-            #[inline]
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                if v as u64 <= Self::Value::max_value() as u64 {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
-                }
-            }
-        )*
-    };
-}
-
-impl_deserialize_num! {
-    i8, deserialize_i8
-    num_self!(i8:visit_i8);
-    int_to_int!(i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i16, deserialize_i16
-    num_self!(i16:visit_i16);
-    num_as_self!(i8:visit_i8);
-    int_to_int!(i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i32, deserialize_i32
-    num_self!(i32:visit_i32);
-    num_as_self!(i8:visit_i8 i16:visit_i16);
-    int_to_int!(i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i64, deserialize_i64
-    num_self!(i64:visit_i64);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    isize, deserialize_i64
-    num_as_self!(i8:visit_i8 i16:visit_i16);
-    int_to_int!(i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u8, deserialize_u8
-    num_self!(u8:visit_u8);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u16, deserialize_u16
-    num_self!(u16:visit_u16);
-    num_as_self!(u8:visit_u8);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u32, deserialize_u32
-    num_self!(u32:visit_u32);
-    num_as_self!(u8:visit_u8 u16:visit_u16);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u64, deserialize_u64
-    num_self!(u64:visit_u64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-}
-
-impl_deserialize_num! {
-    usize, deserialize_u64
-    num_as_self!(u8:visit_u8 u16:visit_u16);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    f32, deserialize_f32
-    num_self!(f32:visit_f32);
-    num_as_self!(f64:visit_f64);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    f64, deserialize_f64
-    num_self!(f64:visit_f64);
-    num_as_self!(f32:visit_f32);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-serde_if_integer128! {
-    impl_deserialize_num! {
-        i128, deserialize_i128
-        num_self!(i128:visit_i128);
-        num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-
-        #[inline]
-        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v <= i128::max_value() as u128 {
-                Ok(v as i128)
-            } else {
-                Err(Error::invalid_value(Unexpected::Other("u128"), &self))
-            }
-        }
-    }
-
-    impl_deserialize_num! {
-        u128, deserialize_u128
-        num_self!(u128:visit_u128);
-        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-        int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-
-        #[inline]
-        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if 0 <= v {
-                Ok(v as u128)
-            } else {
-                Err(Error::invalid_value(Unexpected::Other("i128"), &self))
-            }
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct CharVisitor;
-
-impl<'de> Visitor<'de> for CharVisitor {
-    type Value = char;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a character")
-    }
-
-    #[inline]
-    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    #[inline]
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let mut iter = v.chars();
-        match (iter.next(), iter.next()) {
-            (Some(c), None) => Ok(c),
-            _ => Err(Error::invalid_value(Unexpected::Str(v), &self)),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for char {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_char(CharVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-struct StringVisitor;
-#[cfg(any(feature = "std", feature = "alloc"))]
-struct StringInPlaceVisitor<'a>(&'a mut String);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de> Visitor<'de> for StringVisitor {
-    type Value = String;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.to_owned())
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match str::from_utf8(v) {
-            Ok(s) => Ok(s.to_owned()),
-            Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-        }
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match String::from_utf8(v) {
-            Ok(s) => Ok(s),
-            Err(e) => Err(Error::invalid_value(
-                Unexpected::Bytes(&e.into_bytes()),
-                &self,
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
-    type Value = ();
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.0.clear();
-        self.0.push_str(v);
-        Ok(())
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        *self.0 = v;
-        Ok(())
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match str::from_utf8(v) {
-            Ok(s) => {
-                self.0.clear();
-                self.0.push_str(s);
-                Ok(())
-            }
-            Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-        }
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match String::from_utf8(v) {
-            Ok(s) => {
-                *self.0 = s;
-                Ok(())
-            }
-            Err(e) => Err(Error::invalid_value(
-                Unexpected::Bytes(&e.into_bytes()),
-                &self,
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de> Deserialize<'de> for String {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(StringVisitor)
-    }
-
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(StringInPlaceVisitor(place))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct StrVisitor;
-
-impl<'a> Visitor<'a> for StrVisitor {
-    type Value = &'a str;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed string")
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v) // so easy
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(StrVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct BytesVisitor;
-
-impl<'a> Visitor<'a> for BytesVisitor {
-    type Value = &'a [u8];
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed byte array")
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.as_bytes())
-    }
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_bytes(BytesVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-struct CStringVisitor;
-
-#[cfg(feature = "std")]
-impl<'de> Visitor<'de> for CStringVisitor {
-    type Value = CString;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("byte array")
-    }
-
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        let len = size_hint::cautious(seq.size_hint());
-        let mut values = Vec::with_capacity(len);
-
-        while let Some(value) = try!(seq.next_element()) {
-            values.push(value);
-        }
-
-        CString::new(values).map_err(Error::custom)
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de> Deserialize<'de> for CString {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_byte_buf(CStringVisitor)
-    }
-}
-
-macro_rules! forwarded_impl {
-    (
-        $(#[doc = $doc:tt])*
-        ( $($id: ident),* ), $ty: ty, $func: expr
-    ) => {
-        $(#[doc = $doc])*
-        impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                Deserialize::deserialize(deserializer).map($func)
-            }
-        }
-    }
-}
-
-#[cfg(all(feature = "std", de_boxed_c_str))]
-forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
-
-#[cfg(core_reverse)]
-forwarded_impl!((T), Reverse<T>, Reverse);
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct OptionVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<'de, T> Visitor<'de> for OptionVisitor<T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = Option<T>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("option")
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(None)
-    }
-
-    #[inline]
-    fn visit_none<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(None)
-    }
-
-    #[inline]
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer).map(Some)
-    }
-
-    #[doc(hidden)]
-    fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
-    where
-        D: Deserializer<'de>,
-    {
-        Ok(T::deserialize(deserializer).ok())
-    }
-}
-
-impl<'de, T> Deserialize<'de> for Option<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_option(OptionVisitor {
-            marker: PhantomData,
-        })
-    }
-
-    // The Some variant's repr is opaque, so we can't play cute tricks with its
-    // tag to have deserialize_in_place build the content in place unconditionally.
-    //
-    // FIXME: investigate whether branching on the old value being Some to
-    // deserialize_in_place the value is profitable (probably data-dependent?)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct PhantomDataVisitor<T: ?Sized> {
-    marker: PhantomData<T>,
-}
-
-impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
-    type Value = PhantomData<T>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("unit")
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(PhantomData)
-    }
-}
-
-impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let visitor = PhantomDataVisitor {
-            marker: PhantomData,
-        };
-        deserializer.deserialize_unit_struct("PhantomData", visitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-macro_rules! seq_impl {
-    (
-        $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
-        $access:ident,
-        $clear:expr,
-        $with_capacity:expr,
-        $reserve:expr,
-        $insert:expr
-    ) => {
-        impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty<T $(, $typaram)*>
-        where
-            T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-            $($typaram: $bound1 $(+ $bound2)*,)*
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct SeqVisitor<T $(, $typaram)*> {
-                    marker: PhantomData<$ty<T $(, $typaram)*>>,
-                }
-
-                impl<'de, T $(, $typaram)*> Visitor<'de> for SeqVisitor<T $(, $typaram)*>
-                where
-                    T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-                    $($typaram: $bound1 $(+ $bound2)*,)*
-                {
-                    type Value = $ty<T $(, $typaram)*>;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a sequence")
-                    }
-
-                    #[inline]
-                    fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: SeqAccess<'de>,
-                    {
-                        let mut values = $with_capacity;
-
-                        while let Some(value) = try!($access.next_element()) {
-                            $insert(&mut values, value);
-                        }
-
-                        Ok(values)
-                    }
-                }
-
-                let visitor = SeqVisitor { marker: PhantomData };
-                deserializer.deserialize_seq(visitor)
-            }
-
-            fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct SeqInPlaceVisitor<'a, T: 'a $(, $typaram: 'a)*>(&'a mut $ty<T $(, $typaram)*>);
-
-                impl<'a, 'de, T $(, $typaram)*> Visitor<'de> for SeqInPlaceVisitor<'a, T $(, $typaram)*>
-                where
-                    T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-                    $($typaram: $bound1 $(+ $bound2)*,)*
-                {
-                    type Value = ();
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a sequence")
-                    }
-
-                    #[inline]
-                    fn visit_seq<A>(mut self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: SeqAccess<'de>,
-                    {
-                        $clear(&mut self.0);
-                        $reserve(&mut self.0, size_hint::cautious($access.size_hint()));
-
-                        // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList)
-                        while let Some(value) = try!($access.next_element()) {
-                            $insert(&mut self.0, value);
-                        }
-
-                        Ok(())
-                    }
-                }
-
-                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
-            }
-        }
-    }
-}
-
-// Dummy impl of reserve
-#[cfg(any(feature = "std", feature = "alloc"))]
-fn nop_reserve<T>(_seq: T, _n: usize) {}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(
-    BinaryHeap<T: Ord>,
-    seq,
-    BinaryHeap::clear,
-    BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
-    BinaryHeap::reserve,
-    BinaryHeap::push
-);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(
-    BTreeSet<T: Eq + Ord>,
-    seq,
-    BTreeSet::clear,
-    BTreeSet::new(),
-    nop_reserve,
-    BTreeSet::insert
-);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(
-    LinkedList<T>,
-    seq,
-    LinkedList::clear,
-    LinkedList::new(),
-    nop_reserve,
-    LinkedList::push_back
-);
-
-#[cfg(feature = "std")]
-seq_impl!(
-    HashSet<T: Eq + Hash, S: BuildHasher + Default>,
-    seq,
-    HashSet::clear,
-    HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
-    HashSet::reserve,
-    HashSet::insert);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(
-    VecDeque<T>,
-    seq,
-    VecDeque::clear,
-    VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
-    VecDeque::reserve,
-    VecDeque::push_back
-);
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, T> Deserialize<'de> for Vec<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct VecVisitor<T> {
-            marker: PhantomData<T>,
-        }
-
-        impl<'de, T> Visitor<'de> for VecVisitor<T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = Vec<T>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a sequence")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let mut values = Vec::with_capacity(size_hint::cautious(seq.size_hint()));
-
-                while let Some(value) = try!(seq.next_element()) {
-                    values.push(value);
-                }
-
-                Ok(values)
-            }
-        }
-
-        let visitor = VecVisitor {
-            marker: PhantomData,
-        };
-        deserializer.deserialize_seq(visitor)
-    }
-
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
-
-        impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a sequence")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let hint = size_hint::cautious(seq.size_hint());
-                if let Some(additional) = hint.checked_sub(self.0.len()) {
-                    self.0.reserve(additional);
-                }
-
-                for i in 0..self.0.len() {
-                    let next = {
-                        let next_place = InPlaceSeed(&mut self.0[i]);
-                        try!(seq.next_element_seed(next_place))
-                    };
-                    if next.is_none() {
-                        self.0.truncate(i);
-                        return Ok(());
-                    }
-                }
-
-                while let Some(value) = try!(seq.next_element()) {
-                    self.0.push(value);
-                }
-
-                Ok(())
-            }
-        }
-
-        deserializer.deserialize_seq(VecInPlaceVisitor(place))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct ArrayVisitor<A> {
-    marker: PhantomData<A>,
-}
-struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
-
-impl<A> ArrayVisitor<A> {
-    fn new() -> Self {
-        ArrayVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
-    type Value = [T; 0];
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("an empty array")
-    }
-
-    #[inline]
-    fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        Ok([])
-    }
-}
-
-// Does not require T: Deserialize<'de>.
-impl<'de, T> Deserialize<'de> for [T; 0] {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new())
-    }
-}
-
-macro_rules! array_impls {
-    ($($len:expr => ($($n:tt)+))+) => {
-        $(
-            impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
-            where
-                T: Deserialize<'de>,
-            {
-                type Value = [T; $len];
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str(concat!("an array of length ", $len))
-                }
-
-                #[inline]
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    Ok([$(
-                        match try!(seq.next_element()) {
-                            Some(val) => val,
-                            None => return Err(Error::invalid_length($n, &self)),
-                        }
-                    ),+])
-                }
-            }
-
-            impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]>
-            where
-                T: Deserialize<'de>,
-            {
-                type Value = ();
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str(concat!("an array of length ", $len))
-                }
-
-                #[inline]
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    let mut fail_idx = None;
-                    for (idx, dest) in self.0[..].iter_mut().enumerate() {
-                        if try!(seq.next_element_seed(InPlaceSeed(dest))).is_none() {
-                            fail_idx = Some(idx);
-                            break;
-                        }
-                    }
-                    if let Some(idx) = fail_idx {
-                        return Err(Error::invalid_length(idx, &self));
-                    }
-                    Ok(())
-                }
-            }
-
-            impl<'de, T> Deserialize<'de> for [T; $len]
-            where
-                T: Deserialize<'de>,
-            {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new())
-                }
-
-                fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place))
-                }
-            }
-        )+
-    }
-}
-
-array_impls! {
-    1 => (0)
-    2 => (0 1)
-    3 => (0 1 2)
-    4 => (0 1 2 3)
-    5 => (0 1 2 3 4)
-    6 => (0 1 2 3 4 5)
-    7 => (0 1 2 3 4 5 6)
-    8 => (0 1 2 3 4 5 6 7)
-    9 => (0 1 2 3 4 5 6 7 8)
-    10 => (0 1 2 3 4 5 6 7 8 9)
-    11 => (0 1 2 3 4 5 6 7 8 9 10)
-    12 => (0 1 2 3 4 5 6 7 8 9 10 11)
-    13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
-    14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
-    15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
-    16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
-    17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
-    18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
-    19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
-    20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
-    21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
-    22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
-    23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
-    24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
-    25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
-    26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
-    27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
-    28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
-    29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
-    30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
-    31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
-    32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! tuple_impls {
-    ($($len:tt => ($($n:tt $name:ident)+))+) => {
-        $(
-            impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
-                #[inline]
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    struct TupleVisitor<$($name,)+> {
-                        marker: PhantomData<($($name,)+)>,
-                    }
-
-                    impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> {
-                        type Value = ($($name,)+);
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str(concat!("a tuple of size ", $len))
-                        }
-
-                        #[inline]
-                        #[allow(non_snake_case)]
-                        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                        where
-                            A: SeqAccess<'de>,
-                        {
-                            $(
-                                let $name = match try!(seq.next_element()) {
-                                    Some(value) => value,
-                                    None => return Err(Error::invalid_length($n, &self)),
-                                };
-                            )+
-
-                            Ok(($($name,)+))
-                        }
-                    }
-
-                    deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
-                }
-
-                #[inline]
-                fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+));
-
-                    impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> {
-                        type Value = ();
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str(concat!("a tuple of size ", $len))
-                        }
-
-                        #[inline]
-                        #[allow(non_snake_case)]
-                        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                        where
-                            A: SeqAccess<'de>,
-                        {
-                            $(
-                                if try!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() {
-                                    return Err(Error::invalid_length($n, &self));
-                                }
-                            )+
-
-                            Ok(())
-                        }
-                    }
-
-                    deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place))
-                }
-            }
-        )+
-    }
-}
-
-tuple_impls! {
-    1  => (0 T0)
-    2  => (0 T0 1 T1)
-    3  => (0 T0 1 T1 2 T2)
-    4  => (0 T0 1 T1 2 T2 3 T3)
-    5  => (0 T0 1 T1 2 T2 3 T3 4 T4)
-    6  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
-    7  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
-    8  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
-    9  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
-    10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
-    11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
-    12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
-    13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
-    14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
-    15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
-    16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-macro_rules! map_impl {
-    (
-        $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
-        $access:ident,
-        $with_capacity:expr
-    ) => {
-        impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
-        where
-            K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
-            V: Deserialize<'de>,
-            $($typaram: $bound1 $(+ $bound2)*),*
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct MapVisitor<K, V $(, $typaram)*> {
-                    marker: PhantomData<$ty<K, V $(, $typaram)*>>,
-                }
-
-                impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
-                where
-                    K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
-                    V: Deserialize<'de>,
-                    $($typaram: $bound1 $(+ $bound2)*),*
-                {
-                    type Value = $ty<K, V $(, $typaram)*>;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a map")
-                    }
-
-                    #[inline]
-                    fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: MapAccess<'de>,
-                    {
-                        let mut values = $with_capacity;
-
-                        while let Some((key, value)) = try!($access.next_entry()) {
-                            values.insert(key, value);
-                        }
-
-                        Ok(values)
-                    }
-                }
-
-                let visitor = MapVisitor { marker: PhantomData };
-                deserializer.deserialize_map(visitor)
-            }
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-map_impl!(
-    BTreeMap<K: Ord, V>,
-    map,
-    BTreeMap::new());
-
-#[cfg(feature = "std")]
-map_impl!(
-    HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
-    map,
-    HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-macro_rules! parse_ip_impl {
-    ($expecting:tt $ty:ty; $size:tt) => {
-        impl<'de> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                if deserializer.is_human_readable() {
-                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
-                } else {
-                    <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
-                }
-            }
-        }
-    };
-}
-
-#[cfg(feature = "std")]
-macro_rules! variant_identifier {
-    (
-        $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
-        $expecting_message: expr,
-        $variants_name: ident
-    ) => {
-        enum $name_kind {
-            $( $variant ),*
-        }
-
-        static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];
-
-        impl<'de> Deserialize<'de> for $name_kind {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct KindVisitor;
-
-                impl<'de> Visitor<'de> for KindVisitor {
-                    type Value = $name_kind;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str($expecting_message)
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                $index => Ok($name_kind :: $variant),
-                            )*
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self),),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                stringify!($variant) => Ok($name_kind :: $variant),
-                            )*
-                            _ => Err(Error::unknown_variant(value, $variants_name)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                $bytes => Ok($name_kind :: $variant),
-                            )*
-                            _ => {
-                                match str::from_utf8(value) {
-                                    Ok(value) => Err(Error::unknown_variant(value, $variants_name)),
-                                    Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
-                                }
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(KindVisitor)
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-macro_rules! deserialize_enum {
-    (
-        $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
-        $expecting_message: expr,
-        $deserializer: expr
-    ) => {
-        variant_identifier!{
-            $name_kind ( $($variant; $bytes; $index),* )
-            $expecting_message,
-            VARIANTS
-        }
-
-        struct EnumVisitor;
-        impl<'de> Visitor<'de> for EnumVisitor {
-            type Value = $name;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str(concat!("a ", stringify!($name)))
-            }
-
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match try!(data.variant()) {
-                    $(
-                        ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant),
-                    )*
-                }
-            }
-        }
-        $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor)
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de> Deserialize<'de> for net::IpAddr {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            deserializer.deserialize_str(FromStrVisitor::new("IP address"))
-        } else {
-            use lib::net::IpAddr;
-            deserialize_enum! {
-                IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
-                "`V4` or `V6`",
-                deserializer
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
-
-#[cfg(feature = "std")]
-parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
-
-#[cfg(feature = "std")]
-macro_rules! parse_socket_impl {
-    ($expecting:tt $ty:ty, $new:expr) => {
-        impl<'de> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                if deserializer.is_human_readable() {
-                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
-                } else {
-                    <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
-                }
-            }
-        }
-    };
-}
-
-#[cfg(feature = "std")]
-impl<'de> Deserialize<'de> for net::SocketAddr {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            deserializer.deserialize_str(FromStrVisitor::new("socket address"))
-        } else {
-            use lib::net::SocketAddr;
-            deserialize_enum! {
-                SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
-                "`V4` or `V6`",
-                deserializer
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
-
-#[cfg(feature = "std")]
-parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
-    ip, port, 0, 0
-));
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-struct PathVisitor;
-
-#[cfg(feature = "std")]
-impl<'a> Visitor<'a> for PathVisitor {
-    type Value = &'a Path;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed path")
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.as_ref())
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v)
-            .map(AsRef::as_ref)
-            .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(PathVisitor)
-    }
-}
-
-#[cfg(feature = "std")]
-struct PathBufVisitor;
-
-#[cfg(feature = "std")]
-impl<'de> Visitor<'de> for PathBufVisitor {
-    type Value = PathBuf;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("path string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v)
-            .map(From::from)
-            .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        String::from_utf8(v)
-            .map(From::from)
-            .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self))
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de> Deserialize<'de> for PathBuf {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(PathBufVisitor)
-    }
-}
-
-#[cfg(all(feature = "std", de_boxed_path))]
-forwarded_impl!((), Box<Path>, PathBuf::into_boxed_path);
-
-////////////////////////////////////////////////////////////////////////////////
-
-// If this were outside of the serde crate, it would just use:
-//
-//    #[derive(Deserialize)]
-//    #[serde(variant_identifier)]
-#[cfg(all(feature = "std", any(unix, windows)))]
-variant_identifier! {
-    OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
-    "`Unix` or `Windows`",
-    OSSTR_VARIANTS
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-struct OsStringVisitor;
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-impl<'de> Visitor<'de> for OsStringVisitor {
-    type Value = OsString;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("os string")
-    }
-
-    #[cfg(unix)]
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        use std::os::unix::ffi::OsStringExt;
-
-        match try!(data.variant()) {
-            (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
-            (OsStringKind::Windows, _) => Err(Error::custom(
-                "cannot deserialize Windows OS string on Unix",
-            )),
-        }
-    }
-
-    #[cfg(windows)]
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        use std::os::windows::ffi::OsStringExt;
-
-        match try!(data.variant()) {
-            (OsStringKind::Windows, v) => v
-                .newtype_variant::<Vec<u16>>()
-                .map(|vec| OsString::from_wide(&vec)),
-            (OsStringKind::Unix, _) => Err(Error::custom(
-                "cannot deserialize Unix OS string on Windows",
-            )),
-        }
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-impl<'de> Deserialize<'de> for OsString {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-forwarded_impl!((T), Box<T>, Box::new);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-forwarded_impl!((), Box<str>, String::into_boxed_str);
-
-#[cfg(all(
-    not(de_rc_dst),
-    feature = "rc",
-    any(feature = "std", feature = "alloc")
-))]
-forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Arc` will not attempt to
-    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    (T), Arc<T>, Arc::new
-}
-
-#[cfg(all(
-    not(de_rc_dst),
-    feature = "rc",
-    any(feature = "std", feature = "alloc")
-))]
-forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Rc` will not attempt to
-    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    (T), Rc<T>, Rc::new
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
-where
-    T: ToOwned,
-    T::Owned: Deserialize<'de>,
-{
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::Owned::deserialize(deserializer).map(Cow::Owned)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
-/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        try!(Option::<T>::deserialize(deserializer));
-        Ok(RcWeak::new())
-    }
-}
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
-/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        try!(Option::<T>::deserialize(deserializer));
-        Ok(ArcWeak::new())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
-macro_rules! box_forwarded_impl {
-    (
-        $(#[doc = $doc:tt])*
-        $t:ident
-    ) => {
-        $(#[doc = $doc])*
-        impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
-        where
-            Box<T>: Deserialize<'de>,
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                Box::deserialize(deserializer).map(Into::into)
-            }
-        }
-    };
-}
-
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Rc` will not attempt to
-    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    Rc
-}
-
-#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Arc` will not attempt to
-    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    Arc
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T> Deserialize<'de> for Cell<T>
-where
-    T: Deserialize<'de> + Copy,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer).map(Cell::new)
-    }
-}
-
-forwarded_impl!((T), RefCell<T>, RefCell::new);
-
-#[cfg(feature = "std")]
-forwarded_impl!((T), Mutex<T>, Mutex::new);
-
-#[cfg(feature = "std")]
-forwarded_impl!((T), RwLock<T>, RwLock::new);
-
-////////////////////////////////////////////////////////////////////////////////
-
-// This is a cleaned-up version of the impl generated by:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct Duration {
-//         secs: u64,
-//         nanos: u32,
-//     }
-#[cfg(any(core_duration, feature = "std"))]
-impl<'de> Deserialize<'de> for Duration {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(field_identifier, rename_all = "lowercase")]
-        enum Field {
-            Secs,
-            Nanos,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`secs` or `nanos`")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "secs" => Ok(Field::Secs),
-                            "nanos" => Ok(Field::Nanos),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"secs" => Ok(Field::Secs),
-                            b"nanos" => Ok(Field::Nanos),
-                            _ => {
-                                let value = ::__private::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
-        where
-            E: Error,
-        {
-            static NANOS_PER_SEC: u32 = 1_000_000_000;
-            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
-                Some(_) => Ok(()),
-                None => Err(E::custom("overflow deserializing Duration")),
-            }
-        }
-
-        struct DurationVisitor;
-
-        impl<'de> Visitor<'de> for DurationVisitor {
-            type Value = Duration;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct Duration")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let secs: u64 = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let nanos: u32 = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                try!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut secs: Option<u64> = None;
-                let mut nanos: Option<u32> = None;
-                while let Some(key) = try!(map.next_key()) {
-                    match key {
-                        Field::Secs => {
-                            if secs.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("secs"));
-                            }
-                            secs = Some(try!(map.next_value()));
-                        }
-                        Field::Nanos => {
-                            if nanos.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("nanos"));
-                            }
-                            nanos = Some(try!(map.next_value()));
-                        }
-                    }
-                }
-                let secs = match secs {
-                    Some(secs) => secs,
-                    None => return Err(<A::Error as Error>::missing_field("secs")),
-                };
-                let nanos = match nanos {
-                    Some(nanos) => nanos,
-                    None => return Err(<A::Error as Error>::missing_field("nanos")),
-                };
-                try!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-        }
-
-        const FIELDS: &'static [&'static str] = &["secs", "nanos"];
-        deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-impl<'de> Deserialize<'de> for SystemTime {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // Reuse duration
-        enum Field {
-            Secs,
-            Nanos,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "secs_since_epoch" => Ok(Field::Secs),
-                            "nanos_since_epoch" => Ok(Field::Nanos),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"secs_since_epoch" => Ok(Field::Secs),
-                            b"nanos_since_epoch" => Ok(Field::Nanos),
-                            _ => {
-                                let value = String::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
-        where
-            E: Error,
-        {
-            static NANOS_PER_SEC: u32 = 1_000_000_000;
-            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
-                Some(_) => Ok(()),
-                None => Err(E::custom("overflow deserializing SystemTime epoch offset")),
-            }
-        }
-
-        struct DurationVisitor;
-
-        impl<'de> Visitor<'de> for DurationVisitor {
-            type Value = Duration;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct SystemTime")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let secs: u64 = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let nanos: u32 = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                try!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut secs: Option<u64> = None;
-                let mut nanos: Option<u32> = None;
-                while let Some(key) = try!(map.next_key()) {
-                    match key {
-                        Field::Secs => {
-                            if secs.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field(
-                                    "secs_since_epoch",
-                                ));
-                            }
-                            secs = Some(try!(map.next_value()));
-                        }
-                        Field::Nanos => {
-                            if nanos.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field(
-                                    "nanos_since_epoch",
-                                ));
-                            }
-                            nanos = Some(try!(map.next_value()));
-                        }
-                    }
-                }
-                let secs = match secs {
-                    Some(secs) => secs,
-                    None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
-                };
-                let nanos = match nanos {
-                    Some(nanos) => nanos,
-                    None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
-                };
-                try!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-        }
-
-        const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
-        let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
-        #[cfg(systemtime_checked_add)]
-        let ret = UNIX_EPOCH
-            .checked_add(duration)
-            .ok_or_else(|| D::Error::custom("overflow deserializing SystemTime"));
-        #[cfg(not(systemtime_checked_add))]
-        let ret = Ok(UNIX_EPOCH + duration);
-        ret
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Similar to:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct Range {
-//         start: u64,
-//         end: u32,
-//     }
-impl<'de, Idx> Deserialize<'de> for Range<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let (start, end) = deserializer.deserialize_struct(
-            "Range",
-            range::FIELDS,
-            range::RangeVisitor {
-                expecting: "struct Range",
-                phantom: PhantomData,
-            },
-        )?;
-        Ok(start..end)
-    }
-}
-
-#[cfg(range_inclusive)]
-impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let (start, end) = deserializer.deserialize_struct(
-            "RangeInclusive",
-            range::FIELDS,
-            range::RangeVisitor {
-                expecting: "struct RangeInclusive",
-                phantom: PhantomData,
-            },
-        )?;
-        Ok(RangeInclusive::new(start, end))
-    }
-}
-
-mod range {
-    use lib::*;
-
-    use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
-
-    pub const FIELDS: &'static [&'static str] = &["start", "end"];
-
-    // If this were outside of the serde crate, it would just use:
-    //
-    //    #[derive(Deserialize)]
-    //    #[serde(field_identifier, rename_all = "lowercase")]
-    enum Field {
-        Start,
-        End,
-    }
-
-    impl<'de> Deserialize<'de> for Field {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct FieldVisitor;
-
-            impl<'de> Visitor<'de> for FieldVisitor {
-                type Value = Field;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`start` or `end`")
-                }
-
-                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        "start" => Ok(Field::Start),
-                        "end" => Ok(Field::End),
-                        _ => Err(Error::unknown_field(value, FIELDS)),
-                    }
-                }
-
-                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        b"start" => Ok(Field::Start),
-                        b"end" => Ok(Field::End),
-                        _ => {
-                            let value = ::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&value, FIELDS))
-                        }
-                    }
-                }
-            }
-
-            deserializer.deserialize_identifier(FieldVisitor)
-        }
-    }
-
-    pub struct RangeVisitor<Idx> {
-        pub expecting: &'static str,
-        pub phantom: PhantomData<Idx>,
-    }
-
-    impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
-    where
-        Idx: Deserialize<'de>,
-    {
-        type Value = (Idx, Idx);
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str(self.expecting)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let start: Idx = match try!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(0, &self));
-                }
-            };
-            let end: Idx = match try!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(1, &self));
-                }
-            };
-            Ok((start, end))
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut start: Option<Idx> = None;
-            let mut end: Option<Idx> = None;
-            while let Some(key) = try!(map.next_key()) {
-                match key {
-                    Field::Start => {
-                        if start.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("start"));
-                        }
-                        start = Some(try!(map.next_value()));
-                    }
-                    Field::End => {
-                        if end.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("end"));
-                        }
-                        end = Some(try!(map.next_value()));
-                    }
-                }
-            }
-            let start = match start {
-                Some(start) => start,
-                None => return Err(<A::Error as Error>::missing_field("start")),
-            };
-            let end = match end {
-                Some(end) => end,
-                None => return Err(<A::Error as Error>::missing_field("end")),
-            };
-            Ok((start, end))
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(ops_bound, collections_bound))]
-impl<'de, T> Deserialize<'de> for Bound<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        enum Field {
-            Unbounded,
-            Included,
-            Excluded,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`Unbounded`, `Included` or `Excluded`")
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            0 => Ok(Field::Unbounded),
-                            1 => Ok(Field::Included),
-                            2 => Ok(Field::Excluded),
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "Unbounded" => Ok(Field::Unbounded),
-                            "Included" => Ok(Field::Included),
-                            "Excluded" => Ok(Field::Excluded),
-                            _ => Err(Error::unknown_variant(value, VARIANTS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"Unbounded" => Ok(Field::Unbounded),
-                            b"Included" => Ok(Field::Included),
-                            b"Excluded" => Ok(Field::Excluded),
-                            _ => match str::from_utf8(value) {
-                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
-                                Err(_) => {
-                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self))
-                                }
-                            },
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct BoundVisitor<T>(PhantomData<Bound<T>>);
-
-        impl<'de, T> Visitor<'de> for BoundVisitor<T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = Bound<T>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("enum Bound")
-            }
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match try!(data.variant()) {
-                    (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
-                    (Field::Included, v) => v.newtype_variant().map(Bound::Included),
-                    (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
-                }
-            }
-        }
-
-        const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
-
-        deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! nonzero_integers {
-    ( $( $T: ident, )+ ) => {
-        $(
-            #[cfg(num_nonzero)]
-            impl<'de> Deserialize<'de> for num::$T {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    let value = try!(Deserialize::deserialize(deserializer));
-                    match <num::$T>::new(value) {
-                        Some(nonzero) => Ok(nonzero),
-                        None => Err(Error::custom("expected a non-zero value")),
-                    }
-                }
-            }
-        )+
-    };
-}
-
-nonzero_integers! {
-    NonZeroU8,
-    NonZeroU16,
-    NonZeroU32,
-    NonZeroU64,
-    NonZeroUsize,
-}
-
-#[cfg(num_nonzero_signed)]
-nonzero_integers! {
-    NonZeroI8,
-    NonZeroI16,
-    NonZeroI32,
-    NonZeroI64,
-    NonZeroIsize,
-}
-
-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(num_nonzero_signed)]
-    nonzero_integers! {
-        NonZeroI128,
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T, E> Deserialize<'de> for Result<T, E>
-where
-    T: Deserialize<'de>,
-    E: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(variant_identifier)]
-        enum Field {
-            Ok,
-            Err,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`Ok` or `Err`")
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            0 => Ok(Field::Ok),
-                            1 => Ok(Field::Err),
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "Ok" => Ok(Field::Ok),
-                            "Err" => Ok(Field::Err),
-                            _ => Err(Error::unknown_variant(value, VARIANTS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"Ok" => Ok(Field::Ok),
-                            b"Err" => Ok(Field::Err),
-                            _ => match str::from_utf8(value) {
-                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
-                                Err(_) => {
-                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self))
-                                }
-                            },
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
-
-        impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
-        where
-            T: Deserialize<'de>,
-            E: Deserialize<'de>,
-        {
-            type Value = Result<T, E>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("enum Result")
-            }
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match try!(data.variant()) {
-                    (Field::Ok, v) => v.newtype_variant().map(Ok),
-                    (Field::Err, v) => v.newtype_variant().map(Err),
-                }
-            }
-        }
-
-        const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
-
-        deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T> Deserialize<'de> for Wrapping<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Deserialize::deserialize(deserializer).map(Wrapping)
-    }
-}
-
-#[cfg(all(feature = "std", std_atomic))]
-macro_rules! atomic_impl {
-    ($($ty:ident)*) => {
-        $(
-            impl<'de> Deserialize<'de> for $ty {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    Deserialize::deserialize(deserializer).map(Self::new)
-                }
-            }
-        )*
-    };
-}
-
-#[cfg(all(feature = "std", std_atomic))]
-atomic_impl! {
-    AtomicBool
-    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
-    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
-}
-
-#[cfg(all(feature = "std", std_atomic64))]
-atomic_impl! {
-    AtomicI64 AtomicU64
-}
-
-#[cfg(feature = "std")]
-struct FromStrVisitor<T> {
-    expecting: &'static str,
-    ty: PhantomData<T>,
-}
-
-#[cfg(feature = "std")]
-impl<T> FromStrVisitor<T> {
-    fn new(expecting: &'static str) -> Self {
-        FromStrVisitor {
-            expecting: expecting,
-            ty: PhantomData,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de, T> Visitor<'de> for FromStrVisitor<T>
-where
-    T: str::FromStr,
-    T::Err: fmt::Display,
-{
-    type Value = T;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(self.expecting)
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        s.parse().map_err(Error::custom)
-    }
-}
diff --git a/vendor/serde/src/de/mod.rs b/vendor/serde/src/de/mod.rs
deleted file mode 100644
index 54e2fd64..00000000
--- a/vendor/serde/src/de/mod.rs
+++ /dev/null
@@ -1,2275 +0,0 @@
-//! Generic data structure deserialization framework.
-//!
-//! The two most important traits in this module are [`Deserialize`] and
-//! [`Deserializer`].
-//!
-//!  - **A type that implements `Deserialize` is a data structure** that can be
-//!    deserialized from any data format supported by Serde, and conversely
-//!  - **A type that implements `Deserializer` is a data format** that can
-//!    deserialize any data structure supported by Serde.
-//!
-//! # The Deserialize trait
-//!
-//! Serde provides [`Deserialize`] implementations for many Rust primitive and
-//! standard library types. The complete list is below. All of these can be
-//! deserialized using Serde out of the box.
-//!
-//! Additionally, Serde provides a procedural macro called [`serde_derive`] to
-//! automatically generate [`Deserialize`] implementations for structs and enums
-//! in your program. See the [derive section of the manual] for how to use this.
-//!
-//! In rare cases it may be necessary to implement [`Deserialize`] manually for
-//! some type in your program. See the [Implementing `Deserialize`] section of
-//! the manual for more about this.
-//!
-//! Third-party crates may provide [`Deserialize`] implementations for types
-//! that they expose. For example the [`linked-hash-map`] crate provides a
-//! [`LinkedHashMap<K, V>`] type that is deserializable by Serde because the
-//! crate provides an implementation of [`Deserialize`] for it.
-//!
-//! # The Deserializer trait
-//!
-//! [`Deserializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
-//!
-//! A partial list of well-maintained formats is given on the [Serde
-//! website][data formats].
-//!
-//! # Implementations of Deserialize provided by Serde
-//!
-//! This is a slightly different set of types than what is supported for
-//! serialization. Some types can be serialized by Serde but not deserialized.
-//! One example is `OsStr`.
-//!
-//!  - **Primitive types**:
-//!    - bool
-//!    - i8, i16, i32, i64, i128, isize
-//!    - u8, u16, u32, u64, u128, usize
-//!    - f32, f64
-//!    - char
-//!  - **Compound types**:
-//!    - \[T; 0\] through \[T; 32\]
-//!    - tuples up to size 16
-//!  - **Common standard library types**:
-//!    - String
-//!    - Option\<T\>
-//!    - Result\<T, E\>
-//!    - PhantomData\<T\>
-//!  - **Wrapper types**:
-//!    - Box\<T\>
-//!    - Box\<\[T\]\>
-//!    - Box\<str\>
-//!    - Cow\<'a, T\>
-//!    - Cell\<T\>
-//!    - RefCell\<T\>
-//!    - Mutex\<T\>
-//!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!  - **Collection types**:
-//!    - BTreeMap\<K, V\>
-//!    - BTreeSet\<T\>
-//!    - BinaryHeap\<T\>
-//!    - HashMap\<K, V, H\>
-//!    - HashSet\<T, H\>
-//!    - LinkedList\<T\>
-//!    - VecDeque\<T\>
-//!    - Vec\<T\>
-//!  - **Zero-copy types**:
-//!    - &str
-//!    - &\[u8\]
-//!  - **FFI types**:
-//!    - CString
-//!    - Box\<CStr\>
-//!    - OsString
-//!  - **Miscellaneous standard library types**:
-//!    - Duration
-//!    - SystemTime
-//!    - Path
-//!    - PathBuf
-//!    - Range\<T\>
-//!    - RangeInclusive\<T\>
-//!    - Bound\<T\>
-//!    - num::NonZero*
-//!    - `!` *(unstable)*
-//!  - **Net types**:
-//!    - IpAddr
-//!    - Ipv4Addr
-//!    - Ipv6Addr
-//!    - SocketAddr
-//!    - SocketAddrV4
-//!    - SocketAddrV6
-//!
-//! [Implementing `Deserialize`]: https://serde.rs/impl-deserialize.html
-//! [`Deserialize`]: ../trait.Deserialize.html
-//! [`Deserializer`]: ../trait.Deserializer.html
-//! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`bincode`]: https://github.com/servo/bincode
-//! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
-//! [`serde_derive`]: https://crates.io/crates/serde_derive
-//! [`serde_json`]: https://github.com/serde-rs/json
-//! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
-//! [derive section of the manual]: https://serde.rs/derive.html
-//! [data formats]: https://serde.rs/#data-formats
-
-use lib::*;
-
-////////////////////////////////////////////////////////////////////////////////
-
-pub mod value;
-
-mod ignored_any;
-mod impls;
-mod utf8;
-
-pub use self::ignored_any::IgnoredAny;
-
-#[cfg(feature = "std")]
-#[doc(no_inline)]
-pub use std::error::Error as StdError;
-#[cfg(not(feature = "std"))]
-#[doc(no_inline)]
-pub use std_error::Error as StdError;
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! declare_error_trait {
-    (Error: Sized $(+ $($supertrait:ident)::+)*) => {
-        /// The `Error` trait allows `Deserialize` implementations to create descriptive
-        /// error messages belonging to the `Deserializer` against which they are
-        /// currently running.
-        ///
-        /// Every `Deserializer` declares an `Error` type that encompasses both
-        /// general-purpose deserialization errors as well as errors specific to the
-        /// particular deserialization format. For example the `Error` type of
-        /// `serde_json` can represent errors like an invalid JSON escape sequence or an
-        /// unterminated string literal, in addition to the error cases that are part of
-        /// this trait.
-        ///
-        /// Most deserializers should only need to provide the `Error::custom` method
-        /// and inherit the default behavior for the other methods.
-        ///
-        /// # Example implementation
-        ///
-        /// The [example data format] presented on the website shows an error
-        /// type appropriate for a basic JSON data format.
-        ///
-        /// [example data format]: https://serde.rs/data-format.html
-        pub trait Error: Sized $(+ $($supertrait)::+)* {
-            /// Raised when there is general error when deserializing a type.
-            ///
-            /// The message should not be capitalized and should not end with a period.
-            ///
-            /// ```edition2018
-            /// # use std::str::FromStr;
-            /// #
-            /// # struct IpAddr;
-            /// #
-            /// # impl FromStr for IpAddr {
-            /// #     type Err = String;
-            /// #
-            /// #     fn from_str(_: &str) -> Result<Self, String> {
-            /// #         unimplemented!()
-            /// #     }
-            /// # }
-            /// #
-            /// use serde::de::{self, Deserialize, Deserializer};
-            ///
-            /// impl<'de> Deserialize<'de> for IpAddr {
-            ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            ///     where
-            ///         D: Deserializer<'de>,
-            ///     {
-            ///         let s = String::deserialize(deserializer)?;
-            ///         s.parse().map_err(de::Error::custom)
-            ///     }
-            /// }
-            /// ```
-            fn custom<T>(msg: T) -> Self
-            where
-                T: Display;
-
-            /// Raised when a `Deserialize` receives a type different from what it was
-            /// expecting.
-            ///
-            /// The `unexp` argument provides information about what type was received.
-            /// This is the type that was present in the input file or other source data
-            /// of the Deserializer.
-            ///
-            /// The `exp` argument provides information about what type was being
-            /// expected. This is the type that is written in the program.
-            ///
-            /// For example if we try to deserialize a String out of a JSON file
-            /// containing an integer, the unexpected type is the integer and the
-            /// expected type is the string.
-            #[cold]
-            fn invalid_type(unexp: Unexpected, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
-            }
-
-            /// Raised when a `Deserialize` receives a value of the right type but that
-            /// is wrong for some other reason.
-            ///
-            /// The `unexp` argument provides information about what value was received.
-            /// This is the value that was present in the input file or other source
-            /// data of the Deserializer.
-            ///
-            /// The `exp` argument provides information about what value was being
-            /// expected. This is the type that is written in the program.
-            ///
-            /// For example if we try to deserialize a String out of some binary data
-            /// that is not valid UTF-8, the unexpected value is the bytes and the
-            /// expected value is a string.
-            #[cold]
-            fn invalid_value(unexp: Unexpected, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid value: {}, expected {}", unexp, exp))
-            }
-
-            /// Raised when deserializing a sequence or map and the input data contains
-            /// too many or too few elements.
-            ///
-            /// The `len` argument is the number of elements encountered. The sequence
-            /// or map may have expected more arguments or fewer arguments.
-            ///
-            /// The `exp` argument provides information about what data was being
-            /// expected. For example `exp` might say that a tuple of size 6 was
-            /// expected.
-            #[cold]
-            fn invalid_length(len: usize, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid length {}, expected {}", len, exp))
-            }
-
-            /// Raised when a `Deserialize` enum type received a variant with an
-            /// unrecognized name.
-            #[cold]
-            fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
-                if expected.is_empty() {
-                    Error::custom(format_args!(
-                        "unknown variant `{}`, there are no variants",
-                        variant
-                    ))
-                } else {
-                    Error::custom(format_args!(
-                        "unknown variant `{}`, expected {}",
-                        variant,
-                        OneOf { names: expected }
-                    ))
-                }
-            }
-
-            /// Raised when a `Deserialize` struct type received a field with an
-            /// unrecognized name.
-            #[cold]
-            fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
-                if expected.is_empty() {
-                    Error::custom(format_args!(
-                        "unknown field `{}`, there are no fields",
-                        field
-                    ))
-                } else {
-                    Error::custom(format_args!(
-                        "unknown field `{}`, expected {}",
-                        field,
-                        OneOf { names: expected }
-                    ))
-                }
-            }
-
-            /// Raised when a `Deserialize` struct type expected to receive a required
-            /// field with a particular name but that field was not present in the
-            /// input.
-            #[cold]
-            fn missing_field(field: &'static str) -> Self {
-                Error::custom(format_args!("missing field `{}`", field))
-            }
-
-            /// Raised when a `Deserialize` struct type received more than one of the
-            /// same field.
-            #[cold]
-            fn duplicate_field(field: &'static str) -> Self {
-                Error::custom(format_args!("duplicate field `{}`", field))
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + StdError);
-
-#[cfg(not(feature = "std"))]
-declare_error_trait!(Error: Sized + Debug + Display);
-
-/// `Unexpected` represents an unexpected invocation of any one of the `Visitor`
-/// trait methods.
-///
-/// This is used as an argument to the `invalid_type`, `invalid_value`, and
-/// `invalid_length` methods of the `Error` trait to build error messages.
-///
-/// ```edition2018
-/// # use std::fmt;
-/// #
-/// # use serde::de::{self, Unexpected, Visitor};
-/// #
-/// # struct Example;
-/// #
-/// # impl<'de> Visitor<'de> for Example {
-/// #     type Value = ();
-/// #
-/// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-/// #         write!(formatter, "definitely not a boolean")
-/// #     }
-/// #
-/// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-/// where
-///     E: de::Error,
-/// {
-///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
-/// }
-/// # }
-/// ```
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum Unexpected<'a> {
-    /// The input contained a boolean value that was not expected.
-    Bool(bool),
-
-    /// The input contained an unsigned integer `u8`, `u16`, `u32` or `u64` that
-    /// was not expected.
-    Unsigned(u64),
-
-    /// The input contained a signed integer `i8`, `i16`, `i32` or `i64` that
-    /// was not expected.
-    Signed(i64),
-
-    /// The input contained a floating point `f32` or `f64` that was not
-    /// expected.
-    Float(f64),
-
-    /// The input contained a `char` that was not expected.
-    Char(char),
-
-    /// The input contained a `&str` or `String` that was not expected.
-    Str(&'a str),
-
-    /// The input contained a `&[u8]` or `Vec<u8>` that was not expected.
-    Bytes(&'a [u8]),
-
-    /// The input contained a unit `()` that was not expected.
-    Unit,
-
-    /// The input contained an `Option<T>` that was not expected.
-    Option,
-
-    /// The input contained a newtype struct that was not expected.
-    NewtypeStruct,
-
-    /// The input contained a sequence that was not expected.
-    Seq,
-
-    /// The input contained a map that was not expected.
-    Map,
-
-    /// The input contained an enum that was not expected.
-    Enum,
-
-    /// The input contained a unit variant that was not expected.
-    UnitVariant,
-
-    /// The input contained a newtype variant that was not expected.
-    NewtypeVariant,
-
-    /// The input contained a tuple variant that was not expected.
-    TupleVariant,
-
-    /// The input contained a struct variant that was not expected.
-    StructVariant,
-
-    /// A message stating what uncategorized thing the input contained that was
-    /// not expected.
-    ///
-    /// The message should be a noun or noun phrase, not capitalized and without
-    /// a period. An example message is "unoriginal superhero".
-    Other(&'a str),
-}
-
-impl<'a> fmt::Display for Unexpected<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        use self::Unexpected::*;
-        match *self {
-            Bool(b) => write!(formatter, "boolean `{}`", b),
-            Unsigned(i) => write!(formatter, "integer `{}`", i),
-            Signed(i) => write!(formatter, "integer `{}`", i),
-            Float(f) => write!(formatter, "floating point `{}`", f),
-            Char(c) => write!(formatter, "character `{}`", c),
-            Str(s) => write!(formatter, "string {:?}", s),
-            Bytes(_) => write!(formatter, "byte array"),
-            Unit => write!(formatter, "unit value"),
-            Option => write!(formatter, "Option value"),
-            NewtypeStruct => write!(formatter, "newtype struct"),
-            Seq => write!(formatter, "sequence"),
-            Map => write!(formatter, "map"),
-            Enum => write!(formatter, "enum"),
-            UnitVariant => write!(formatter, "unit variant"),
-            NewtypeVariant => write!(formatter, "newtype variant"),
-            TupleVariant => write!(formatter, "tuple variant"),
-            StructVariant => write!(formatter, "struct variant"),
-            Other(other) => formatter.write_str(other),
-        }
-    }
-}
-
-/// `Expected` represents an explanation of what data a `Visitor` was expecting
-/// to receive.
-///
-/// This is used as an argument to the `invalid_type`, `invalid_value`, and
-/// `invalid_length` methods of the `Error` trait to build error messages. The
-/// message should be a noun or noun phrase that completes the sentence "This
-/// Visitor expects to receive ...", for example the message could be "an
-/// integer between 0 and 64". The message should not be capitalized and should
-/// not end with a period.
-///
-/// Within the context of a `Visitor` implementation, the `Visitor` itself
-/// (`&self`) is an implementation of this trait.
-///
-/// ```edition2018
-/// # use std::fmt;
-/// #
-/// # use serde::de::{self, Unexpected, Visitor};
-/// #
-/// # struct Example;
-/// #
-/// # impl<'de> Visitor<'de> for Example {
-/// #     type Value = ();
-/// #
-/// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-/// #         write!(formatter, "definitely not a boolean")
-/// #     }
-/// #
-/// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-/// where
-///     E: de::Error,
-/// {
-///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
-/// }
-/// # }
-/// ```
-///
-/// Outside of a `Visitor`, `&"..."` can be used.
-///
-/// ```edition2018
-/// # use serde::de::{self, Unexpected};
-/// #
-/// # fn example<E>() -> Result<(), E>
-/// # where
-/// #     E: de::Error,
-/// # {
-/// #     let v = true;
-/// return Err(de::Error::invalid_type(Unexpected::Bool(v), &"a negative integer"));
-/// # }
-/// ```
-pub trait Expected {
-    /// Format an explanation of what data was being expected. Same signature as
-    /// the `Display` and `Debug` traits.
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
-}
-
-impl<'de, T> Expected for T
-where
-    T: Visitor<'de>,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.expecting(formatter)
-    }
-}
-
-impl<'a> Expected for &'a str {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(self)
-    }
-}
-
-impl<'a> Display for Expected + 'a {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Expected::fmt(self, formatter)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data structure** that can be deserialized from any data format supported
-/// by Serde.
-///
-/// Serde provides `Deserialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][de]. All of these can
-/// be deserialized using Serde out of the box.
-///
-/// Additionally, Serde provides a procedural macro called `serde_derive` to
-/// automatically generate `Deserialize` implementations for structs and enums
-/// in your program. See the [derive section of the manual][derive] for how to
-/// use this.
-///
-/// In rare cases it may be necessary to implement `Deserialize` manually for
-/// some type in your program. See the [Implementing
-/// `Deserialize`][impl-deserialize] section of the manual for more about this.
-///
-/// Third-party crates may provide `Deserialize` implementations for types that
-/// they expose. For example the `linked-hash-map` crate provides a
-/// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate
-/// provides an implementation of `Deserialize` for it.
-///
-/// [de]: https://docs.serde.rs/serde/de/index.html
-/// [derive]: https://serde.rs/derive.html
-/// [impl-deserialize]: https://serde.rs/impl-deserialize.html
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by `Self` when deserialized. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-pub trait Deserialize<'de>: Sized {
-    /// Deserialize this value from the given Serde deserializer.
-    ///
-    /// See the [Implementing `Deserialize`][impl-deserialize] section of the
-    /// manual for more information about how to implement this method.
-    ///
-    /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>;
-
-    /// Deserializes a value into `self` from the given Deserializer.
-    ///
-    /// The purpose of this method is to allow the deserializer to reuse
-    /// resources and avoid copies. As such, if this method returns an error,
-    /// `self` will be in an indeterminate state where some parts of the struct
-    /// have been overwritten. Although whatever state that is will be
-    /// memory-safe.
-    ///
-    /// This is generally useful when repeatedly deserializing values that
-    /// are processed one at a time, where the value of `self` doesn't matter
-    /// when the next deserialization occurs.
-    ///
-    /// If you manually implement this, your recursive deserializations should
-    /// use `deserialize_in_place`.
-    ///
-    /// This method is stable and an official public API, but hidden from the
-    /// documentation because it is almost never what newbies are looking for.
-    /// Showing it in rustdoc would cause it to be featured more prominently
-    /// than it deserves.
-    #[doc(hidden)]
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // Default implementation just delegates to `deserialize` impl.
-        *place = Deserialize::deserialize(deserializer)?;
-        Ok(())
-    }
-}
-
-/// A data structure that can be deserialized without borrowing any data from
-/// the deserializer.
-///
-/// This is primarily useful for trait bounds on functions. For example a
-/// `from_str` function may be able to deserialize a data structure that borrows
-/// from the input string, but a `from_reader` function may only deserialize
-/// owned data.
-///
-/// ```edition2018
-/// # use serde::de::{Deserialize, DeserializeOwned};
-/// # use std::io::{Read, Result};
-/// #
-/// # trait Ignore {
-/// fn from_str<'a, T>(s: &'a str) -> Result<T>
-/// where
-///     T: Deserialize<'a>;
-///
-/// fn from_reader<R, T>(rdr: R) -> Result<T>
-/// where
-///     R: Read,
-///     T: DeserializeOwned;
-/// # }
-/// ```
-///
-/// # Lifetime
-///
-/// The relationship between `Deserialize` and `DeserializeOwned` in trait
-/// bounds is explained in more detail on the page [Understanding deserializer
-/// lifetimes].
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
-impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
-
-/// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
-/// ever find yourself looking for a way to pass data into a `Deserialize` impl,
-/// this trait is the way to do it.
-///
-/// As one example of stateful deserialization consider deserializing a JSON
-/// array into an existing buffer. Using the `Deserialize` trait we could
-/// deserialize a JSON array into a `Vec<T>` but it would be a freshly allocated
-/// `Vec<T>`; there is no way for `Deserialize` to reuse a previously allocated
-/// buffer. Using `DeserializeSeed` instead makes this possible as in the
-/// example code below.
-///
-/// The canonical API for stateless deserialization looks like this:
-///
-/// ```edition2018
-/// # use serde::Deserialize;
-/// #
-/// # enum Error {}
-/// #
-/// fn func<'de, T: Deserialize<'de>>() -> Result<T, Error>
-/// # {
-/// #     unimplemented!()
-/// # }
-/// ```
-///
-/// Adjusting an API like this to support stateful deserialization is a matter
-/// of accepting a seed as input:
-///
-/// ```edition2018
-/// # use serde::de::DeserializeSeed;
-/// #
-/// # enum Error {}
-/// #
-/// fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
-/// # {
-/// #     let _ = seed;
-/// #     unimplemented!()
-/// # }
-/// ```
-///
-/// In practice the majority of deserialization is stateless. An API expecting a
-/// seed can be appeased by passing `std::marker::PhantomData` as a seed in the
-/// case of stateless deserialization.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by `Self::Value` when deserialized. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need
-/// to deserialize it into a flat representation like `vec![1, 2, 3, 4, 5, 6]`.
-/// Allocating a brand new `Vec<T>` for each subarray would be slow. Instead we
-/// would like to allocate a single `Vec<T>` and then deserialize each subarray
-/// into it. This requires stateful deserialization using the `DeserializeSeed`
-/// trait.
-///
-/// ```edition2018
-/// use std::fmt;
-/// use std::marker::PhantomData;
-///
-/// use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
-///
-/// // A DeserializeSeed implementation that uses stateful deserialization to
-/// // append array elements onto the end of an existing vector. The preexisting
-/// // state ("seed") in this case is the Vec<T>. The `deserialize` method of
-/// // `ExtendVec` will be traversing the inner arrays of the JSON input and
-/// // appending each integer into the existing Vec.
-/// struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);
-///
-/// impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     // The return type of the `deserialize` method. This implementation
-///     // appends onto an existing vector but does not create any new data
-///     // structure, so the return type is ().
-///     type Value = ();
-///
-///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///     where
-///         D: Deserializer<'de>,
-///     {
-///         // Visitor implementation that will walk an inner array of the JSON
-///         // input.
-///         struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);
-///
-///         impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>
-///         where
-///             T: Deserialize<'de>,
-///         {
-///             type Value = ();
-///
-///             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///                 write!(formatter, "an array of integers")
-///             }
-///
-///             fn visit_seq<A>(self, mut seq: A) -> Result<(), A::Error>
-///             where
-///                 A: SeqAccess<'de>,
-///             {
-///                 // Visit each element in the inner array and push it onto
-///                 // the existing vector.
-///                 while let Some(elem) = seq.next_element()? {
-///                     self.0.push(elem);
-///                 }
-///                 Ok(())
-///             }
-///         }
-///
-///         deserializer.deserialize_seq(ExtendVecVisitor(self.0))
-///     }
-/// }
-///
-/// // Visitor implementation that will walk the outer array of the JSON input.
-/// struct FlattenedVecVisitor<T>(PhantomData<T>);
-///
-/// impl<'de, T> Visitor<'de> for FlattenedVecVisitor<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     // This Visitor constructs a single Vec<T> to hold the flattened
-///     // contents of the inner arrays.
-///     type Value = Vec<T>;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(formatter, "an array of arrays")
-///     }
-///
-///     fn visit_seq<A>(self, mut seq: A) -> Result<Vec<T>, A::Error>
-///     where
-///         A: SeqAccess<'de>,
-///     {
-///         // Create a single Vec to hold the flattened contents.
-///         let mut vec = Vec::new();
-///
-///         // Each iteration through this loop is one inner array.
-///         while let Some(()) = seq.next_element_seed(ExtendVec(&mut vec))? {
-///             // Nothing to do; inner array has been appended into `vec`.
-///         }
-///
-///         // Return the finished vec.
-///         Ok(vec)
-///     }
-/// }
-///
-/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// # where
-/// #     D: Deserializer<'de>,
-/// # {
-/// let visitor = FlattenedVecVisitor(PhantomData);
-/// let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;
-/// #     Ok(())
-/// # }
-/// ```
-pub trait DeserializeSeed<'de>: Sized {
-    /// The type produced by using this seed.
-    type Value;
-
-    /// Equivalent to the more common `Deserialize::deserialize` method, except
-    /// with some initial piece of data (the seed) passed in.
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>;
-}
-
-impl<'de, T> DeserializeSeed<'de> for PhantomData<T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = T;
-
-    #[inline]
-    fn deserialize<D>(self, deserializer: D) -> Result<T, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data format** that can deserialize any data structure supported by
-/// Serde.
-///
-/// The role of this trait is to define the deserialization half of the [Serde
-/// data model], which is a way to categorize every Rust data type into one of
-/// 29 possible types. Each method of the `Deserializer` trait corresponds to one
-/// of the types of the data model.
-///
-/// Implementations of `Deserialize` map themselves into this data model by
-/// passing to the `Deserializer` a `Visitor` implementation that can receive
-/// these various types.
-///
-/// The types that make up the Serde data model are:
-///
-///  - **14 primitive types**
-///    - bool
-///    - i8, i16, i32, i64, i128
-///    - u8, u16, u32, u64, u128
-///    - f32, f64
-///    - char
-///  - **string**
-///    - UTF-8 bytes with a length and no null terminator.
-///    - When serializing, all strings are handled equally. When deserializing,
-///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - \[u8\]
-///    - Similar to strings, during deserialization byte arrays can be
-///      transient, owned, or borrowed.
-///  - **option**
-///    - Either none or some value.
-///  - **unit**
-///    - The type of `()` in Rust. It represents an anonymous value containing
-///      no data.
-///  - **unit_struct**
-///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
-///      value containing no data.
-///  - **unit_variant**
-///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
-///  - **newtype_struct**
-///    - For example `struct Millimeters(u8)`.
-///  - **newtype_variant**
-///    - For example the `E::N` in `enum E { N(u8) }`.
-///  - **seq**
-///    - A variably sized heterogeneous sequence of values, for example `Vec<T>`
-///      or `HashSet<T>`. When serializing, the length may or may not be known
-///      before iterating through all the data. When deserializing, the length
-///      is determined by looking at the serialized data.
-///  - **tuple**
-///    - A statically sized heterogeneous sequence of values for which the
-///      length will be known at deserialization time without looking at the
-///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
-///      `[u64; 10]`.
-///  - **tuple_struct**
-///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
-///  - **tuple_variant**
-///    - For example the `E::T` in `enum E { T(u8, u8) }`.
-///  - **map**
-///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
-///  - **struct**
-///    - A heterogeneous key-value pairing in which the keys are strings and
-///      will be known at deserialization time without looking at the serialized
-///      data, for example `struct S { r: u8, g: u8, b: u8 }`.
-///  - **struct_variant**
-///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
-///
-/// The `Deserializer` trait supports two entry point styles which enables
-/// different kinds of deserialization.
-///
-/// 1. The `deserialize` method. Self-describing data formats like JSON are able
-///    to look at the serialized data and tell what it represents. For example
-///    the JSON deserializer may see an opening curly brace (`{`) and know that
-///    it is seeing a map. If the data format supports
-///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
-///    type it sees in the input. JSON uses this approach when deserializing
-///    `serde_json::Value` which is an enum that can represent any JSON
-///    document. Without knowing what is in a JSON document, we can deserialize
-///    it to `serde_json::Value` by going through
-///    `Deserializer::deserialize_any`.
-///
-/// 2. The various `deserialize_*` methods. Non-self-describing formats like
-///    Bincode need to be told what is in the input in order to deserialize it.
-///    The `deserialize_*` methods are hints to the deserializer for how to
-///    interpret the next piece of input. Non-self-describing formats are not
-///    able to deserialize something like `serde_json::Value` which relies on
-///    `Deserializer::deserialize_any`.
-///
-/// When implementing `Deserialize`, you should avoid relying on
-/// `Deserializer::deserialize_any` unless you need to be told by the
-/// Deserializer what type is in the input. Know that relying on
-/// `Deserializer::deserialize_any` means your data type will be able to
-/// deserialize from self-describing formats only, ruling out Bincode and many
-/// others.
-///
-/// [Serde data model]: https://serde.rs/data-model.html
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed from the input when deserializing. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website contains example code for
-/// a basic JSON `Deserializer`.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait Deserializer<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// Require the `Deserializer` to figure out how to drive the visitor based
-    /// on what data type is in the input.
-    ///
-    /// When implementing `Deserialize`, you should avoid relying on
-    /// `Deserializer::deserialize_any` unless you need to be told by the
-    /// Deserializer what type is in the input. Know that relying on
-    /// `Deserializer::deserialize_any` means your data type will be able to
-    /// deserialize from self-describing formats only, ruling out Bincode and
-    /// many others.
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `bool` value.
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i8` value.
-    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i16` value.
-    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i32` value.
-    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i64` value.
-    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `i128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("i128 is not supported"))
-        }
-    }
-
-    /// Hint that the `Deserialize` type is expecting a `u8` value.
-    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u16` value.
-    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u32` value.
-    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u64` value.
-    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `u128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("u128 is not supported"))
-        }
-    }
-
-    /// Hint that the `Deserialize` type is expecting a `f32` value.
-    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `f64` value.
-    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `char` value.
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a string value and does
-    /// not benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would benefit from taking ownership of `String` data,
-    /// indicate this to the `Deserializer` by using `deserialize_string`
-    /// instead.
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a string value and would
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would not benefit from taking ownership of `String`
-    /// data, indicate that to the `Deserializer` by using `deserialize_str`
-    /// instead.
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a byte array and does not
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would benefit from taking ownership of `Vec<u8>` data,
-    /// indicate this to the `Deserializer` by using `deserialize_byte_buf`
-    /// instead.
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a byte array and would
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would not benefit from taking ownership of `Vec<u8>`
-    /// data, indicate that to the `Deserializer` by using `deserialize_bytes`
-    /// instead.
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an optional value.
-    ///
-    /// This allows deserializers that encode an optional value as a nullable
-    /// value to convert the null value into `None` and a regular value into
-    /// `Some(value)`.
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a unit value.
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a unit struct with a
-    /// particular name.
-    fn deserialize_unit_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a newtype struct with a
-    /// particular name.
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a sequence of values.
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a sequence of values and
-    /// knows how many values there are without looking at the serialized data.
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a tuple struct with a
-    /// particular name and number of fields.
-    fn deserialize_tuple_struct<V>(
-        self,
-        name: &'static str,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a map of key-value pairs.
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a struct with a particular
-    /// name and fields.
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an enum value with a
-    /// particular name and possible variants.
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting the name of a struct
-    /// field or the discriminant of an enum variant.
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type needs to deserialize a value whose type
-    /// doesn't matter because it is ignored.
-    ///
-    /// Deserializers for non-self-describing formats may not support this mode.
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Determine whether `Deserialize` implementations should expect to
-    /// deserialize their human-readable form.
-    ///
-    /// Some types have a human-readable form that may be somewhat expensive to
-    /// construct, as well as a binary form that is compact and efficient.
-    /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Bincode will prefer the
-    /// compact one.
-    ///
-    /// ```edition2018
-    /// # use std::ops::Add;
-    /// # use std::str::FromStr;
-    /// #
-    /// # struct Timestamp;
-    /// #
-    /// # impl Timestamp {
-    /// #     const EPOCH: Timestamp = Timestamp;
-    /// # }
-    /// #
-    /// # impl FromStr for Timestamp {
-    /// #     type Err = String;
-    /// #     fn from_str(_: &str) -> Result<Self, Self::Err> {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # struct Duration;
-    /// #
-    /// # impl Duration {
-    /// #     fn seconds(_: u64) -> Self { unimplemented!() }
-    /// # }
-    /// #
-    /// # impl Add<Duration> for Timestamp {
-    /// #     type Output = Timestamp;
-    /// #     fn add(self, _: Duration) -> Self::Output {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::de::{self, Deserialize, Deserializer};
-    ///
-    /// impl<'de> Deserialize<'de> for Timestamp {
-    ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    ///     where
-    ///         D: Deserializer<'de>,
-    ///     {
-    ///         if deserializer.is_human_readable() {
-    ///             // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
-    ///             let s = String::deserialize(deserializer)?;
-    ///             Timestamp::from_str(&s).map_err(de::Error::custom)
-    ///         } else {
-    ///             // Deserialize from a compact binary representation, seconds since
-    ///             // the Unix epoch.
-    ///             let n = u64::deserialize(deserializer)?;
-    ///             Ok(Timestamp::EPOCH + Duration::seconds(n))
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The default implementation of this method returns `true`. Data formats
-    /// may override this to `false` to request a compact form for types that
-    /// support one. Note that modifying this method to change a format from
-    /// human-readable to compact or vice versa should be regarded as a breaking
-    /// change, as a value serialized in human-readable mode is not required to
-    /// deserialize from the same data in compact mode.
-    #[inline]
-    fn is_human_readable(&self) -> bool {
-        true
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This trait represents a visitor that walks through a deserializer.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the requirement for lifetime of data
-/// that may be borrowed by `Self::Value`. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// ```edition2018
-/// # use std::fmt;
-/// #
-/// # use serde::de::{self, Unexpected, Visitor};
-/// #
-/// /// A visitor that deserializes a long string - a string containing at least
-/// /// some minimum number of bytes.
-/// struct LongString {
-///     min: usize,
-/// }
-///
-/// impl<'de> Visitor<'de> for LongString {
-///     type Value = String;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(formatter, "a string containing at least {} bytes", self.min)
-///     }
-///
-///     fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-///     where
-///         E: de::Error,
-///     {
-///         if s.len() >= self.min {
-///             Ok(s.to_owned())
-///         } else {
-///             Err(de::Error::invalid_value(Unexpected::Str(s), &self))
-///         }
-///     }
-/// }
-/// ```
-pub trait Visitor<'de>: Sized {
-    /// The value produced by this visitor.
-    type Value;
-
-    /// Format a message stating what data this Visitor expects to receive.
-    ///
-    /// This is used in error messages. The message should complete the sentence
-    /// "This Visitor expects to receive ...", for example the message could be
-    /// "an integer between 0 and 64". The message should not be capitalized and
-    /// should not end with a period.
-    ///
-    /// ```edition2018
-    /// # use std::fmt;
-    /// #
-    /// # struct S {
-    /// #     max: usize,
-    /// # }
-    /// #
-    /// # impl<'de> serde::de::Visitor<'de> for S {
-    /// #     type Value = ();
-    /// #
-    /// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-    ///     write!(formatter, "an integer between 0 and {}", self.max)
-    /// }
-    /// # }
-    /// ```
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
-
-    /// The input contains a boolean.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Bool(v), &self))
-    }
-
-    /// The input contains an `i8`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i16`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i32`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Signed(v), &self))
-    }
-
-    serde_if_integer128! {
-        /// The input contains a `i128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
-        }
-    }
-
-    /// The input contains a `u8`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u16`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u32`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
-    }
-
-    serde_if_integer128! {
-        /// The input contains a `u128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let _ = v;
-            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
-        }
-    }
-
-    /// The input contains an `f32`.
-    ///
-    /// The default implementation forwards to [`visit_f64`].
-    ///
-    /// [`visit_f64`]: #method.visit_f64
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_f64(v as f64)
-    }
-
-    /// The input contains an `f64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Float(v), &self))
-    }
-
-    /// The input contains a `char`.
-    ///
-    /// The default implementation forwards to [`visit_str`] as a one-character
-    /// string.
-    ///
-    /// [`visit_str`]: #method.visit_str
-    #[inline]
-    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(utf8::encode(v).as_str())
-    }
-
-    /// The input contains a string. The lifetime of the string is ephemeral and
-    /// it may be destroyed after this method returns.
-    ///
-    /// This method allows the `Deserializer` to avoid a copy by retaining
-    /// ownership of any buffered data. `Deserialize` implementations that do
-    /// not benefit from taking ownership of `String` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_str` rather than
-    /// `Deserializer::deserialize_string`.
-    ///
-    /// It is never correct to implement `visit_string` without implementing
-    /// `visit_str`. Implement neither, both, or just `visit_str`.
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Str(v), &self))
-    }
-
-    /// The input contains a string that lives at least as long as the
-    /// `Deserializer`.
-    ///
-    /// This enables zero-copy deserialization of strings in some formats. For
-    /// example JSON input containing the JSON string `"borrowed"` can be
-    /// deserialized with zero copying into a `&'a str` as long as the input
-    /// data outlives `'a`.
-    ///
-    /// The default implementation forwards to `visit_str`.
-    #[inline]
-    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(v)
-    }
-
-    /// The input contains a string and ownership of the string is being given
-    /// to the `Visitor`.
-    ///
-    /// This method allows the `Visitor` to avoid a copy by taking ownership of
-    /// a string created by the `Deserializer`. `Deserialize` implementations
-    /// that benefit from taking ownership of `String` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_string` rather
-    /// than `Deserializer::deserialize_str`, although not every deserializer
-    /// will honor such a request.
-    ///
-    /// It is never correct to implement `visit_string` without implementing
-    /// `visit_str`. Implement neither, both, or just `visit_str`.
-    ///
-    /// The default implementation forwards to `visit_str` and then drops the
-    /// `String`.
-    #[inline]
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(&v)
-    }
-
-    /// The input contains a byte array. The lifetime of the byte array is
-    /// ephemeral and it may be destroyed after this method returns.
-    ///
-    /// This method allows the `Deserializer` to avoid a copy by retaining
-    /// ownership of any buffered data. `Deserialize` implementations that do
-    /// not benefit from taking ownership of `Vec<u8>` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_bytes` rather
-    /// than `Deserializer::deserialize_byte_buf`.
-    ///
-    /// It is never correct to implement `visit_byte_buf` without implementing
-    /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = v;
-        Err(Error::invalid_type(Unexpected::Bytes(v), &self))
-    }
-
-    /// The input contains a byte array that lives at least as long as the
-    /// `Deserializer`.
-    ///
-    /// This enables zero-copy deserialization of bytes in some formats. For
-    /// example Bincode data containing bytes can be deserialized with zero
-    /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
-    ///
-    /// The default implementation forwards to `visit_bytes`.
-    #[inline]
-    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_bytes(v)
-    }
-
-    /// The input contains a byte array and ownership of the byte array is being
-    /// given to the `Visitor`.
-    ///
-    /// This method allows the `Visitor` to avoid a copy by taking ownership of
-    /// a byte buffer created by the `Deserializer`. `Deserialize`
-    /// implementations that benefit from taking ownership of `Vec<u8>` data
-    /// should indicate that to the deserializer by using
-    /// `Deserializer::deserialize_byte_buf` rather than
-    /// `Deserializer::deserialize_bytes`, although not every deserializer will
-    /// honor such a request.
-    ///
-    /// It is never correct to implement `visit_byte_buf` without implementing
-    /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
-    ///
-    /// The default implementation forwards to `visit_bytes` and then drops the
-    /// `Vec<u8>`.
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_bytes(&v)
-    }
-
-    /// The input contains an optional that is absent.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_none<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Option, &self))
-    }
-
-    /// The input contains an optional that is present.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let _ = deserializer;
-        Err(Error::invalid_type(Unexpected::Option, &self))
-    }
-
-    /// The input contains a unit `()`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Unit, &self))
-    }
-
-    /// The input contains a newtype struct.
-    ///
-    /// The content of the newtype struct may be read from the given
-    /// `Deserializer`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let _ = deserializer;
-        Err(Error::invalid_type(Unexpected::NewtypeStruct, &self))
-    }
-
-    /// The input contains a sequence of elements.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        let _ = seq;
-        Err(Error::invalid_type(Unexpected::Seq, &self))
-    }
-
-    /// The input contains a key-value map.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
-    where
-        A: MapAccess<'de>,
-    {
-        let _ = map;
-        Err(Error::invalid_type(Unexpected::Map, &self))
-    }
-
-    /// The input contains an enum.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        let _ = data;
-        Err(Error::invalid_type(Unexpected::Enum, &self))
-    }
-
-    // Used when deserializing a flattened Option field. Not public API.
-    #[doc(hidden)]
-    fn __private_visit_untagged_option<D>(self, _: D) -> Result<Self::Value, ()>
-    where
-        D: Deserializer<'de>,
-    {
-        Err(())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to each element of a sequence in the input.
-///
-/// This is a trait that a `Deserializer` passes to a `Visitor` implementation,
-/// which deserializes each item in a sequence.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by deserialized sequence elements. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SeqAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SeqAccess<'de> {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// This returns `Ok(Some(value))` for the next value in the sequence, or
-    /// `Ok(None)` if there are no more remaining items.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `SeqAccess::next_element` instead.
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>;
-
-    /// This returns `Ok(Some(value))` for the next value in the sequence, or
-    /// `Ok(None)` if there are no more remaining items.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `SeqAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        self.next_element_seed(PhantomData)
-    }
-
-    /// Returns the number of elements remaining in the sequence, if known.
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
-where
-    A: SeqAccess<'de>,
-{
-    type Error = A::Error;
-
-    #[inline]
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        (**self).next_element_seed(seed)
-    }
-
-    #[inline]
-    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        (**self).next_element()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        (**self).size_hint()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to each entry of a map in the input.
-///
-/// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by deserialized map entries. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `MapAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait MapAccess<'de> {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
-    /// if there are no more remaining entries.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_key` or `MapAccess::next_entry` instead.
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
-    where
-        K: DeserializeSeed<'de>;
-
-    /// This returns a `Ok(value)` for the next value in the map.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_value` instead.
-    ///
-    /// # Panics
-    ///
-    /// Calling `next_value_seed` before `next_key_seed` is incorrect and is
-    /// allowed to panic or return bogus results.
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
-    where
-        V: DeserializeSeed<'de>;
-
-    /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
-    /// the map, or `Ok(None)` if there are no more remaining items.
-    ///
-    /// `MapAccess` implementations should override the default behavior if a
-    /// more efficient implementation is possible.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_entry` instead.
-    #[inline]
-    fn next_entry_seed<K, V>(
-        &mut self,
-        kseed: K,
-        vseed: V,
-    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-        V: DeserializeSeed<'de>,
-    {
-        match try!(self.next_key_seed(kseed)) {
-            Some(key) => {
-                let value = try!(self.next_value_seed(vseed));
-                Ok(Some((key, value)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
-    /// if there are no more remaining entries.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-    where
-        K: Deserialize<'de>,
-    {
-        self.next_key_seed(PhantomData)
-    }
-
-    /// This returns a `Ok(value)` for the next value in the map.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    ///
-    /// # Panics
-    ///
-    /// Calling `next_value` before `next_key` is incorrect and is allowed to
-    /// panic or return bogus results.
-    #[inline]
-    fn next_value<V>(&mut self) -> Result<V, Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        self.next_value_seed(PhantomData)
-    }
-
-    /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
-    /// the map, or `Ok(None)` if there are no more remaining items.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
-    where
-        K: Deserialize<'de>,
-        V: Deserialize<'de>,
-    {
-        self.next_entry_seed(PhantomData, PhantomData)
-    }
-
-    /// Returns the number of entries remaining in the map, if known.
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
-where
-    A: MapAccess<'de>,
-{
-    type Error = A::Error;
-
-    #[inline]
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-    {
-        (**self).next_key_seed(seed)
-    }
-
-    #[inline]
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        (**self).next_value_seed(seed)
-    }
-
-    #[inline]
-    fn next_entry_seed<K, V>(
-        &mut self,
-        kseed: K,
-        vseed: V,
-    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-        V: DeserializeSeed<'de>,
-    {
-        (**self).next_entry_seed(kseed, vseed)
-    }
-
-    #[inline]
-    fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
-    where
-        K: Deserialize<'de>,
-        V: Deserialize<'de>,
-    {
-        (**self).next_entry()
-    }
-
-    #[inline]
-    fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-    where
-        K: Deserialize<'de>,
-    {
-        (**self).next_key()
-    }
-
-    #[inline]
-    fn next_value<V>(&mut self) -> Result<V, Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        (**self).next_value()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        (**self).size_hint()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to the data of an enum in the input.
-///
-/// `EnumAccess` is created by the `Deserializer` and passed to the
-/// `Visitor` in order to identify which variant of an enum to deserialize.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by the deserialized enum variant. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `EnumAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait EnumAccess<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-    /// The `Visitor` that will be used to deserialize the content of the enum
-    /// variant.
-    type Variant: VariantAccess<'de, Error = Self::Error>;
-
-    /// `variant` is called to identify which variant to deserialize.
-    ///
-    /// `Deserialize` implementations should typically use `EnumAccess::variant`
-    /// instead.
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-    where
-        V: DeserializeSeed<'de>;
-
-    /// `variant` is called to identify which variant to deserialize.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `EnumAccess` implementations should not override the default behavior.
-    #[inline]
-    fn variant<V>(self) -> Result<(V, Self::Variant), Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        self.variant_seed(PhantomData)
-    }
-}
-
-/// `VariantAccess` is a visitor that is created by the `Deserializer` and
-/// passed to the `Deserialize` to deserialize the content of a particular enum
-/// variant.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by the deserialized enum variant. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `VariantAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait VariantAccess<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization. Must match the error type of our `EnumAccess`.
-    type Error: Error;
-
-    /// Called when deserializing a variant with no values.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2018
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// fn unit_variant(self) -> Result<(), Self::Error> {
-    ///     // What the data actually contained; suppose it is a tuple variant.
-    ///     let unexp = Unexpected::TupleVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"unit variant"))
-    /// }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn unit_variant(self) -> Result<(), Self::Error>;
-
-    /// Called when deserializing a variant with a single value.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `VariantAccess::newtype_variant` instead.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2018
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-    /// where
-    ///     T: DeserializeSeed<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"newtype variant"))
-    /// }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>;
-
-    /// Called when deserializing a variant with a single value.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `VariantAccess` implementations should not override the default
-    /// behavior.
-    #[inline]
-    fn newtype_variant<T>(self) -> Result<T, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        self.newtype_variant_seed(PhantomData)
-    }
-
-    /// Called when deserializing a tuple-like variant.
-    ///
-    /// The `len` is the number of fields expected in the tuple variant.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2018
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// fn tuple_variant<V>(
-    ///     self,
-    ///     _len: usize,
-    ///     _visitor: V,
-    /// ) -> Result<V::Value, Self::Error>
-    /// where
-    ///     V: Visitor<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"tuple variant"))
-    /// }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Called when deserializing a struct-like variant.
-    ///
-    /// The `fields` are the names of the fields of the struct variant.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2018
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// fn struct_variant<V>(
-    ///     self,
-    ///     _fields: &'static [&'static str],
-    ///     _visitor: V,
-    /// ) -> Result<V::Value, Self::Error>
-    /// where
-    ///     V: Visitor<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"struct variant"))
-    /// }
-    /// # }
-    /// ```
-    fn struct_variant<V>(
-        self,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Converts an existing value into a `Deserializer` from which other values can
-/// be deserialized.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed from the resulting `Deserializer`. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// ```edition2018
-/// use std::str::FromStr;
-/// use serde::Deserialize;
-/// use serde::de::{value, IntoDeserializer};
-///
-/// #[derive(Deserialize)]
-/// enum Setting {
-///     On,
-///     Off,
-/// }
-///
-/// impl FromStr for Setting {
-///     type Err = value::Error;
-///
-///     fn from_str(s: &str) -> Result<Self, Self::Err> {
-///         Self::deserialize(s.into_deserializer())
-///     }
-/// }
-/// ```
-pub trait IntoDeserializer<'de, E: Error = value::Error> {
-    /// The type of the deserializer being converted into.
-    type Deserializer: Deserializer<'de, Error = E>;
-
-    /// Convert this value into a deserializer.
-    fn into_deserializer(self) -> Self::Deserializer;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Used in error messages.
-///
-/// - expected `a`
-/// - expected `a` or `b`
-/// - expected one of `a`, `b`, `c`
-///
-/// The slice of names must not be empty.
-struct OneOf {
-    names: &'static [&'static str],
-}
-
-impl Display for OneOf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self.names.len() {
-            0 => panic!(), // special case elsewhere
-            1 => write!(formatter, "`{}`", self.names[0]),
-            2 => write!(formatter, "`{}` or `{}`", self.names[0], self.names[1]),
-            _ => {
-                try!(write!(formatter, "one of "));
-                for (i, alt) in self.names.iter().enumerate() {
-                    if i > 0 {
-                        try!(write!(formatter, ", "));
-                    }
-                    try!(write!(formatter, "`{}`", alt));
-                }
-                Ok(())
-            }
-        }
-    }
-}
diff --git a/vendor/serde/src/de/seed.rs b/vendor/serde/src/de/seed.rs
deleted file mode 100644
index 13b7ea46..00000000
--- a/vendor/serde/src/de/seed.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use de::{Deserialize, DeserializeSeed, Deserializer};
-
-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
-    }
-}
diff --git a/vendor/serde/src/de/utf8.rs b/vendor/serde/src/de/utf8.rs
deleted file mode 100644
index 576fd03c..00000000
--- a/vendor/serde/src/de/utf8.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use lib::*;
-
-const TAG_CONT: u8 = 0b1000_0000;
-const TAG_TWO_B: u8 = 0b1100_0000;
-const TAG_THREE_B: u8 = 0b1110_0000;
-const TAG_FOUR_B: u8 = 0b1111_0000;
-const MAX_ONE_B: u32 = 0x80;
-const MAX_TWO_B: u32 = 0x800;
-const MAX_THREE_B: u32 = 0x10000;
-
-#[inline]
-pub fn encode(c: char) -> Encode {
-    let code = c as u32;
-    let mut buf = [0; 4];
-    let pos = if code < MAX_ONE_B {
-        buf[3] = code as u8;
-        3
-    } else if code < MAX_TWO_B {
-        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        2
-    } else if code < MAX_THREE_B {
-        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
-        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        1
-    } else {
-        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
-        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
-        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        0
-    };
-    Encode { buf: buf, pos: pos }
-}
-
-pub struct Encode {
-    buf: [u8; 4],
-    pos: usize,
-}
-
-impl Encode {
-    pub fn as_str(&self) -> &str {
-        str::from_utf8(&self.buf[self.pos..]).unwrap()
-    }
-}
diff --git a/vendor/serde/src/de/value.rs b/vendor/serde/src/de/value.rs
deleted file mode 100644
index 1b154c3a..00000000
--- a/vendor/serde/src/de/value.rs
+++ /dev/null
@@ -1,1635 +0,0 @@
-//! Building blocks for deserializing basic values using the `IntoDeserializer`
-//! trait.
-//!
-//! ```edition2018
-//! use std::str::FromStr;
-//! use serde::Deserialize;
-//! use serde::de::{value, IntoDeserializer};
-//!
-//! #[derive(Deserialize)]
-//! enum Setting {
-//!     On,
-//!     Off,
-//! }
-//!
-//! impl FromStr for Setting {
-//!     type Err = value::Error;
-//!
-//!     fn from_str(s: &str) -> Result<Self, Self::Err> {
-//!         Self::deserialize(s.into_deserializer())
-//!     }
-//! }
-//! ```
-
-use lib::*;
-
-use self::private::{First, Second};
-use __private::size_hint;
-use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
-use ser;
-
-////////////////////////////////////////////////////////////////////////////////
-
-// For structs that contain a PhantomData. We do not want the trait
-// bound `E: Clone` inferred by derive(Clone).
-macro_rules! impl_copy_clone {
-    ($ty:ident $(<$lifetime:tt>)*) => {
-        impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
-
-        impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
-            fn clone(&self) -> Self {
-                *self
-            }
-        }
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A minimal representation of all possible errors that can occur using the
-/// `IntoDeserializer` trait.
-#[derive(Clone, PartialEq)]
-pub struct Error {
-    err: ErrorImpl,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-type ErrorImpl = Box<str>;
-#[cfg(not(any(feature = "std", feature = "alloc")))]
-type ErrorImpl = ();
-
-impl de::Error for Error {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        Error {
-            err: msg.to_string().into_boxed_str(),
-        }
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        let _ = msg;
-        Error { err: () }
-    }
-}
-
-impl ser::Error for Error {
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        de::Error::custom(msg)
-    }
-}
-
-impl Display for Error {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(&self.err)
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("Serde deserialization error")
-    }
-}
-
-impl Debug for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = formatter.debug_tuple("Error");
-        #[cfg(any(feature = "std", feature = "alloc"))]
-        debug.field(&self.err);
-        debug.finish()
-    }
-}
-
-#[cfg(feature = "std")]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        &self.err
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, E> IntoDeserializer<'de, E> for ()
-where
-    E: de::Error,
-{
-    type Deserializer = UnitDeserializer<E>;
-
-    fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
-    }
-}
-
-/// A deserializer holding a `()`.
-pub struct UnitDeserializer<E> {
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(UnitDeserializer);
-
-impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_none()
-    }
-}
-
-impl<E> Debug for UnitDeserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.debug_struct("UnitDeserializer").finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that cannot be instantiated.
-#[cfg(feature = "unstable")]
-pub struct NeverDeserializer<E> {
-    never: !,
-    marker: PhantomData<E>,
-}
-
-#[cfg(feature = "unstable")]
-impl<'de, E> IntoDeserializer<'de, E> for !
-where
-    E: de::Error,
-{
-    type Deserializer = NeverDeserializer<E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.never
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! primitive_deserializer {
-    ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
-        #[doc = "A deserializer holding"]
-        #[doc = $doc]
-        pub struct $name<E> {
-            value: $ty,
-            marker: PhantomData<E>
-        }
-
-        impl_copy_clone!($name);
-
-        impl<'de, E> IntoDeserializer<'de, E> for $ty
-        where
-            E: de::Error,
-        {
-            type Deserializer = $name<E>;
-
-            fn into_deserializer(self) -> $name<E> {
-                $name {
-                    value: self,
-                    marker: PhantomData,
-                }
-            }
-        }
-
-        impl<'de, E> de::Deserializer<'de> for $name<E>
-        where
-            E: de::Error,
-        {
-            type Error = E;
-
-            forward_to_deserialize_any! {
-                bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
-                string bytes byte_buf option unit unit_struct newtype_struct seq
-                tuple tuple_struct map struct enum identifier ignored_any
-            }
-
-            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-            where
-                V: de::Visitor<'de>,
-            {
-                visitor.$method(self.value $($cast)*)
-            }
-        }
-
-        impl<E> Debug for $name<E> {
-            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter
-                    .debug_struct(stringify!($name))
-                    .field("value", &self.value)
-                    .finish()
-            }
-        }
-    }
-}
-
-primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool);
-primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
-primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
-primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
-primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
-primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
-primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
-primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
-primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
-primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
-primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
-primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
-primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
-
-serde_if_integer128! {
-    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-}
-
-/// A deserializer holding a `u32`.
-pub struct U32Deserializer<E> {
-    value: u32,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(U32Deserializer);
-
-impl<'de, E> IntoDeserializer<'de, E> for u32
-where
-    E: de::Error,
-{
-    type Deserializer = U32Deserializer<E>;
-
-    fn into_deserializer(self) -> U32Deserializer<E> {
-        U32Deserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_u32(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-}
-
-impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<E> Debug for U32Deserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("U32Deserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str`.
-pub struct StrDeserializer<'a, E> {
-    value: &'a str,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(StrDeserializer<'de>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
-where
-    E: de::Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> StrDeserializer<'a, E> {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_str(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<'a, E> Debug for StrDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("StrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str` with a lifetime tied to another
-/// deserializer.
-pub struct BorrowedStrDeserializer<'de, E> {
-    value: &'de str,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(BorrowedStrDeserializer<'de>);
-
-impl<'de, E> BorrowedStrDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given string.
-    pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
-        BorrowedStrDeserializer {
-            value: value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BorrowedStrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `String`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct StringDeserializer<E> {
-    value: String,
-    marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Clone for StringDeserializer<E> {
-    fn clone(&self) -> Self {
-        StringDeserializer {
-            value: self.value.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> IntoDeserializer<'de, E> for String
-where
-    E: de::Error,
-{
-    type Deserializer = StringDeserializer<E>;
-
-    fn into_deserializer(self) -> StringDeserializer<E> {
-        StringDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_string(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Debug for StringDeserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("StringDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `Cow<str>`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct CowStrDeserializer<'a, E> {
-    value: Cow<'a, str>,
-    marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Clone for CowStrDeserializer<'a, E> {
-    fn clone(&self) -> Self {
-        CowStrDeserializer {
-            value: self.value.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
-where
-    E: de::Error,
-{
-    type Deserializer = CowStrDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
-        CowStrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value {
-            Cow::Borrowed(string) => visitor.visit_str(string),
-            Cow::Owned(string) => visitor.visit_string(string),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Debug for CowStrDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("CowStrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
-    marker: PhantomData<E>,
-}
-
-impl<'a, E> BytesDeserializer<'a, E> {
-    /// Create a new deserializer from the given bytes.
-    pub fn new(value: &'a [u8]) -> Self {
-        BytesDeserializer {
-            value: value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl_copy_clone!(BytesDeserializer<'a>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8]
-where
-    E: de::Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
-        BytesDeserializer::new(self)
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_bytes(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'a, E> Debug for BytesDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BytesDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
-pub struct BorrowedBytesDeserializer<'de, E> {
-    value: &'de [u8],
-    marker: PhantomData<E>,
-}
-
-impl<'de, E> BorrowedBytesDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given borrowed bytes.
-    pub fn new(value: &'de [u8]) -> Self {
-        BorrowedBytesDeserializer {
-            value: value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl_copy_clone!(BorrowedBytesDeserializer<'de>);
-
-impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_bytes(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BorrowedBytesDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a sequence.
-#[derive(Clone)]
-pub struct SeqDeserializer<I, E> {
-    iter: iter::Fuse<I>,
-    count: usize,
-    marker: PhantomData<E>,
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
-    I: Iterator,
-{
-    /// Construct a new `SeqDeserializer<I, E>`.
-    pub fn new(iter: I) -> Self {
-        SeqDeserializer {
-            iter: iter.fuse(),
-            count: 0,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
-    I: Iterator,
-    E: de::Error,
-{
-    /// Check for remaining elements after passing a `SeqDeserializer` to
-    /// `Visitor::visit_seq`.
-    pub fn end(self) -> Result<(), E> {
-        let remaining = self.iter.count();
-        if remaining == 0 {
-            Ok(())
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(
-                self.count + remaining,
-                &ExpectedInSeq(self.count),
-            ))
-        }
-    }
-}
-
-impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
-where
-    I: Iterator<Item = T>,
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let v = try!(visitor.visit_seq(&mut self));
-        try!(self.end());
-        Ok(v)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E>
-where
-    I: Iterator<Item = T>,
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => {
-                self.count += 1;
-                seed.deserialize(value.into_deserializer()).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-struct ExpectedInSeq(usize);
-
-impl Expected for ExpectedInSeq {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        if self.0 == 1 {
-            write!(formatter, "1 element in sequence")
-        } else {
-            write!(formatter, "{} elements in sequence", self.0)
-        }
-    }
-}
-
-impl<I, E> Debug for SeqDeserializer<I, E>
-where
-    I: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("SeqDeserializer")
-            .field("iter", &self.iter)
-            .field("count", &self.count)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
-where
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
-where
-    T: IntoDeserializer<'de, E> + Eq + Ord,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
-where
-    T: IntoDeserializer<'de, E> + Eq + Hash,
-    S: BuildHasher,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `SeqAccess`.
-#[derive(Clone, Debug)]
-pub struct SeqAccessDeserializer<A> {
-    seq: A,
-}
-
-impl<A> SeqAccessDeserializer<A> {
-    /// Construct a new `SeqAccessDeserializer<A>`.
-    pub fn new(seq: A) -> Self {
-        SeqAccessDeserializer { seq: seq }
-    }
-}
-
-impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A>
-where
-    A: de::SeqAccess<'de>,
-{
-    type Error = A::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_seq(self.seq)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a map.
-pub struct MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    iter: iter::Fuse<I>,
-    value: Option<Second<I::Item>>,
-    count: usize,
-    lifetime: PhantomData<&'de ()>,
-    error: PhantomData<E>,
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    /// Construct a new `MapDeserializer<I, E>`.
-    pub fn new(iter: I) -> Self {
-        MapDeserializer {
-            iter: iter.fuse(),
-            value: None,
-            count: 0,
-            lifetime: PhantomData,
-            error: PhantomData,
-        }
-    }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    E: de::Error,
-{
-    /// Check for remaining elements after passing a `MapDeserializer` to
-    /// `Visitor::visit_map`.
-    pub fn end(self) -> Result<(), E> {
-        let remaining = self.iter.count();
-        if remaining == 0 {
-            Ok(())
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(
-                self.count + remaining,
-                &ExpectedInMap(self.count),
-            ))
-        }
-    }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> {
-        match self.iter.next() {
-            Some(kv) => {
-                self.count += 1;
-                Some(private::Pair::split(kv))
-            }
-            None => None,
-        }
-    }
-}
-
-impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let value = try!(visitor.visit_map(&mut self));
-        try!(self.end());
-        Ok(value)
-    }
-
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let value = try!(visitor.visit_seq(&mut self));
-        try!(self.end());
-        Ok(value)
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = len;
-        self.deserialize_seq(visitor)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
-        struct enum identifier ignored_any
-    }
-}
-
-impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                seed.deserialize(key.into_deserializer()).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let value = self.value.take();
-        // Panic because this indicates a bug in the program rather than an
-        // expected failure.
-        let value = value.expect("MapAccess::next_value called before next_key");
-        seed.deserialize(value.into_deserializer())
-    }
-
-    fn next_entry_seed<TK, TV>(
-        &mut self,
-        kseed: TK,
-        vseed: TV,
-    ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
-    where
-        TK: de::DeserializeSeed<'de>,
-        TV: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((key, value)) => {
-                let key = try!(kseed.deserialize(key.into_deserializer()));
-                let value = try!(vseed.deserialize(value.into_deserializer()));
-                Ok(Some((key, value)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((k, v)) => {
-                let de = PairDeserializer(k, v, PhantomData);
-                seed.deserialize(de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-// Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.
-impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
-where
-    I: Iterator + Clone,
-    I::Item: private::Pair,
-    Second<I::Item>: Clone,
-{
-    fn clone(&self) -> Self {
-        MapDeserializer {
-            iter: self.iter.clone(),
-            value: self.value.clone(),
-            count: self.count,
-            lifetime: self.lifetime,
-            error: self.error,
-        }
-    }
-}
-
-impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
-where
-    I: Iterator + Debug,
-    I::Item: private::Pair,
-    Second<I::Item>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("MapDeserializer")
-            .field("iter", &self.iter)
-            .field("value", &self.value)
-            .field("count", &self.count)
-            .finish()
-    }
-}
-
-// Used in the `impl SeqAccess for MapDeserializer` to visit the map as a
-// sequence of pairs.
-struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
-
-impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
-where
-    A: IntoDeserializer<'de, E>,
-    B: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
-        struct enum identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
-        let pair = try!(visitor.visit_seq(&mut pair_visitor));
-        if pair_visitor.1.is_none() {
-            Ok(pair)
-        } else {
-            let remaining = pair_visitor.size_hint().unwrap();
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining)))
-        }
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if len == 2 {
-            self.deserialize_seq(visitor)
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(2, &ExpectedInSeq(len)))
-        }
-    }
-}
-
-struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
-
-impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E>
-where
-    A: IntoDeserializer<'de, E>,
-    B: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        if let Some(k) = self.0.take() {
-            seed.deserialize(k.into_deserializer()).map(Some)
-        } else if let Some(v) = self.1.take() {
-            seed.deserialize(v.into_deserializer()).map(Some)
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        if self.0.is_some() {
-            Some(2)
-        } else if self.1.is_some() {
-            Some(1)
-        } else {
-            Some(0)
-        }
-    }
-}
-
-struct ExpectedInMap(usize);
-
-impl Expected for ExpectedInMap {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        if self.0 == 1 {
-            write!(formatter, "1 element in map")
-        } else {
-            write!(formatter, "{} elements in map", self.0)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
-where
-    K: IntoDeserializer<'de, E> + Eq + Ord,
-    V: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        MapDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
-where
-    K: IntoDeserializer<'de, E> + Eq + Hash,
-    V: IntoDeserializer<'de, E>,
-    S: BuildHasher,
-    E: de::Error,
-{
-    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        MapDeserializer::new(self.into_iter())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `MapAccess`.
-#[derive(Clone, Debug)]
-pub struct MapAccessDeserializer<A> {
-    map: A,
-}
-
-impl<A> MapAccessDeserializer<A> {
-    /// Construct a new `MapAccessDeserializer<A>`.
-    pub fn new(map: A) -> Self {
-        MapAccessDeserializer { map: map }
-    }
-}
-
-impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A>
-where
-    A: de::MapAccess<'de>,
-{
-    type Error = A::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_map(self.map)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
-where
-    A: de::MapAccess<'de>,
-{
-    type Error = A::Error;
-    type Variant = private::MapAsEnum<A>;
-
-    fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.map.next_key_seed(seed)? {
-            Some(key) => Ok((key, private::map_as_enum(self.map))),
-            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-mod private {
-    use lib::*;
-
-    use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};
-
-    pub struct UnitOnly<E> {
-        marker: PhantomData<E>,
-    }
-
-    pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
-        (
-            t,
-            UnitOnly {
-                marker: PhantomData,
-            },
-        )
-    }
-
-    impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn unit_variant(self) -> Result<(), Self::Error> {
-            Ok(())
-        }
-
-        fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            ))
-        }
-
-        fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            ))
-        }
-
-        fn struct_variant<V>(
-            self,
-            _fields: &'static [&'static str],
-            _visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            ))
-        }
-    }
-
-    pub struct MapAsEnum<A> {
-        map: A,
-    }
-
-    pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
-        MapAsEnum { map: map }
-    }
-
-    impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
-    where
-        A: MapAccess<'de>,
-    {
-        type Error = A::Error;
-
-        fn unit_variant(mut self) -> Result<(), Self::Error> {
-            self.map.next_value()
-        }
-
-        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: DeserializeSeed<'de>,
-        {
-            self.map.next_value_seed(seed)
-        }
-
-        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.map.next_value_seed(SeedTupleVariant {
-                len: len,
-                visitor: visitor,
-            })
-        }
-
-        fn struct_variant<V>(
-            mut self,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.map
-                .next_value_seed(SeedStructVariant { visitor: visitor })
-        }
-    }
-
-    struct SeedTupleVariant<V> {
-        len: usize,
-        visitor: V,
-    }
-
-    impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
-    where
-        V: Visitor<'de>,
-    {
-        type Value = V::Value;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_tuple(self.len, self.visitor)
-        }
-    }
-
-    struct SeedStructVariant<V> {
-        visitor: V,
-    }
-
-    impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
-    where
-        V: Visitor<'de>,
-    {
-        type Value = V::Value;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_map(self.visitor)
-        }
-    }
-
-    /// Avoid having to restate the generic types on `MapDeserializer`. The
-    /// `Iterator::Item` contains enough information to figure out K and V.
-    pub trait Pair {
-        type First;
-        type Second;
-        fn split(self) -> (Self::First, Self::Second);
-    }
-
-    impl<A, B> Pair for (A, B) {
-        type First = A;
-        type Second = B;
-        fn split(self) -> (A, B) {
-            self
-        }
-    }
-
-    pub type First<T> = <T as Pair>::First;
-    pub type Second<T> = <T as Pair>::Second;
-}
diff --git a/vendor/serde/src/integer128.rs b/vendor/serde/src/integer128.rs
deleted file mode 100644
index 0ee05bdc..00000000
--- a/vendor/serde/src/integer128.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-/// Conditional compilation depending on whether Serde is built with support for
-/// 128-bit integers.
-///
-/// Data formats that wish to support Rust compiler versions older than 1.26
-/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
-/// of their Serializer and Deserializer behind this macro.
-///
-/// Data formats that require a minimum Rust compiler version of at least 1.26,
-/// or do not target platforms that lack 128-bit integers, do not need to
-/// bother with this macro and may assume support for 128-bit integers.
-///
-/// ```edition2018
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// use serde::{serde_if_integer128, Serializer};
-///
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
-///         /* ... */
-/// #         unimplemented!()
-///     }
-///
-///     /* ... */
-///
-///     serde_if_integer128! {
-///         fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///
-///         fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///     }
-/// #
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant seq
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// When Serde is built with support for 128-bit integers, this macro expands
-/// transparently into just the input tokens.
-///
-/// ```edition2018
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {
-///         $($tt)*
-///     };
-/// }
-/// ```
-///
-/// When built without support for 128-bit integers, this macro expands to
-/// nothing.
-///
-/// ```edition2018
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {};
-/// }
-/// ```
-#[cfg(integer128)]
-#[macro_export]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {
-        $($tt)*
-    };
-}
-
-#[cfg(not(integer128))]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {};
-}
diff --git a/vendor/serde/src/lib.rs b/vendor/serde/src/lib.rs
deleted file mode 100644
index f6a8ac00..00000000
--- a/vendor/serde/src/lib.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-//! # Serde
-//!
-//! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
-//! structures efficiently and generically.
-//!
-//! The Serde ecosystem consists of data structures that know how to serialize
-//! and deserialize themselves along with data formats that know how to
-//! serialize and deserialize other things. Serde provides the layer by which
-//! these two groups interact with each other, allowing any supported data
-//! structure to be serialized and deserialized using any supported data format.
-//!
-//! See the Serde website <https://serde.rs/> for additional documentation and
-//! usage examples.
-//!
-//! ## Design
-//!
-//! Where many other languages rely on runtime reflection for serializing data,
-//! Serde is instead built on Rust's powerful trait system. A data structure
-//! that knows how to serialize and deserialize itself is one that implements
-//! Serde's `Serialize` and `Deserialize` traits (or uses Serde's derive
-//! attribute to automatically generate implementations at compile time). This
-//! avoids any overhead of reflection or runtime type information. In fact in
-//! many situations the interaction between data structure and data format can
-//! be completely optimized away by the Rust compiler, leaving Serde
-//! serialization to perform the same speed as a handwritten serializer for the
-//! specific selection of data structure and data format.
-//!
-//! ## Data formats
-//!
-//! The following is a partial list of data formats that have been implemented
-//! for Serde by the community.
-//!
-//! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
-//! - [Bincode], a compact binary format
-//!   used for IPC within the Servo rendering engine.
-//! - [CBOR], a Concise Binary Object Representation designed for small message
-//!   size without the need for version negotiation.
-//! - [YAML], a self-proclaimed human-friendly configuration language that ain't
-//!   markup language.
-//! - [MessagePack], an efficient binary format that resembles a compact JSON.
-//! - [TOML], a minimal configuration format used by [Cargo].
-//! - [Pickle], a format common in the Python world.
-//! - [RON], a Rusty Object Notation.
-//! - [BSON], the data storage and network transfer format used by MongoDB.
-//! - [Avro], a binary format used within Apache Hadoop, with support for schema
-//!   definition.
-//! - [JSON5], a superset of JSON including some productions from ES5.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
-//! - [URL] query strings, in the x-www-form-urlencoded format.
-//! - [Envy], a way to deserialize environment variables into Rust structs.
-//!   *(deserialization only)*
-//! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
-//!   Rust structs. *(deserialization only)*
-//! - [S-expressions], the textual representation of code and data used by the
-//!   Lisp language family.
-//! - [D-Bus]'s binary wire format.
-//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.
-//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
-//!   and from DynamoDB.
-//!
-//! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/servo/bincode
-//! [CBOR]: https://github.com/enarx/ciborium
-//! [YAML]: https://github.com/dtolnay/serde-yaml
-//! [MessagePack]: https://github.com/3Hren/msgpack-rust
-//! [TOML]: https://github.com/alexcrichton/toml-rs
-//! [Pickle]: https://github.com/birkenfeld/serde-pickle
-//! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/zonyitoo/bson-rs
-//! [Avro]: https://github.com/flavray/avro-rs
-//! [JSON5]: https://github.com/callum-oakley/json5-rs
-//! [Postcard]: https://github.com/jamesmunns/postcard
-//! [URL]: https://docs.rs/serde_qs
-//! [Envy]: https://github.com/softprops/envy
-//! [Envy Store]: https://github.com/softprops/envy-store
-//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
-//! [S-expressions]: https://github.com/rotty/lexpr-rs
-//! [D-Bus]: https://docs.rs/zvariant
-//! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
-//! [DynamoDB Items]: https://docs.rs/serde_dynamo
-//! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.132")]
-// Support using Serde without the standard library!
-#![cfg_attr(not(feature = "std"), no_std)]
-// Unstable functionality only if the user asks for it. For tracking and
-// discussion of these features please refer to this issue:
-//
-//    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(never_type))]
-#![allow(unknown_lints, bare_trait_objects, deprecated)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-// Ignored clippy and clippy_pedantic lints
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-        unnested_or_patterns,
-        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
-        semicolon_if_nothing_returned,
-        // not available in our oldest supported compiler
-        checked_conversions,
-        empty_enum,
-        redundant_field_names,
-        redundant_static_lifetimes,
-        // integer and float ser/de requires these sorts of casts
-        cast_possible_truncation,
-        cast_possible_wrap,
-        cast_sign_loss,
-        // things are often more readable this way
-        cast_lossless,
-        module_name_repetitions,
-        option_if_let_else,
-        single_match_else,
-        type_complexity,
-        use_self,
-        zero_prefixed_literal,
-        // correctly used
-        enum_glob_use,
-        let_underscore_drop,
-        map_err_ignore,
-        result_unit_err,
-        wildcard_imports,
-        // not practical
-        needless_pass_by_value,
-        similar_names,
-        too_many_lines,
-        // preference
-        doc_markdown,
-        unseparated_literal_suffix,
-        // false positive
-        needless_doctest_main,
-        // noisy
-        missing_errors_doc,
-        must_use_candidate,
-    )
-)]
-// Rustc lints.
-#![deny(missing_docs, unused_imports)]
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "alloc")]
-extern crate alloc;
-
-/// A facade around all the types we need from the `std`, `core`, and `alloc`
-/// crates. This avoids elaborate import wrangling having to happen in every
-/// module.
-mod lib {
-    mod core {
-        #[cfg(not(feature = "std"))]
-        pub use core::*;
-        #[cfg(feature = "std")]
-        pub use std::*;
-    }
-
-    pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
-    pub use self::core::{f32, f64};
-    pub use self::core::{i16, i32, i64, i8, isize};
-    pub use self::core::{u16, u32, u64, u8, usize};
-
-    pub use self::core::cell::{Cell, RefCell};
-    pub use self::core::clone::{self, Clone};
-    pub use self::core::convert::{self, From, Into};
-    pub use self::core::default::{self, Default};
-    pub use self::core::fmt::{self, Debug, Display};
-    pub use self::core::marker::{self, PhantomData};
-    pub use self::core::num::Wrapping;
-    pub use self::core::ops::Range;
-    pub use self::core::option::{self, Option};
-    pub use self::core::result::{self, Result};
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::borrow::{Cow, ToOwned};
-    #[cfg(feature = "std")]
-    pub use std::borrow::{Cow, ToOwned};
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::string::{String, ToString};
-    #[cfg(feature = "std")]
-    pub use std::string::{String, ToString};
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::vec::Vec;
-    #[cfg(feature = "std")]
-    pub use std::vec::Vec;
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::boxed::Box;
-    #[cfg(feature = "std")]
-    pub use std::boxed::Box;
-
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::rc::{Rc, Weak as RcWeak};
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::rc::{Rc, Weak as RcWeak};
-
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::sync::{Arc, Weak as ArcWeak};
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::sync::{Arc, Weak as ArcWeak};
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-    #[cfg(feature = "std")]
-    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-
-    #[cfg(feature = "std")]
-    pub use std::{error, net};
-
-    #[cfg(feature = "std")]
-    pub use std::collections::{HashMap, HashSet};
-    #[cfg(feature = "std")]
-    pub use std::ffi::{CStr, CString, OsStr, OsString};
-    #[cfg(feature = "std")]
-    pub use std::hash::{BuildHasher, Hash};
-    #[cfg(feature = "std")]
-    pub use std::io::Write;
-    #[cfg(feature = "std")]
-    pub use std::path::{Path, PathBuf};
-    #[cfg(feature = "std")]
-    pub use std::sync::{Mutex, RwLock};
-    #[cfg(feature = "std")]
-    pub use std::time::{SystemTime, UNIX_EPOCH};
-
-    #[cfg(all(feature = "std", collections_bound))]
-    pub use std::collections::Bound;
-
-    #[cfg(core_reverse)]
-    pub use self::core::cmp::Reverse;
-
-    #[cfg(ops_bound)]
-    pub use self::core::ops::Bound;
-
-    #[cfg(range_inclusive)]
-    pub use self::core::ops::RangeInclusive;
-
-    #[cfg(all(feature = "std", std_atomic))]
-    pub use std::sync::atomic::{
-        AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
-        AtomicUsize, Ordering,
-    };
-    #[cfg(all(feature = "std", std_atomic64))]
-    pub use std::sync::atomic::{AtomicI64, AtomicU64};
-
-    #[cfg(any(core_duration, feature = "std"))]
-    pub use self::core::time::Duration;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[macro_use]
-mod macros;
-
-#[macro_use]
-mod integer128;
-
-pub mod de;
-pub mod ser;
-
-#[doc(inline)]
-pub use de::{Deserialize, Deserializer};
-#[doc(inline)]
-pub use ser::{Serialize, Serializer};
-
-// Used by generated code and doc tests. Not public API.
-#[doc(hidden)]
-#[path = "private/mod.rs"]
-pub mod __private;
-
-#[allow(unused_imports)]
-use self::__private as export;
-#[allow(unused_imports)]
-use self::__private as private;
-
-#[path = "de/seed.rs"]
-mod seed;
-
-#[cfg(not(feature = "std"))]
-mod std_error;
-
-// Re-export #[derive(Serialize, Deserialize)].
-//
-// The reason re-exporting is not enabled by default is that disabling it would
-// be annoying for crates that provide handwritten impls or data formats. They
-// would need to disable default features and then explicitly re-enable std.
-#[cfg(feature = "serde_derive")]
-#[allow(unused_imports)]
-#[macro_use]
-extern crate serde_derive;
-#[cfg(feature = "serde_derive")]
-#[doc(hidden)]
-pub use serde_derive::*;
diff --git a/vendor/serde/src/macros.rs b/vendor/serde/src/macros.rs
deleted file mode 100644
index 6502a23a..00000000
--- a/vendor/serde/src/macros.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-// Super explicit first paragraph because this shows up at the top level and
-// trips up people who are just looking for basic Serialize / Deserialize
-// documentation.
-//
-/// Helper macro when implementing the `Deserializer` part of a new data format
-/// for Serde.
-///
-/// Some [`Deserializer`] implementations for self-describing formats do not
-/// care what hint the [`Visitor`] gives them, they just want to blindly call
-/// the [`Visitor`] method corresponding to the data they can tell is in the
-/// input. This requires repetitive implementations of all the [`Deserializer`]
-/// trait methods.
-///
-/// ```edition2018
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// #
-/// # struct MyDeserializer;
-/// #
-/// # impl<'de> Deserializer<'de> for MyDeserializer {
-/// #     type Error = value::Error;
-/// #
-/// #     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
-/// #     where
-/// #         V: Visitor<'de>,
-/// #     {
-/// #         unimplemented!()
-/// #     }
-/// #
-/// #[inline]
-/// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-/// where
-///     V: Visitor<'de>,
-/// {
-///     self.deserialize_any(visitor)
-/// }
-/// #
-/// #     forward_to_deserialize_any! {
-/// #         i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-/// #         bytes byte_buf option unit unit_struct newtype_struct seq tuple
-/// #         tuple_struct map struct enum identifier ignored_any
-/// #     }
-/// # }
-/// ```
-///
-/// The `forward_to_deserialize_any!` macro implements these simple forwarding
-/// methods so that they forward directly to [`Deserializer::deserialize_any`].
-/// You can choose which methods to forward.
-///
-/// ```edition2018
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// #
-/// # struct MyDeserializer;
-/// #
-/// impl<'de> Deserializer<'de> for MyDeserializer {
-/// #   type Error = value::Error;
-/// #
-///     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-///     where
-///         V: Visitor<'de>,
-///     {
-///         /* ... */
-/// #       let _ = visitor;
-/// #       unimplemented!()
-///     }
-///
-///     forward_to_deserialize_any! {
-///         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-///         bytes byte_buf option unit unit_struct newtype_struct seq tuple
-///         tuple_struct map struct enum identifier ignored_any
-///     }
-/// }
-/// ```
-///
-/// The macro assumes the convention that your `Deserializer` lifetime parameter
-/// is called `'de` and that the `Visitor` type parameters on each method are
-/// called `V`. A different type parameter and a different lifetime can be
-/// specified explicitly if necessary.
-///
-/// ```edition2018
-/// # use std::marker::PhantomData;
-/// #
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// #
-/// # struct MyDeserializer<V>(PhantomData<V>);
-/// #
-/// # impl<'q, V> Deserializer<'q> for MyDeserializer<V> {
-/// #     type Error = value::Error;
-/// #
-/// #     fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error>
-/// #     where
-/// #         W: Visitor<'q>,
-/// #     {
-/// #         unimplemented!()
-/// #     }
-/// #
-/// forward_to_deserialize_any! {
-///     <W: Visitor<'q>>
-///     bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-///     bytes byte_buf option unit unit_struct newtype_struct seq tuple
-///     tuple_struct map struct enum identifier ignored_any
-/// }
-/// # }
-/// ```
-///
-/// [`Deserializer`]: trait.Deserializer.html
-/// [`Visitor`]: de/trait.Visitor.html
-/// [`Deserializer::deserialize_any`]: trait.Deserializer.html#tymethod.deserialize_any
-#[macro_export(local_inner_macros)]
-macro_rules! forward_to_deserialize_any {
-    (<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => {
-        $(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})*
-    };
-    // This case must be after the previous one.
-    ($($func:ident)*) => {
-        $(forward_to_deserialize_any_helper!{$func<'de, V>})*
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! forward_to_deserialize_any_method {
-    ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
-        #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
-        where
-            $v: $crate::de::Visitor<$l>,
-        {
-            $(
-                let _ = $arg;
-            )*
-            self.deserialize_any(visitor)
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! forward_to_deserialize_any_helper {
-    (bool<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()}
-    };
-    (i8<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i8<$l, $v>()}
-    };
-    (i16<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i16<$l, $v>()}
-    };
-    (i32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i32<$l, $v>()}
-    };
-    (i64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
-    };
-    (i128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
-        }
-    };
-    (u8<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
-    };
-    (u16<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u16<$l, $v>()}
-    };
-    (u32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u32<$l, $v>()}
-    };
-    (u64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
-    };
-    (u128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
-        }
-    };
-    (f32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
-    };
-    (f64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_f64<$l, $v>()}
-    };
-    (char<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_char<$l, $v>()}
-    };
-    (str<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_str<$l, $v>()}
-    };
-    (string<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_string<$l, $v>()}
-    };
-    (bytes<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_bytes<$l, $v>()}
-    };
-    (byte_buf<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_byte_buf<$l, $v>()}
-    };
-    (option<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_option<$l, $v>()}
-    };
-    (unit<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_unit<$l, $v>()}
-    };
-    (unit_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_unit_struct<$l, $v>(name: &'static str)}
-    };
-    (newtype_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_newtype_struct<$l, $v>(name: &'static str)}
-    };
-    (seq<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_seq<$l, $v>()}
-    };
-    (tuple<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_tuple<$l, $v>(len: usize)}
-    };
-    (tuple_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_tuple_struct<$l, $v>(name: &'static str, len: usize)}
-    };
-    (map<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_map<$l, $v>()}
-    };
-    (struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_struct<$l, $v>(name: &'static str, fields: &'static [&'static str])}
-    };
-    (enum<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_enum<$l, $v>(name: &'static str, variants: &'static [&'static str])}
-    };
-    (identifier<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_identifier<$l, $v>()}
-    };
-    (ignored_any<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_ignored_any<$l, $v>()}
-    };
-}
diff --git a/vendor/serde/src/private/de.rs b/vendor/serde/src/private/de.rs
deleted file mode 100644
index a387d404..00000000
--- a/vendor/serde/src/private/de.rs
+++ /dev/null
@@ -1,2959 +0,0 @@
-use lib::*;
-
-use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
-use de::{Deserialize, Deserializer, Error, IntoDeserializer, Visitor};
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-use de::{DeserializeSeed, MapAccess, Unexpected};
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub use self::content::{
-    Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
-    InternallyTaggedUnitVisitor, TagContentOtherField, TagContentOtherFieldVisitor,
-    TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
-};
-
-pub use seed::InPlaceSeed;
-
-/// If the missing field is of type `Option<T>` then treat is as `None`,
-/// otherwise it is an error.
-pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
-where
-    V: Deserialize<'de>,
-    E: Error,
-{
-    struct MissingFieldDeserializer<E>(&'static str, PhantomData<E>);
-
-    impl<'de, E> Deserializer<'de> for MissingFieldDeserializer<E>
-    where
-        E: Error,
-    {
-        type Error = E;
-
-        fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            Err(Error::missing_field(self.0))
-        }
-
-        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            visitor.visit_none()
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    let deserializer = MissingFieldDeserializer(field, PhantomData);
-    Deserialize::deserialize(deserializer)
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
-where
-    D: Deserializer<'de>,
-    R: From<Cow<'a, str>>,
-{
-    struct CowStrVisitor;
-
-    impl<'a> Visitor<'a> for CowStrVisitor {
-        type Value = Cow<'a, str>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a string")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.to_owned()))
-        }
-
-        fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Borrowed(v))
-        }
-
-        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v))
-        }
-
-        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            match str::from_utf8(v) {
-                Ok(s) => Ok(Cow::Owned(s.to_owned())),
-                Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-            }
-        }
-
-        fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            match str::from_utf8(v) {
-                Ok(s) => Ok(Cow::Borrowed(s)),
-                Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-            }
-        }
-
-        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            match String::from_utf8(v) {
-                Ok(s) => Ok(Cow::Owned(s)),
-                Err(e) => Err(Error::invalid_value(
-                    Unexpected::Bytes(&e.into_bytes()),
-                    &self,
-                )),
-            }
-        }
-    }
-
-    deserializer.deserialize_str(CowStrVisitor).map(From::from)
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D::Error>
-where
-    D: Deserializer<'de>,
-    R: From<Cow<'a, [u8]>>,
-{
-    struct CowBytesVisitor;
-
-    impl<'a> Visitor<'a> for CowBytesVisitor {
-        type Value = Cow<'a, [u8]>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("a byte array")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.as_bytes().to_vec()))
-        }
-
-        fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Borrowed(v.as_bytes()))
-        }
-
-        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.into_bytes()))
-        }
-
-        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.to_vec()))
-        }
-
-        fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Borrowed(v))
-        }
-
-        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v))
-        }
-    }
-
-    deserializer
-        .deserialize_bytes(CowBytesVisitor)
-        .map(From::from)
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-mod content {
-    // This module is private and nothing here should be used outside of
-    // generated code.
-    //
-    // We will iterate on the implementation for a few releases and only have to
-    // worry about backward compatibility for the `untagged` and `tag` attributes
-    // rather than for this entire mechanism.
-    //
-    // This issue is tracking making some of this stuff public:
-    // https://github.com/serde-rs/serde/issues/741
-
-    use lib::*;
-
-    use __private::size_hint;
-    use de::{
-        self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
-        MapAccess, SeqAccess, Unexpected, Visitor,
-    };
-
-    /// Used from generated code to buffer the contents of the Deserializer when
-    /// deserializing untagged enums and internally tagged enums.
-    ///
-    /// Not public API. Use serde-value instead.
-    #[derive(Debug)]
-    pub enum Content<'de> {
-        Bool(bool),
-
-        U8(u8),
-        U16(u16),
-        U32(u32),
-        U64(u64),
-
-        I8(i8),
-        I16(i16),
-        I32(i32),
-        I64(i64),
-
-        F32(f32),
-        F64(f64),
-
-        Char(char),
-        String(String),
-        Str(&'de str),
-        ByteBuf(Vec<u8>),
-        Bytes(&'de [u8]),
-
-        None,
-        Some(Box<Content<'de>>),
-
-        Unit,
-        Newtype(Box<Content<'de>>),
-        Seq(Vec<Content<'de>>),
-        Map(Vec<(Content<'de>, Content<'de>)>),
-    }
-
-    impl<'de> Content<'de> {
-        pub fn as_str(&self) -> Option<&str> {
-            match *self {
-                Content::Str(x) => Some(x),
-                Content::String(ref x) => Some(x),
-                Content::Bytes(x) => str::from_utf8(x).ok(),
-                Content::ByteBuf(ref x) => str::from_utf8(x).ok(),
-                _ => None,
-            }
-        }
-
-        #[cold]
-        fn unexpected(&self) -> Unexpected {
-            match *self {
-                Content::Bool(b) => Unexpected::Bool(b),
-                Content::U8(n) => Unexpected::Unsigned(n as u64),
-                Content::U16(n) => Unexpected::Unsigned(n as u64),
-                Content::U32(n) => Unexpected::Unsigned(n as u64),
-                Content::U64(n) => Unexpected::Unsigned(n),
-                Content::I8(n) => Unexpected::Signed(n as i64),
-                Content::I16(n) => Unexpected::Signed(n as i64),
-                Content::I32(n) => Unexpected::Signed(n as i64),
-                Content::I64(n) => Unexpected::Signed(n),
-                Content::F32(f) => Unexpected::Float(f as f64),
-                Content::F64(f) => Unexpected::Float(f),
-                Content::Char(c) => Unexpected::Char(c),
-                Content::String(ref s) => Unexpected::Str(s),
-                Content::Str(s) => Unexpected::Str(s),
-                Content::ByteBuf(ref b) => Unexpected::Bytes(b),
-                Content::Bytes(b) => Unexpected::Bytes(b),
-                Content::None | Content::Some(_) => Unexpected::Option,
-                Content::Unit => Unexpected::Unit,
-                Content::Newtype(_) => Unexpected::NewtypeStruct,
-                Content::Seq(_) => Unexpected::Seq,
-                Content::Map(_) => Unexpected::Map,
-            }
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Content<'de> {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            // Untagged and internally tagged enums are only supported in
-            // self-describing formats.
-            let visitor = ContentVisitor { value: PhantomData };
-            deserializer.deserialize_any(visitor)
-        }
-    }
-
-    struct ContentVisitor<'de> {
-        value: PhantomData<Content<'de>>,
-    }
-
-    impl<'de> ContentVisitor<'de> {
-        fn new() -> Self {
-            ContentVisitor { value: PhantomData }
-        }
-    }
-
-    impl<'de> Visitor<'de> for ContentVisitor<'de> {
-        type Value = Content<'de>;
-
-        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            fmt.write_str("any value")
-        }
-
-        fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::Bool(value))
-        }
-
-        fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::I8(value))
-        }
-
-        fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::I16(value))
-        }
-
-        fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::I32(value))
-        }
-
-        fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::I64(value))
-        }
-
-        fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::U8(value))
-        }
-
-        fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::U16(value))
-        }
-
-        fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::U32(value))
-        }
-
-        fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::U64(value))
-        }
-
-        fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::F32(value))
-        }
-
-        fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::F64(value))
-        }
-
-        fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::Char(value))
-        }
-
-        fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::String(value.into()))
-        }
-
-        fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::Str(value))
-        }
-
-        fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::String(value))
-        }
-
-        fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::ByteBuf(value.into()))
-        }
-
-        fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::Bytes(value))
-        }
-
-        fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::ByteBuf(value))
-        }
-
-        fn visit_unit<F>(self) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::Unit)
-        }
-
-        fn visit_none<F>(self) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            Ok(Content::None)
-        }
-
-        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            Deserialize::deserialize(deserializer).map(|v| Content::Some(Box::new(v)))
-        }
-
-        fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            Deserialize::deserialize(deserializer).map(|v| Content::Newtype(Box::new(v)))
-        }
-
-        fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: SeqAccess<'de>,
-        {
-            let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
-            while let Some(e) = try!(visitor.next_element()) {
-                vec.push(e);
-            }
-            Ok(Content::Seq(vec))
-        }
-
-        fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: MapAccess<'de>,
-        {
-            let mut vec = Vec::with_capacity(size_hint::cautious(visitor.size_hint()));
-            while let Some(kv) = try!(visitor.next_entry()) {
-                vec.push(kv);
-            }
-            Ok(Content::Map(vec))
-        }
-
-        fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: EnumAccess<'de>,
-        {
-            Err(de::Error::custom(
-                "untagged and internally tagged enums do not support enum input",
-            ))
-        }
-    }
-
-    /// This is the type of the map keys in an internally tagged enum.
-    ///
-    /// Not public API.
-    pub enum TagOrContent<'de> {
-        Tag,
-        Content(Content<'de>),
-    }
-
-    struct TagOrContentVisitor<'de> {
-        name: &'static str,
-        value: PhantomData<TagOrContent<'de>>,
-    }
-
-    impl<'de> TagOrContentVisitor<'de> {
-        fn new(name: &'static str) -> Self {
-            TagOrContentVisitor {
-                name: name,
-                value: PhantomData,
-            }
-        }
-    }
-
-    impl<'de> DeserializeSeed<'de> for TagOrContentVisitor<'de> {
-        type Value = TagOrContent<'de>;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            // Internally tagged enums are only supported in self-describing
-            // formats.
-            deserializer.deserialize_any(self)
-        }
-    }
-
-    impl<'de> Visitor<'de> for TagOrContentVisitor<'de> {
-        type Value = TagOrContent<'de>;
-
-        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            write!(fmt, "a type tag `{}` or any other value", self.name)
-        }
-
-        fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_bool(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_i8(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_i16(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_i32(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_i64(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_u8(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_u16(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_u32(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_u64(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_f32(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_f64(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_char(value)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_str(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_borrowed_str(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_string(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name.as_bytes() {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_bytes(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name.as_bytes() {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_borrowed_bytes(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            if value == self.name.as_bytes() {
-                Ok(TagOrContent::Tag)
-            } else {
-                ContentVisitor::new()
-                    .visit_byte_buf(value)
-                    .map(TagOrContent::Content)
-            }
-        }
-
-        fn visit_unit<F>(self) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_unit()
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_none<F>(self) -> Result<Self::Value, F>
-        where
-            F: de::Error,
-        {
-            ContentVisitor::new()
-                .visit_none()
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            ContentVisitor::new()
-                .visit_some(deserializer)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            ContentVisitor::new()
-                .visit_newtype_struct(deserializer)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: SeqAccess<'de>,
-        {
-            ContentVisitor::new()
-                .visit_seq(visitor)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: MapAccess<'de>,
-        {
-            ContentVisitor::new()
-                .visit_map(visitor)
-                .map(TagOrContent::Content)
-        }
-
-        fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
-        where
-            V: EnumAccess<'de>,
-        {
-            ContentVisitor::new()
-                .visit_enum(visitor)
-                .map(TagOrContent::Content)
-        }
-    }
-
-    /// Used by generated code to deserialize an internally tagged enum.
-    ///
-    /// Not public API.
-    pub struct TaggedContent<'de, T> {
-        pub tag: T,
-        pub content: Content<'de>,
-    }
-
-    /// Not public API.
-    pub struct TaggedContentVisitor<'de, T> {
-        tag_name: &'static str,
-        expecting: &'static str,
-        value: PhantomData<TaggedContent<'de, T>>,
-    }
-
-    impl<'de, T> TaggedContentVisitor<'de, T> {
-        /// Visitor for the content of an internally tagged enum with the given
-        /// tag name.
-        pub fn new(name: &'static str, expecting: &'static str) -> Self {
-            TaggedContentVisitor {
-                tag_name: name,
-                expecting: expecting,
-                value: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, T> DeserializeSeed<'de> for TaggedContentVisitor<'de, T>
-    where
-        T: Deserialize<'de>,
-    {
-        type Value = TaggedContent<'de, T>;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            // Internally tagged enums are only supported in self-describing
-            // formats.
-            deserializer.deserialize_any(self)
-        }
-    }
-
-    impl<'de, T> Visitor<'de> for TaggedContentVisitor<'de, T>
-    where
-        T: Deserialize<'de>,
-    {
-        type Value = TaggedContent<'de, T>;
-
-        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            fmt.write_str(self.expecting)
-        }
-
-        fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
-        where
-            S: SeqAccess<'de>,
-        {
-            let tag = match try!(seq.next_element()) {
-                Some(tag) => tag,
-                None => {
-                    return Err(de::Error::missing_field(self.tag_name));
-                }
-            };
-            let rest = de::value::SeqAccessDeserializer::new(seq);
-            Ok(TaggedContent {
-                tag: tag,
-                content: try!(Content::deserialize(rest)),
-            })
-        }
-
-        fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
-        where
-            M: MapAccess<'de>,
-        {
-            let mut tag = None;
-            let mut vec = Vec::with_capacity(size_hint::cautious(map.size_hint()));
-            while let Some(k) = try!(map.next_key_seed(TagOrContentVisitor::new(self.tag_name))) {
-                match k {
-                    TagOrContent::Tag => {
-                        if tag.is_some() {
-                            return Err(de::Error::duplicate_field(self.tag_name));
-                        }
-                        tag = Some(try!(map.next_value()));
-                    }
-                    TagOrContent::Content(k) => {
-                        let v = try!(map.next_value());
-                        vec.push((k, v));
-                    }
-                }
-            }
-            match tag {
-                None => Err(de::Error::missing_field(self.tag_name)),
-                Some(tag) => Ok(TaggedContent {
-                    tag: tag,
-                    content: Content::Map(vec),
-                }),
-            }
-        }
-    }
-
-    /// Used by generated code to deserialize an adjacently tagged enum.
-    ///
-    /// Not public API.
-    pub enum TagOrContentField {
-        Tag,
-        Content,
-    }
-
-    /// Not public API.
-    pub struct TagOrContentFieldVisitor {
-        pub tag: &'static str,
-        pub content: &'static str,
-    }
-
-    impl<'de> DeserializeSeed<'de> for TagOrContentFieldVisitor {
-        type Value = TagOrContentField;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_str(self)
-        }
-    }
-
-    impl<'de> Visitor<'de> for TagOrContentFieldVisitor {
-        type Value = TagOrContentField;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(formatter, "{:?} or {:?}", self.tag, self.content)
-        }
-
-        fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
-        where
-            E: de::Error,
-        {
-            if field == self.tag {
-                Ok(TagOrContentField::Tag)
-            } else if field == self.content {
-                Ok(TagOrContentField::Content)
-            } else {
-                Err(de::Error::invalid_value(Unexpected::Str(field), &self))
-            }
-        }
-    }
-
-    /// Used by generated code to deserialize an adjacently tagged enum when
-    /// ignoring unrelated fields is allowed.
-    ///
-    /// Not public API.
-    pub enum TagContentOtherField {
-        Tag,
-        Content,
-        Other,
-    }
-
-    /// Not public API.
-    pub struct TagContentOtherFieldVisitor {
-        pub tag: &'static str,
-        pub content: &'static str,
-    }
-
-    impl<'de> DeserializeSeed<'de> for TagContentOtherFieldVisitor {
-        type Value = TagContentOtherField;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_str(self)
-        }
-    }
-
-    impl<'de> Visitor<'de> for TagContentOtherFieldVisitor {
-        type Value = TagContentOtherField;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(
-                formatter,
-                "{:?}, {:?}, or other ignored fields",
-                self.tag, self.content
-            )
-        }
-
-        fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
-        where
-            E: de::Error,
-        {
-            if field == self.tag {
-                Ok(TagContentOtherField::Tag)
-            } else if field == self.content {
-                Ok(TagContentOtherField::Content)
-            } else {
-                Ok(TagContentOtherField::Other)
-            }
-        }
-    }
-
-    /// Not public API
-    pub struct ContentDeserializer<'de, E> {
-        content: Content<'de>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> ContentDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        #[cold]
-        fn invalid_type(self, exp: &Expected) -> E {
-            de::Error::invalid_type(self.content.unexpected(), exp)
-        }
-
-        fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-    }
-
-    fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
-    where
-        V: Visitor<'de>,
-        E: de::Error,
-    {
-        let seq = content.into_iter().map(ContentDeserializer::new);
-        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
-        let value = try!(visitor.visit_seq(&mut seq_visitor));
-        try!(seq_visitor.end());
-        Ok(value)
-    }
-
-    fn visit_content_map<'de, V, E>(
-        content: Vec<(Content<'de>, Content<'de>)>,
-        visitor: V,
-    ) -> Result<V::Value, E>
-    where
-        V: Visitor<'de>,
-        E: de::Error,
-    {
-        let map = content
-            .into_iter()
-            .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
-        let mut map_visitor = de::value::MapDeserializer::new(map);
-        let value = try!(visitor.visit_map(&mut map_visitor));
-        try!(map_visitor.end());
-        Ok(value)
-    }
-
-    /// Used when deserializing an internally tagged enum because the content
-    /// will be used exactly once.
-    impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Bool(v) => visitor.visit_bool(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::Char(v) => visitor.visit_char(v),
-                Content::String(v) => visitor.visit_string(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::Unit => visitor.visit_unit(),
-                Content::None => visitor.visit_none(),
-                Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
-                Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
-                Content::Seq(v) => visit_content_seq(v, visitor),
-                Content::Map(v) => visit_content_map(v, visitor),
-            }
-        }
-
-        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Bool(v) => visitor.visit_bool(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_float(visitor)
-        }
-
-        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_float(visitor)
-        }
-
-        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Char(v) => visitor.visit_char(v),
-                Content::String(v) => visitor.visit_string(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_string(visitor)
-        }
-
-        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::String(v) => visitor.visit_string(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_byte_buf(visitor)
-        }
-
-        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::String(v) => visitor.visit_string(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::Seq(v) => visit_content_seq(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::None => visitor.visit_none(),
-                Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
-                Content::Unit => visitor.visit_unit(),
-                _ => visitor.visit_some(self),
-            }
-        }
-
-        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Unit => visitor.visit_unit(),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_unit_struct<V>(
-            self,
-            _name: &'static str,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                // As a special case, allow deserializing untagged newtype
-                // variant containing unit struct.
-                //
-                //     #[derive(Deserialize)]
-                //     struct Info;
-                //
-                //     #[derive(Deserialize)]
-                //     #[serde(tag = "topic")]
-                //     enum Message {
-                //         Info(Info),
-                //     }
-                //
-                // We want {"topic":"Info"} to deserialize even though
-                // ordinarily unit structs do not deserialize from empty map/seq.
-                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
-                Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(),
-                _ => self.deserialize_any(visitor),
-            }
-        }
-
-        fn deserialize_newtype_struct<V>(
-            self,
-            _name: &str,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
-                _ => visitor.visit_newtype_struct(self),
-            }
-        }
-
-        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Seq(v) => visit_content_seq(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_seq(visitor)
-        }
-
-        fn deserialize_tuple_struct<V>(
-            self,
-            _name: &'static str,
-            _len: usize,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_seq(visitor)
-        }
-
-        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Map(v) => visit_content_map(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_struct<V>(
-            self,
-            _name: &'static str,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::Seq(v) => visit_content_seq(v, visitor),
-                Content::Map(v) => visit_content_map(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_enum<V>(
-            self,
-            _name: &str,
-            _variants: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            let (variant, value) = match self.content {
-                Content::Map(value) => {
-                    let mut iter = value.into_iter();
-                    let (variant, value) = match iter.next() {
-                        Some(v) => v,
-                        None => {
-                            return Err(de::Error::invalid_value(
-                                de::Unexpected::Map,
-                                &"map with a single key",
-                            ));
-                        }
-                    };
-                    // enums are encoded in json as maps with a single key:value pair
-                    if iter.next().is_some() {
-                        return Err(de::Error::invalid_value(
-                            de::Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                    (variant, Some(value))
-                }
-                s @ Content::String(_) | s @ Content::Str(_) => (s, None),
-                other => {
-                    return Err(de::Error::invalid_type(
-                        other.unexpected(),
-                        &"string or map",
-                    ));
-                }
-            };
-
-            visitor.visit_enum(EnumDeserializer::new(variant, value))
-        }
-
-        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.content {
-                Content::String(v) => visitor.visit_string(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            drop(self);
-            visitor.visit_unit()
-        }
-    }
-
-    impl<'de, E> ContentDeserializer<'de, E> {
-        /// private API, don't use
-        pub fn new(content: Content<'de>) -> Self {
-            ContentDeserializer {
-                content: content,
-                err: PhantomData,
-            }
-        }
-    }
-
-    pub struct EnumDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        variant: Content<'de>,
-        value: Option<Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> EnumDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
-            EnumDeserializer {
-                variant: variant,
-                value: value,
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-        type Variant = VariantDeserializer<'de, Self::Error>;
-
-        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
-        where
-            V: de::DeserializeSeed<'de>,
-        {
-            let visitor = VariantDeserializer {
-                value: self.value,
-                err: PhantomData,
-            };
-            seed.deserialize(ContentDeserializer::new(self.variant))
-                .map(|v| (v, visitor))
-        }
-    }
-
-    pub struct VariantDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        value: Option<Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> de::VariantAccess<'de> for VariantDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn unit_variant(self) -> Result<(), E> {
-            match self.value {
-                Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)),
-                None => Ok(()),
-            }
-        }
-
-        fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.value {
-                Some(value) => seed.deserialize(ContentDeserializer::new(value)),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"newtype variant",
-                )),
-            }
-        }
-
-        fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            match self.value {
-                Some(Content::Seq(v)) => {
-                    de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
-                }
-                Some(other) => Err(de::Error::invalid_type(
-                    other.unexpected(),
-                    &"tuple variant",
-                )),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"tuple variant",
-                )),
-            }
-        }
-
-        fn struct_variant<V>(
-            self,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            match self.value {
-                Some(Content::Map(v)) => {
-                    de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
-                }
-                Some(Content::Seq(v)) => {
-                    de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
-                }
-                Some(other) => Err(de::Error::invalid_type(
-                    other.unexpected(),
-                    &"struct variant",
-                )),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"struct variant",
-                )),
-            }
-        }
-    }
-
-    struct SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        iter: <Vec<Content<'de>> as IntoIterator>::IntoIter,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(vec: Vec<Content<'de>>) -> Self {
-            SeqDeserializer {
-                iter: vec.into_iter(),
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, E> de::Deserializer<'de> for SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            let len = self.iter.len();
-            if len == 0 {
-                visitor.visit_unit()
-            } else {
-                let ret = try!(visitor.visit_seq(&mut self));
-                let remaining = self.iter.len();
-                if remaining == 0 {
-                    Ok(ret)
-                } else {
-                    Err(de::Error::invalid_length(len, &"fewer elements in array"))
-                }
-            }
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    impl<'de, E> de::SeqAccess<'de> for SeqDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
-                None => Ok(None),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    struct MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        iter: <Vec<(Content<'de>, Content<'de>)> as IntoIterator>::IntoIter,
-        value: Option<Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, E> MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(map: Vec<(Content<'de>, Content<'de>)>) -> Self {
-            MapDeserializer {
-                iter: map.into_iter(),
-                value: None,
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, E> de::MapAccess<'de> for MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some((key, value)) => {
-                    self.value = Some(value);
-                    seed.deserialize(ContentDeserializer::new(key)).map(Some)
-                }
-                None => Ok(None),
-            }
-        }
-
-        fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.value.take() {
-                Some(value) => seed.deserialize(ContentDeserializer::new(value)),
-                None => Err(de::Error::custom("value is missing")),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    impl<'de, E> de::Deserializer<'de> for MapDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            visitor.visit_map(self)
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    /// Not public API.
-    pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
-        content: &'a Content<'de>,
-        err: PhantomData<E>,
-    }
-
-    impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        #[cold]
-        fn invalid_type(self, exp: &Expected) -> E {
-            de::Error::invalid_type(self.content.unexpected(), exp)
-        }
-
-        fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-    }
-
-    fn visit_content_seq_ref<'a, 'de, V, E>(
-        content: &'a [Content<'de>],
-        visitor: V,
-    ) -> Result<V::Value, E>
-    where
-        V: Visitor<'de>,
-        E: de::Error,
-    {
-        let seq = content.iter().map(ContentRefDeserializer::new);
-        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
-        let value = try!(visitor.visit_seq(&mut seq_visitor));
-        try!(seq_visitor.end());
-        Ok(value)
-    }
-
-    fn visit_content_map_ref<'a, 'de, V, E>(
-        content: &'a [(Content<'de>, Content<'de>)],
-        visitor: V,
-    ) -> Result<V::Value, E>
-    where
-        V: Visitor<'de>,
-        E: de::Error,
-    {
-        let map = content.iter().map(|&(ref k, ref v)| {
-            (
-                ContentRefDeserializer::new(k),
-                ContentRefDeserializer::new(v),
-            )
-        });
-        let mut map_visitor = de::value::MapDeserializer::new(map);
-        let value = try!(visitor.visit_map(&mut map_visitor));
-        try!(map_visitor.end());
-        Ok(value)
-    }
-
-    /// Used when deserializing an untagged enum because the content may need
-    /// to be used more than once.
-    impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Bool(v) => visitor.visit_bool(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U16(v) => visitor.visit_u16(v),
-                Content::U32(v) => visitor.visit_u32(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                Content::I8(v) => visitor.visit_i8(v),
-                Content::I16(v) => visitor.visit_i16(v),
-                Content::I32(v) => visitor.visit_i32(v),
-                Content::I64(v) => visitor.visit_i64(v),
-                Content::F32(v) => visitor.visit_f32(v),
-                Content::F64(v) => visitor.visit_f64(v),
-                Content::Char(v) => visitor.visit_char(v),
-                Content::String(ref v) => visitor.visit_str(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::Unit => visitor.visit_unit(),
-                Content::None => visitor.visit_none(),
-                Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
-                Content::Newtype(ref v) => {
-                    visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
-                }
-                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
-                Content::Map(ref v) => visit_content_map_ref(v, visitor),
-            }
-        }
-
-        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Bool(v) => visitor.visit_bool(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_integer(visitor)
-        }
-
-        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_float(visitor)
-        }
-
-        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_float(visitor)
-        }
-
-        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Char(v) => visitor.visit_char(v),
-                Content::String(ref v) => visitor.visit_str(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::String(ref v) => visitor.visit_str(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_str(visitor)
-        }
-
-        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::String(ref v) => visitor.visit_str(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_bytes(visitor)
-        }
-
-        fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::None => visitor.visit_none(),
-                Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
-                Content::Unit => visitor.visit_unit(),
-                _ => visitor.visit_some(self),
-            }
-        }
-
-        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Unit => visitor.visit_unit(),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_unit_struct<V>(
-            self,
-            _name: &'static str,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_unit(visitor)
-        }
-
-        fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Newtype(ref v) => {
-                    visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
-                }
-                _ => visitor.visit_newtype_struct(self),
-            }
-        }
-
-        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_seq(visitor)
-        }
-
-        fn deserialize_tuple_struct<V>(
-            self,
-            _name: &'static str,
-            _len: usize,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_seq(visitor)
-        }
-
-        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Map(ref v) => visit_content_map_ref(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_struct<V>(
-            self,
-            _name: &'static str,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
-                Content::Map(ref v) => visit_content_map_ref(v, visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_enum<V>(
-            self,
-            _name: &str,
-            _variants: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            let (variant, value) = match *self.content {
-                Content::Map(ref value) => {
-                    let mut iter = value.iter();
-                    let &(ref variant, ref value) = match iter.next() {
-                        Some(v) => v,
-                        None => {
-                            return Err(de::Error::invalid_value(
-                                de::Unexpected::Map,
-                                &"map with a single key",
-                            ));
-                        }
-                    };
-                    // enums are encoded in json as maps with a single key:value pair
-                    if iter.next().is_some() {
-                        return Err(de::Error::invalid_value(
-                            de::Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                    (variant, Some(value))
-                }
-                ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
-                ref other => {
-                    return Err(de::Error::invalid_type(
-                        other.unexpected(),
-                        &"string or map",
-                    ));
-                }
-            };
-
-            visitor.visit_enum(EnumRefDeserializer {
-                variant: variant,
-                value: value,
-                err: PhantomData,
-            })
-        }
-
-        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            match *self.content {
-                Content::String(ref v) => visitor.visit_str(v),
-                Content::Str(v) => visitor.visit_borrowed_str(v),
-                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
-                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
-                Content::U8(v) => visitor.visit_u8(v),
-                Content::U64(v) => visitor.visit_u64(v),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            visitor.visit_unit()
-        }
-    }
-
-    impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
-        /// private API, don't use
-        pub fn new(content: &'a Content<'de>) -> Self {
-            ContentRefDeserializer {
-                content: content,
-                err: PhantomData,
-            }
-        }
-    }
-
-    struct EnumRefDeserializer<'a, 'de: 'a, E>
-    where
-        E: de::Error,
-    {
-        variant: &'a Content<'de>,
-        value: Option<&'a Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, 'a, E> de::EnumAccess<'de> for EnumRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-        type Variant = VariantRefDeserializer<'a, 'de, Self::Error>;
-
-        fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-        where
-            V: de::DeserializeSeed<'de>,
-        {
-            let visitor = VariantRefDeserializer {
-                value: self.value,
-                err: PhantomData,
-            };
-            seed.deserialize(ContentRefDeserializer::new(self.variant))
-                .map(|v| (v, visitor))
-        }
-    }
-
-    struct VariantRefDeserializer<'a, 'de: 'a, E>
-    where
-        E: de::Error,
-    {
-        value: Option<&'a Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'de, 'a, E> de::VariantAccess<'de> for VariantRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn unit_variant(self) -> Result<(), E> {
-            match self.value {
-                Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
-                None => Ok(()),
-            }
-        }
-
-        fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.value {
-                Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"newtype variant",
-                )),
-            }
-        }
-
-        fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            match self.value {
-                Some(&Content::Seq(ref v)) => {
-                    de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
-                }
-                Some(other) => Err(de::Error::invalid_type(
-                    other.unexpected(),
-                    &"tuple variant",
-                )),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"tuple variant",
-                )),
-            }
-        }
-
-        fn struct_variant<V>(
-            self,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            match self.value {
-                Some(&Content::Map(ref v)) => {
-                    de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
-                }
-                Some(&Content::Seq(ref v)) => {
-                    de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
-                }
-                Some(other) => Err(de::Error::invalid_type(
-                    other.unexpected(),
-                    &"struct variant",
-                )),
-                None => Err(de::Error::invalid_type(
-                    de::Unexpected::UnitVariant,
-                    &"struct variant",
-                )),
-            }
-        }
-    }
-
-    struct SeqRefDeserializer<'a, 'de: 'a, E>
-    where
-        E: de::Error,
-    {
-        iter: <&'a [Content<'de>] as IntoIterator>::IntoIter,
-        err: PhantomData<E>,
-    }
-
-    impl<'a, 'de, E> SeqRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(slice: &'a [Content<'de>]) -> Self {
-            SeqRefDeserializer {
-                iter: slice.iter(),
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, 'a, E> de::Deserializer<'de> for SeqRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            let len = self.iter.len();
-            if len == 0 {
-                visitor.visit_unit()
-            } else {
-                let ret = try!(visitor.visit_seq(&mut self));
-                let remaining = self.iter.len();
-                if remaining == 0 {
-                    Ok(ret)
-                } else {
-                    Err(de::Error::invalid_length(len, &"fewer elements in array"))
-                }
-            }
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    impl<'de, 'a, E> de::SeqAccess<'de> for SeqRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some(value) => seed
-                    .deserialize(ContentRefDeserializer::new(value))
-                    .map(Some),
-                None => Ok(None),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    struct MapRefDeserializer<'a, 'de: 'a, E>
-    where
-        E: de::Error,
-    {
-        iter: <&'a [(Content<'de>, Content<'de>)] as IntoIterator>::IntoIter,
-        value: Option<&'a Content<'de>>,
-        err: PhantomData<E>,
-    }
-
-    impl<'a, 'de, E> MapRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        fn new(map: &'a [(Content<'de>, Content<'de>)]) -> Self {
-            MapRefDeserializer {
-                iter: map.iter(),
-                value: None,
-                err: PhantomData,
-            }
-        }
-    }
-
-    impl<'de, 'a, E> de::MapAccess<'de> for MapRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.iter.next() {
-                Some(&(ref key, ref value)) => {
-                    self.value = Some(value);
-                    seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
-                }
-                None => Ok(None),
-            }
-        }
-
-        fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            match self.value.take() {
-                Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
-                None => Err(de::Error::custom("value is missing")),
-            }
-        }
-
-        fn size_hint(&self) -> Option<usize> {
-            size_hint::from_bounds(&self.iter)
-        }
-    }
-
-    impl<'de, 'a, E> de::Deserializer<'de> for MapRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        #[inline]
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            visitor.visit_map(self)
-        }
-
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-            bytes byte_buf option unit unit_struct newtype_struct seq tuple
-            tuple_struct map struct enum identifier ignored_any
-        }
-    }
-
-    impl<'de, E> de::IntoDeserializer<'de, E> for ContentDeserializer<'de, E>
-    where
-        E: de::Error,
-    {
-        type Deserializer = Self;
-
-        fn into_deserializer(self) -> Self {
-            self
-        }
-    }
-
-    impl<'de, 'a, E> de::IntoDeserializer<'de, E> for ContentRefDeserializer<'a, 'de, E>
-    where
-        E: de::Error,
-    {
-        type Deserializer = Self;
-
-        fn into_deserializer(self) -> Self {
-            self
-        }
-    }
-
-    /// Visitor for deserializing an internally tagged unit variant.
-    ///
-    /// Not public API.
-    pub struct InternallyTaggedUnitVisitor<'a> {
-        type_name: &'a str,
-        variant_name: &'a str,
-    }
-
-    impl<'a> InternallyTaggedUnitVisitor<'a> {
-        /// Not public API.
-        pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
-            InternallyTaggedUnitVisitor {
-                type_name: type_name,
-                variant_name: variant_name,
-            }
-        }
-    }
-
-    impl<'de, 'a> Visitor<'de> for InternallyTaggedUnitVisitor<'a> {
-        type Value = ();
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(
-                formatter,
-                "unit variant {}::{}",
-                self.type_name, self.variant_name
-            )
-        }
-
-        fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
-        where
-            S: SeqAccess<'de>,
-        {
-            Ok(())
-        }
-
-        fn visit_map<M>(self, mut access: M) -> Result<(), M::Error>
-        where
-            M: MapAccess<'de>,
-        {
-            while try!(access.next_entry::<IgnoredAny, IgnoredAny>()).is_some() {}
-            Ok(())
-        }
-    }
-
-    /// Visitor for deserializing an untagged unit variant.
-    ///
-    /// Not public API.
-    pub struct UntaggedUnitVisitor<'a> {
-        type_name: &'a str,
-        variant_name: &'a str,
-    }
-
-    impl<'a> UntaggedUnitVisitor<'a> {
-        /// Not public API.
-        pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
-            UntaggedUnitVisitor {
-                type_name: type_name,
-                variant_name: variant_name,
-            }
-        }
-    }
-
-    impl<'de, 'a> Visitor<'de> for UntaggedUnitVisitor<'a> {
-        type Value = ();
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(
-                formatter,
-                "unit variant {}::{}",
-                self.type_name, self.variant_name
-            )
-        }
-
-        fn visit_unit<E>(self) -> Result<(), E>
-        where
-            E: de::Error,
-        {
-            Ok(())
-        }
-
-        fn visit_none<E>(self) -> Result<(), E>
-        where
-            E: de::Error,
-        {
-            Ok(())
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Like `IntoDeserializer` but also implemented for `&[u8]`. This is used for
-// the newtype fallthrough case of `field_identifier`.
-//
-//    #[derive(Deserialize)]
-//    #[serde(field_identifier)]
-//    enum F {
-//        A,
-//        B,
-//        Other(String), // deserialized using IdentifierDeserializer
-//    }
-pub trait IdentifierDeserializer<'de, E: Error> {
-    type Deserializer: Deserializer<'de, Error = E>;
-
-    fn from(self) -> Self::Deserializer;
-}
-
-pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
-
-impl<'de, E> IdentifierDeserializer<'de, E> for u64
-where
-    E: Error,
-{
-    type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
-
-    fn from(self) -> Self::Deserializer {
-        self.into_deserializer()
-    }
-}
-
-pub struct StrDeserializer<'a, E> {
-    value: &'a str,
-    marker: PhantomData<E>,
-}
-
-impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_str(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-pub struct BorrowedStrDeserializer<'de, E> {
-    value: &'de str,
-    marker: PhantomData<E>,
-}
-
-impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
-where
-    E: Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
-where
-    E: Error,
-{
-    type Deserializer = BorrowedStrDeserializer<'de, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BorrowedStrDeserializer {
-            value: self.0,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
-where
-    E: Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BytesDeserializer::new(self)
-    }
-}
-
-impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
-where
-    E: Error,
-{
-    type Deserializer = BorrowedBytesDeserializer<'de, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BorrowedBytesDeserializer::new(self.0)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
-    pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,
-    pub PhantomData<E>,
-);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> FlatMapDeserializer<'a, 'de, E>
-where
-    E: Error,
-{
-    fn deserialize_other<V>() -> Result<V, E> {
-        Err(Error::custom("can only flatten structs and maps"))
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-macro_rules! forward_to_deserialize_other {
-    ($($func:ident ( $($arg:ty),* ))*) => {
-        $(
-            fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
-            where
-                V: Visitor<'de>,
-            {
-                Self::deserialize_other()
-            }
-        )*
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_map(FlatInternallyTaggedAccess {
-            iter: self.0.iter_mut(),
-            pending: None,
-            _marker: PhantomData,
-        })
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        for item in self.0.iter_mut() {
-            // items in the vector are nulled out when used.  So we can only use
-            // an item if it's still filled in and if the field is one we care
-            // about.
-            let use_item = match *item {
-                None => false,
-                Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x)),
-            };
-
-            if use_item {
-                let (key, value) = item.take().unwrap();
-                return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
-            }
-        }
-
-        Err(Error::custom(format_args!(
-            "no variant of enum {} found in flattened data",
-            name
-        )))
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_map(FlatMapAccess::new(self.0.iter()))
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_map(FlatStructAccess::new(self.0.iter_mut(), fields))
-    }
-
-    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        match visitor.__private_visit_untagged_option(self) {
-            Ok(value) => Ok(value),
-            Err(()) => Self::deserialize_other(),
-        }
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-
-    forward_to_deserialize_other! {
-        deserialize_bool()
-        deserialize_i8()
-        deserialize_i16()
-        deserialize_i32()
-        deserialize_i64()
-        deserialize_u8()
-        deserialize_u16()
-        deserialize_u32()
-        deserialize_u64()
-        deserialize_f32()
-        deserialize_f64()
-        deserialize_char()
-        deserialize_str()
-        deserialize_string()
-        deserialize_bytes()
-        deserialize_byte_buf()
-        deserialize_unit_struct(&'static str)
-        deserialize_seq()
-        deserialize_tuple(usize)
-        deserialize_tuple_struct(&'static str, usize)
-        deserialize_identifier()
-        deserialize_ignored_any()
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapAccess<'a, 'de: 'a, E> {
-    iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
-    pending_content: Option<&'a Content<'de>>,
-    _marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
-    fn new(
-        iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
-    ) -> FlatMapAccess<'a, 'de, E> {
-        FlatMapAccess {
-            iter: iter,
-            pending_content: None,
-            _marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        for item in &mut self.iter {
-            // Items in the vector are nulled out when used by a struct.
-            if let Some((ref key, ref content)) = *item {
-                self.pending_content = Some(content);
-                return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
-            }
-        }
-        Ok(None)
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.pending_content.take() {
-            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
-            None => Err(Error::custom("value is missing")),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatStructAccess<'a, 'de: 'a, E> {
-    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-    pending_content: Option<Content<'de>>,
-    fields: &'static [&'static str],
-    _marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> FlatStructAccess<'a, 'de, E> {
-    fn new(
-        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-        fields: &'static [&'static str],
-    ) -> FlatStructAccess<'a, 'de, E> {
-        FlatStructAccess {
-            iter: iter,
-            pending_content: None,
-            fields: fields,
-            _marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> MapAccess<'de> for FlatStructAccess<'a, 'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        while let Some(item) = self.iter.next() {
-            // items in the vector are nulled out when used.  So we can only use
-            // an item if it's still filled in and if the field is one we care
-            // about.  In case we do not know which fields we want, we take them all.
-            let use_item = match *item {
-                None => false,
-                Some((ref c, _)) => c.as_str().map_or(false, |key| self.fields.contains(&key)),
-            };
-
-            if use_item {
-                let (key, content) = item.take().unwrap();
-                self.pending_content = Some(content);
-                return seed.deserialize(ContentDeserializer::new(key)).map(Some);
-            }
-        }
-        Ok(None)
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.pending_content.take() {
-            Some(value) => seed.deserialize(ContentDeserializer::new(value)),
-            None => Err(Error::custom("value is missing")),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatInternallyTaggedAccess<'a, 'de: 'a, E> {
-    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-    pending: Option<&'a Content<'de>>,
-    _marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de, E> MapAccess<'de> for FlatInternallyTaggedAccess<'a, 'de, E>
-where
-    E: Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        for item in &mut self.iter {
-            if let Some((ref key, ref content)) = *item {
-                // Do not take(), instead borrow this entry. The internally tagged
-                // enum does its own buffering so we can't tell whether this entry
-                // is going to be consumed. Borrowing here leaves the entry
-                // available for later flattened fields.
-                self.pending = Some(content);
-                return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
-            }
-        }
-        Ok(None)
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.pending.take() {
-            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
-            None => panic!("value is missing"),
-        }
-    }
-}
diff --git a/vendor/serde/src/private/doc.rs b/vendor/serde/src/private/doc.rs
deleted file mode 100644
index f597af84..00000000
--- a/vendor/serde/src/private/doc.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-// Used only by Serde doc tests. Not public API.
-
-use lib::*;
-
-use ser;
-
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Error;
-
-impl ser::Error for Error {
-    fn custom<T>(_: T) -> Self
-    where
-        T: Display,
-    {
-        unimplemented!()
-    }
-}
-
-#[cfg(feature = "std")]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        unimplemented!()
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        unimplemented!()
-    }
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __private_serialize {
-    () => {
-        trait Serialize {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::Serializer;
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! __serialize_unimplemented {
-    ($($func:ident)*) => {
-        $(
-            __serialize_unimplemented_helper!($func);
-        )*
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __serialize_unimplemented_method {
-    ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
-            unimplemented!()
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! __serialize_unimplemented_helper {
-    (bool) => {
-        __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
-    };
-    (i8) => {
-        __serialize_unimplemented_method!(serialize_i8(i8) -> Ok);
-    };
-    (i16) => {
-        __serialize_unimplemented_method!(serialize_i16(i16) -> Ok);
-    };
-    (i32) => {
-        __serialize_unimplemented_method!(serialize_i32(i32) -> Ok);
-    };
-    (i64) => {
-        __serialize_unimplemented_method!(serialize_i64(i64) -> Ok);
-    };
-    (u8) => {
-        __serialize_unimplemented_method!(serialize_u8(u8) -> Ok);
-    };
-    (u16) => {
-        __serialize_unimplemented_method!(serialize_u16(u16) -> Ok);
-    };
-    (u32) => {
-        __serialize_unimplemented_method!(serialize_u32(u32) -> Ok);
-    };
-    (u64) => {
-        __serialize_unimplemented_method!(serialize_u64(u64) -> Ok);
-    };
-    (f32) => {
-        __serialize_unimplemented_method!(serialize_f32(f32) -> Ok);
-    };
-    (f64) => {
-        __serialize_unimplemented_method!(serialize_f64(f64) -> Ok);
-    };
-    (char) => {
-        __serialize_unimplemented_method!(serialize_char(char) -> Ok);
-    };
-    (str) => {
-        __serialize_unimplemented_method!(serialize_str(&str) -> Ok);
-    };
-    (bytes) => {
-        __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok);
-    };
-    (none) => {
-        __serialize_unimplemented_method!(serialize_none() -> Ok);
-    };
-    (some) => {
-        __serialize_unimplemented_method!(serialize_some<T>(&T) -> Ok);
-    };
-    (unit) => {
-        __serialize_unimplemented_method!(serialize_unit() -> Ok);
-    };
-    (unit_struct) => {
-        __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok);
-    };
-    (unit_variant) => {
-        __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok);
-    };
-    (newtype_struct) => {
-        __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str, &T) -> Ok);
-    };
-    (newtype_variant) => {
-        __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str, u32, &str, &T) -> Ok);
-    };
-    (seq) => {
-        type SerializeSeq = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_seq(Option<usize>) -> SerializeSeq);
-    };
-    (tuple) => {
-        type SerializeTuple = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple);
-    };
-    (tuple_struct) => {
-        type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct);
-    };
-    (tuple_variant) => {
-        type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant);
-    };
-    (map) => {
-        type SerializeMap = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_map(Option<usize>) -> SerializeMap);
-    };
-    (struct) => {
-        type SerializeStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct);
-    };
-    (struct_variant) => {
-        type SerializeStructVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant);
-    };
-}
diff --git a/vendor/serde/src/private/mod.rs b/vendor/serde/src/private/mod.rs
deleted file mode 100644
index 71e82a89..00000000
--- a/vendor/serde/src/private/mod.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#[cfg(serde_derive)]
-pub mod de;
-#[cfg(serde_derive)]
-pub mod ser;
-
-pub mod size_hint;
-
-// FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed.
-pub mod doc;
-
-pub use lib::clone::Clone;
-pub use lib::convert::{From, Into};
-pub use lib::default::Default;
-pub use lib::fmt::{self, Formatter};
-pub use lib::marker::PhantomData;
-pub use lib::option::Option::{self, None, Some};
-pub use lib::ptr;
-pub use lib::result::Result::{self, Err, Ok};
-
-pub use self::string::from_utf8_lossy;
-
-#[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::{ToString, Vec};
-
-#[cfg(core_try_from)]
-pub use lib::convert::TryFrom;
-
-mod string {
-    use lib::*;
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
-        String::from_utf8_lossy(bytes)
-    }
-
-    // The generated code calls this like:
-    //
-    //     let value = &_serde::__private::from_utf8_lossy(bytes);
-    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-    //
-    // so it is okay for the return type to be different from the std case as long
-    // as the above works.
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
-        // Three unicode replacement characters if it fails. They look like a
-        // white-on-black question mark. The user will recognize it as invalid
-        // UTF-8.
-        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-    }
-}
diff --git a/vendor/serde/src/private/ser.rs b/vendor/serde/src/private/ser.rs
deleted file mode 100644
index 6ee99938..00000000
--- a/vendor/serde/src/private/ser.rs
+++ /dev/null
@@ -1,1310 +0,0 @@
-use lib::*;
-
-use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-use self::content::{
-    Content, ContentSerializer, SerializeStructVariantAsMapValue, SerializeTupleVariantAsMapValue,
-};
-
-/// Used to check that serde(getter) attributes return the expected type.
-/// Not public API.
-pub fn constrain<T: ?Sized>(t: &T) -> &T {
-    t
-}
-
-/// Not public API.
-pub fn serialize_tagged_newtype<S, T>(
-    serializer: S,
-    type_ident: &'static str,
-    variant_ident: &'static str,
-    tag: &'static str,
-    variant_name: &'static str,
-    value: &T,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-    T: Serialize,
-{
-    value.serialize(TaggedSerializer {
-        type_ident: type_ident,
-        variant_ident: variant_ident,
-        tag: tag,
-        variant_name: variant_name,
-        delegate: serializer,
-    })
-}
-
-struct TaggedSerializer<S> {
-    type_ident: &'static str,
-    variant_ident: &'static str,
-    tag: &'static str,
-    variant_name: &'static str,
-    delegate: S,
-}
-
-enum Unsupported {
-    Boolean,
-    Integer,
-    Float,
-    Char,
-    String,
-    ByteArray,
-    Optional,
-    Unit,
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    UnitStruct,
-    Sequence,
-    Tuple,
-    TupleStruct,
-    Enum,
-}
-
-impl Display for Unsupported {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Unsupported::Boolean => formatter.write_str("a boolean"),
-            Unsupported::Integer => formatter.write_str("an integer"),
-            Unsupported::Float => formatter.write_str("a float"),
-            Unsupported::Char => formatter.write_str("a char"),
-            Unsupported::String => formatter.write_str("a string"),
-            Unsupported::ByteArray => formatter.write_str("a byte array"),
-            Unsupported::Optional => formatter.write_str("an optional"),
-            Unsupported::Unit => formatter.write_str("unit"),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Unsupported::UnitStruct => formatter.write_str("unit struct"),
-            Unsupported::Sequence => formatter.write_str("a sequence"),
-            Unsupported::Tuple => formatter.write_str("a tuple"),
-            Unsupported::TupleStruct => formatter.write_str("a tuple struct"),
-            Unsupported::Enum => formatter.write_str("an enum"),
-        }
-    }
-}
-
-impl<S> TaggedSerializer<S>
-where
-    S: Serializer,
-{
-    fn bad_type(self, what: Unsupported) -> S::Error {
-        ser::Error::custom(format_args!(
-            "cannot serialize tagged newtype variant {}::{} containing {}",
-            self.type_ident, self.variant_ident, what
-        ))
-    }
-}
-
-impl<S> Serializer for TaggedSerializer<S>
-where
-    S: Serializer,
-{
-    type Ok = S::Ok;
-    type Error = S::Error;
-
-    type SerializeSeq = Impossible<S::Ok, S::Error>;
-    type SerializeTuple = Impossible<S::Ok, S::Error>;
-    type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
-    type SerializeMap = S::SerializeMap;
-    type SerializeStruct = S::SerializeStruct;
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    type SerializeTupleVariant = SerializeTupleVariantAsMapValue<S::SerializeMap>;
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    type SerializeStructVariant = Impossible<S::Ok, S::Error>;
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    type SerializeStructVariant = SerializeStructVariantAsMapValue<S::SerializeMap>;
-
-    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Boolean))
-    }
-
-    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
-    }
-
-    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
-    }
-
-    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Char))
-    }
-
-    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::String))
-    }
-
-    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::ByteArray))
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Optional))
-    }
-
-    fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(self.bad_type(Unsupported::Optional))
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Unit))
-    }
-
-    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(Some(1)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        map.end()
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        inner_variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(Some(2)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        try!(map.serialize_entry(inner_variant, &()));
-        map.end()
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _: &'static str,
-        _: u32,
-        inner_variant: &'static str,
-        inner_value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        let mut map = try!(self.delegate.serialize_map(Some(2)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        try!(map.serialize_entry(inner_variant, inner_value));
-        map.end()
-    }
-
-    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(self.bad_type(Unsupported::Sequence))
-    }
-
-    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(self.bad_type(Unsupported::Tuple))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(self.bad_type(Unsupported::TupleStruct))
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn serialize_tuple_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        // Lack of push-based serialization means we need to buffer the content
-        // of the tuple variant, so it requires std.
-        Err(self.bad_type(Unsupported::Enum))
-    }
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn serialize_tuple_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        inner_variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(Some(2)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        try!(map.serialize_key(inner_variant));
-        Ok(SerializeTupleVariantAsMapValue::new(
-            map,
-            inner_variant,
-            len,
-        ))
-    }
-
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(len.map(|len| len + 1)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        Ok(map)
-    }
-
-    fn serialize_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        let mut state = try!(self.delegate.serialize_struct(name, len + 1));
-        try!(state.serialize_field(self.tag, self.variant_name));
-        Ok(state)
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn serialize_struct_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        // Lack of push-based serialization means we need to buffer the content
-        // of the struct variant, so it requires std.
-        Err(self.bad_type(Unsupported::Enum))
-    }
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn serialize_struct_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        inner_variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        let mut map = try!(self.delegate.serialize_map(Some(2)));
-        try!(map.serialize_entry(self.tag, self.variant_name));
-        try!(map.serialize_key(inner_variant));
-        Ok(SerializeStructVariantAsMapValue::new(
-            map,
-            inner_variant,
-            len,
-        ))
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Display,
-    {
-        Err(self.bad_type(Unsupported::String))
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-mod content {
-    use lib::*;
-
-    use ser::{self, Serialize, Serializer};
-
-    pub struct SerializeTupleVariantAsMapValue<M> {
-        map: M,
-        name: &'static str,
-        fields: Vec<Content>,
-    }
-
-    impl<M> SerializeTupleVariantAsMapValue<M> {
-        pub fn new(map: M, name: &'static str, len: usize) -> Self {
-            SerializeTupleVariantAsMapValue {
-                map: map,
-                name: name,
-                fields: Vec::with_capacity(len),
-            }
-        }
-    }
-
-    impl<M> ser::SerializeTupleVariant for SerializeTupleVariantAsMapValue<M>
-    where
-        M: ser::SerializeMap,
-    {
-        type Ok = M::Ok;
-        type Error = M::Error;
-
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
-            self.fields.push(value);
-            Ok(())
-        }
-
-        fn end(mut self) -> Result<M::Ok, M::Error> {
-            try!(self
-                .map
-                .serialize_value(&Content::TupleStruct(self.name, self.fields)));
-            self.map.end()
-        }
-    }
-
-    pub struct SerializeStructVariantAsMapValue<M> {
-        map: M,
-        name: &'static str,
-        fields: Vec<(&'static str, Content)>,
-    }
-
-    impl<M> SerializeStructVariantAsMapValue<M> {
-        pub fn new(map: M, name: &'static str, len: usize) -> Self {
-            SerializeStructVariantAsMapValue {
-                map: map,
-                name: name,
-                fields: Vec::with_capacity(len),
-            }
-        }
-    }
-
-    impl<M> ser::SerializeStructVariant for SerializeStructVariantAsMapValue<M>
-    where
-        M: ser::SerializeMap,
-    {
-        type Ok = M::Ok;
-        type Error = M::Error;
-
-        fn serialize_field<T: ?Sized>(
-            &mut self,
-            key: &'static str,
-            value: &T,
-        ) -> Result<(), M::Error>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
-            self.fields.push((key, value));
-            Ok(())
-        }
-
-        fn end(mut self) -> Result<M::Ok, M::Error> {
-            try!(self
-                .map
-                .serialize_value(&Content::Struct(self.name, self.fields)));
-            self.map.end()
-        }
-    }
-
-    pub enum Content {
-        Bool(bool),
-
-        U8(u8),
-        U16(u16),
-        U32(u32),
-        U64(u64),
-
-        I8(i8),
-        I16(i16),
-        I32(i32),
-        I64(i64),
-
-        F32(f32),
-        F64(f64),
-
-        Char(char),
-        String(String),
-        Bytes(Vec<u8>),
-
-        None,
-        Some(Box<Content>),
-
-        Unit,
-        UnitStruct(&'static str),
-        UnitVariant(&'static str, u32, &'static str),
-        NewtypeStruct(&'static str, Box<Content>),
-        NewtypeVariant(&'static str, u32, &'static str, Box<Content>),
-
-        Seq(Vec<Content>),
-        Tuple(Vec<Content>),
-        TupleStruct(&'static str, Vec<Content>),
-        TupleVariant(&'static str, u32, &'static str, Vec<Content>),
-        Map(Vec<(Content, Content)>),
-        Struct(&'static str, Vec<(&'static str, Content)>),
-        StructVariant(
-            &'static str,
-            u32,
-            &'static str,
-            Vec<(&'static str, Content)>,
-        ),
-    }
-
-    impl Serialize for Content {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            match *self {
-                Content::Bool(b) => serializer.serialize_bool(b),
-                Content::U8(u) => serializer.serialize_u8(u),
-                Content::U16(u) => serializer.serialize_u16(u),
-                Content::U32(u) => serializer.serialize_u32(u),
-                Content::U64(u) => serializer.serialize_u64(u),
-                Content::I8(i) => serializer.serialize_i8(i),
-                Content::I16(i) => serializer.serialize_i16(i),
-                Content::I32(i) => serializer.serialize_i32(i),
-                Content::I64(i) => serializer.serialize_i64(i),
-                Content::F32(f) => serializer.serialize_f32(f),
-                Content::F64(f) => serializer.serialize_f64(f),
-                Content::Char(c) => serializer.serialize_char(c),
-                Content::String(ref s) => serializer.serialize_str(s),
-                Content::Bytes(ref b) => serializer.serialize_bytes(b),
-                Content::None => serializer.serialize_none(),
-                Content::Some(ref c) => serializer.serialize_some(&**c),
-                Content::Unit => serializer.serialize_unit(),
-                Content::UnitStruct(n) => serializer.serialize_unit_struct(n),
-                Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v),
-                Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c),
-                Content::NewtypeVariant(n, i, v, ref c) => {
-                    serializer.serialize_newtype_variant(n, i, v, &**c)
-                }
-                Content::Seq(ref elements) => elements.serialize(serializer),
-                Content::Tuple(ref elements) => {
-                    use ser::SerializeTuple;
-                    let mut tuple = try!(serializer.serialize_tuple(elements.len()));
-                    for e in elements {
-                        try!(tuple.serialize_element(e));
-                    }
-                    tuple.end()
-                }
-                Content::TupleStruct(n, ref fields) => {
-                    use ser::SerializeTupleStruct;
-                    let mut ts = try!(serializer.serialize_tuple_struct(n, fields.len()));
-                    for f in fields {
-                        try!(ts.serialize_field(f));
-                    }
-                    ts.end()
-                }
-                Content::TupleVariant(n, i, v, ref fields) => {
-                    use ser::SerializeTupleVariant;
-                    let mut tv = try!(serializer.serialize_tuple_variant(n, i, v, fields.len()));
-                    for f in fields {
-                        try!(tv.serialize_field(f));
-                    }
-                    tv.end()
-                }
-                Content::Map(ref entries) => {
-                    use ser::SerializeMap;
-                    let mut map = try!(serializer.serialize_map(Some(entries.len())));
-                    for &(ref k, ref v) in entries {
-                        try!(map.serialize_entry(k, v));
-                    }
-                    map.end()
-                }
-                Content::Struct(n, ref fields) => {
-                    use ser::SerializeStruct;
-                    let mut s = try!(serializer.serialize_struct(n, fields.len()));
-                    for &(k, ref v) in fields {
-                        try!(s.serialize_field(k, v));
-                    }
-                    s.end()
-                }
-                Content::StructVariant(n, i, v, ref fields) => {
-                    use ser::SerializeStructVariant;
-                    let mut sv = try!(serializer.serialize_struct_variant(n, i, v, fields.len()));
-                    for &(k, ref v) in fields {
-                        try!(sv.serialize_field(k, v));
-                    }
-                    sv.end()
-                }
-            }
-        }
-    }
-
-    pub struct ContentSerializer<E> {
-        error: PhantomData<E>,
-    }
-
-    impl<E> ContentSerializer<E> {
-        pub fn new() -> Self {
-            ContentSerializer { error: PhantomData }
-        }
-    }
-
-    impl<E> Serializer for ContentSerializer<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        type SerializeSeq = SerializeSeq<E>;
-        type SerializeTuple = SerializeTuple<E>;
-        type SerializeTupleStruct = SerializeTupleStruct<E>;
-        type SerializeTupleVariant = SerializeTupleVariant<E>;
-        type SerializeMap = SerializeMap<E>;
-        type SerializeStruct = SerializeStruct<E>;
-        type SerializeStructVariant = SerializeStructVariant<E>;
-
-        fn serialize_bool(self, v: bool) -> Result<Content, E> {
-            Ok(Content::Bool(v))
-        }
-
-        fn serialize_i8(self, v: i8) -> Result<Content, E> {
-            Ok(Content::I8(v))
-        }
-
-        fn serialize_i16(self, v: i16) -> Result<Content, E> {
-            Ok(Content::I16(v))
-        }
-
-        fn serialize_i32(self, v: i32) -> Result<Content, E> {
-            Ok(Content::I32(v))
-        }
-
-        fn serialize_i64(self, v: i64) -> Result<Content, E> {
-            Ok(Content::I64(v))
-        }
-
-        fn serialize_u8(self, v: u8) -> Result<Content, E> {
-            Ok(Content::U8(v))
-        }
-
-        fn serialize_u16(self, v: u16) -> Result<Content, E> {
-            Ok(Content::U16(v))
-        }
-
-        fn serialize_u32(self, v: u32) -> Result<Content, E> {
-            Ok(Content::U32(v))
-        }
-
-        fn serialize_u64(self, v: u64) -> Result<Content, E> {
-            Ok(Content::U64(v))
-        }
-
-        fn serialize_f32(self, v: f32) -> Result<Content, E> {
-            Ok(Content::F32(v))
-        }
-
-        fn serialize_f64(self, v: f64) -> Result<Content, E> {
-            Ok(Content::F64(v))
-        }
-
-        fn serialize_char(self, v: char) -> Result<Content, E> {
-            Ok(Content::Char(v))
-        }
-
-        fn serialize_str(self, value: &str) -> Result<Content, E> {
-            Ok(Content::String(value.to_owned()))
-        }
-
-        fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> {
-            Ok(Content::Bytes(value.to_owned()))
-        }
-
-        fn serialize_none(self) -> Result<Content, E> {
-            Ok(Content::None)
-        }
-
-        fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
-        where
-            T: Serialize,
-        {
-            Ok(Content::Some(Box::new(try!(value.serialize(self)))))
-        }
-
-        fn serialize_unit(self) -> Result<Content, E> {
-            Ok(Content::Unit)
-        }
-
-        fn serialize_unit_struct(self, name: &'static str) -> Result<Content, E> {
-            Ok(Content::UnitStruct(name))
-        }
-
-        fn serialize_unit_variant(
-            self,
-            name: &'static str,
-            variant_index: u32,
-            variant: &'static str,
-        ) -> Result<Content, E> {
-            Ok(Content::UnitVariant(name, variant_index, variant))
-        }
-
-        fn serialize_newtype_struct<T: ?Sized>(
-            self,
-            name: &'static str,
-            value: &T,
-        ) -> Result<Content, E>
-        where
-            T: Serialize,
-        {
-            Ok(Content::NewtypeStruct(
-                name,
-                Box::new(try!(value.serialize(self))),
-            ))
-        }
-
-        fn serialize_newtype_variant<T: ?Sized>(
-            self,
-            name: &'static str,
-            variant_index: u32,
-            variant: &'static str,
-            value: &T,
-        ) -> Result<Content, E>
-        where
-            T: Serialize,
-        {
-            Ok(Content::NewtypeVariant(
-                name,
-                variant_index,
-                variant,
-                Box::new(try!(value.serialize(self))),
-            ))
-        }
-
-        fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
-            Ok(SerializeSeq {
-                elements: Vec::with_capacity(len.unwrap_or(0)),
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
-            Ok(SerializeTuple {
-                elements: Vec::with_capacity(len),
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_tuple_struct(
-            self,
-            name: &'static str,
-            len: usize,
-        ) -> Result<Self::SerializeTupleStruct, E> {
-            Ok(SerializeTupleStruct {
-                name: name,
-                fields: Vec::with_capacity(len),
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_tuple_variant(
-            self,
-            name: &'static str,
-            variant_index: u32,
-            variant: &'static str,
-            len: usize,
-        ) -> Result<Self::SerializeTupleVariant, E> {
-            Ok(SerializeTupleVariant {
-                name: name,
-                variant_index: variant_index,
-                variant: variant,
-                fields: Vec::with_capacity(len),
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
-            Ok(SerializeMap {
-                entries: Vec::with_capacity(len.unwrap_or(0)),
-                key: None,
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_struct(
-            self,
-            name: &'static str,
-            len: usize,
-        ) -> Result<Self::SerializeStruct, E> {
-            Ok(SerializeStruct {
-                name: name,
-                fields: Vec::with_capacity(len),
-                error: PhantomData,
-            })
-        }
-
-        fn serialize_struct_variant(
-            self,
-            name: &'static str,
-            variant_index: u32,
-            variant: &'static str,
-            len: usize,
-        ) -> Result<Self::SerializeStructVariant, E> {
-            Ok(SerializeStructVariant {
-                name: name,
-                variant_index: variant_index,
-                variant: variant,
-                fields: Vec::with_capacity(len),
-                error: PhantomData,
-            })
-        }
-    }
-
-    pub struct SerializeSeq<E> {
-        elements: Vec<Content>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeSeq for SerializeSeq<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.elements.push(value);
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::Seq(self.elements))
-        }
-    }
-
-    pub struct SerializeTuple<E> {
-        elements: Vec<Content>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeTuple for SerializeTuple<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.elements.push(value);
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::Tuple(self.elements))
-        }
-    }
-
-    pub struct SerializeTupleStruct<E> {
-        name: &'static str,
-        fields: Vec<Content>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.fields.push(value);
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::TupleStruct(self.name, self.fields))
-        }
-    }
-
-    pub struct SerializeTupleVariant<E> {
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        fields: Vec<Content>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.fields.push(value);
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::TupleVariant(
-                self.name,
-                self.variant_index,
-                self.variant,
-                self.fields,
-            ))
-        }
-    }
-
-    pub struct SerializeMap<E> {
-        entries: Vec<(Content, Content)>,
-        key: Option<Content>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeMap for SerializeMap<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let key = try!(key.serialize(ContentSerializer::<E>::new()));
-            self.key = Some(key);
-            Ok(())
-        }
-
-        fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let key = self
-                .key
-                .take()
-                .expect("serialize_value called before serialize_key");
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.entries.push((key, value));
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::Map(self.entries))
-        }
-
-        fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
-        where
-            K: Serialize,
-            V: Serialize,
-        {
-            let key = try!(key.serialize(ContentSerializer::<E>::new()));
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.entries.push((key, value));
-            Ok(())
-        }
-    }
-
-    pub struct SerializeStruct<E> {
-        name: &'static str,
-        fields: Vec<(&'static str, Content)>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeStruct for SerializeStruct<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.fields.push((key, value));
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::Struct(self.name, self.fields))
-        }
-    }
-
-    pub struct SerializeStructVariant<E> {
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        fields: Vec<(&'static str, Content)>,
-        error: PhantomData<E>,
-    }
-
-    impl<E> ser::SerializeStructVariant for SerializeStructVariant<E>
-    where
-        E: ser::Error,
-    {
-        type Ok = Content;
-        type Error = E;
-
-        fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
-        where
-            T: Serialize,
-        {
-            let value = try!(value.serialize(ContentSerializer::<E>::new()));
-            self.fields.push((key, value));
-            Ok(())
-        }
-
-        fn end(self) -> Result<Content, E> {
-            Ok(Content::StructVariant(
-                self.name,
-                self.variant_index,
-                self.variant,
-                self.fields,
-            ))
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapSerializer<'a, M: 'a>(pub &'a mut M);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> FlatMapSerializer<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    fn bad_type(what: Unsupported) -> M::Error {
-        ser::Error::custom(format_args!(
-            "can only flatten structs and maps (got {})",
-            what
-        ))
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> Serializer for FlatMapSerializer<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    type Ok = ();
-    type Error = M::Error;
-
-    type SerializeSeq = Impossible<Self::Ok, M::Error>;
-    type SerializeTuple = Impossible<Self::Ok, M::Error>;
-    type SerializeTupleStruct = Impossible<Self::Ok, M::Error>;
-    type SerializeMap = FlatMapSerializeMap<'a, M>;
-    type SerializeStruct = FlatMapSerializeStruct<'a, M>;
-    type SerializeTupleVariant = Impossible<Self::Ok, M::Error>;
-    type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
-
-    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Boolean))
-    }
-
-    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Integer))
-    }
-
-    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Float))
-    }
-
-    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Float))
-    }
-
-    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Char))
-    }
-
-    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::String))
-    }
-
-    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::ByteArray))
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-
-    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::UnitStruct))
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Enum))
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _: &'static str,
-        _: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        try!(self.0.serialize_key(variant));
-        self.0.serialize_value(value)
-    }
-
-    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(Self::bad_type(Unsupported::Sequence))
-    }
-
-    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(Self::bad_type(Unsupported::Tuple))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(Self::bad_type(Unsupported::TupleStruct))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(Self::bad_type(Unsupported::Enum))
-    }
-
-    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Ok(FlatMapSerializeMap(self.0))
-    }
-
-    fn serialize_struct(
-        self,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Ok(FlatMapSerializeStruct(self.0))
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        inner_variant: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        try!(self.0.serialize_key(inner_variant));
-        Ok(FlatMapSerializeStructVariantAsMapValue::new(
-            self.0,
-            inner_variant,
-        ))
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapSerializeMap<'a, M: 'a>(&'a mut M);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> ser::SerializeMap for FlatMapSerializeMap<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    type Ok = ();
-    type Error = M::Error;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        self.0.serialize_key(key)
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        self.0.serialize_value(value)
-    }
-
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-    {
-        self.0.serialize_entry(key, value)
-    }
-
-    fn end(self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapSerializeStruct<'a, M: 'a>(&'a mut M);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> ser::SerializeStruct for FlatMapSerializeStruct<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    type Ok = ();
-    type Error = M::Error;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        self.0.serialize_entry(key, value)
-    }
-
-    fn end(self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
-    map: &'a mut M,
-    name: &'static str,
-    fields: Vec<(&'static str, Content)>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> FlatMapSerializeStructVariantAsMapValue<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVariantAsMapValue<'a, M> {
-        FlatMapSerializeStructVariantAsMapValue {
-            map: map,
-            name: name,
-            fields: Vec::new(),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, M> ser::SerializeStructVariant for FlatMapSerializeStructVariantAsMapValue<'a, M>
-where
-    M: SerializeMap + 'a,
-{
-    type Ok = ();
-    type Error = M::Error;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
-        self.fields.push((key, value));
-        Ok(())
-    }
-
-    fn end(self) -> Result<(), Self::Error> {
-        try!(self
-            .map
-            .serialize_value(&Content::Struct(self.name, self.fields)));
-        Ok(())
-    }
-}
diff --git a/vendor/serde/src/private/size_hint.rs b/vendor/serde/src/private/size_hint.rs
deleted file mode 100644
index ca71e616..00000000
--- a/vendor/serde/src/private/size_hint.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use lib::*;
-
-pub fn from_bounds<I>(iter: &I) -> Option<usize>
-where
-    I: Iterator,
-{
-    helper(iter.size_hint())
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[inline]
-pub fn cautious(hint: Option<usize>) -> usize {
-    cmp::min(hint.unwrap_or(0), 4096)
-}
-
-fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
-    match bounds {
-        (lower, Some(upper)) if lower == upper => Some(upper),
-        _ => None,
-    }
-}
diff --git a/vendor/serde/src/ser/fmt.rs b/vendor/serde/src/ser/fmt.rs
deleted file mode 100644
index e7e09a1b..00000000
--- a/vendor/serde/src/ser/fmt.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-use lib::*;
-use ser::{Error, Impossible, Serialize, Serializer};
-
-impl Error for fmt::Error {
-    fn custom<T: Display>(_msg: T) -> Self {
-        fmt::Error
-    }
-}
-
-macro_rules! fmt_primitives {
-    ($($f:ident: $t:ty,)*) => {
-        $(
-            fn $f(self, v: $t) -> fmt::Result {
-                Display::fmt(&v, self)
-            }
-        )*
-    };
-}
-
-/// ```edition2018
-/// use serde::Serialize;
-/// use std::fmt::{self, Display};
-///
-/// #[derive(Serialize)]
-/// #[serde(rename_all = "kebab-case")]
-/// pub enum MessageType {
-///     StartRequest,
-///     EndRequest,
-/// }
-///
-/// impl Display for MessageType {
-///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-///         self.serialize(f)
-///     }
-/// }
-/// ```
-impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
-    type Ok = ();
-    type Error = fmt::Error;
-    type SerializeSeq = Impossible<(), fmt::Error>;
-    type SerializeTuple = Impossible<(), fmt::Error>;
-    type SerializeTupleStruct = Impossible<(), fmt::Error>;
-    type SerializeTupleVariant = Impossible<(), fmt::Error>;
-    type SerializeMap = Impossible<(), fmt::Error>;
-    type SerializeStruct = Impossible<(), fmt::Error>;
-    type SerializeStructVariant = Impossible<(), fmt::Error>;
-
-    fmt_primitives! {
-        serialize_bool: bool,
-        serialize_i8: i8,
-        serialize_i16: i16,
-        serialize_i32: i32,
-        serialize_i64: i64,
-        serialize_u8: u8,
-        serialize_u16: u16,
-        serialize_u32: u32,
-        serialize_u64: u64,
-        serialize_f32: f32,
-        serialize_f64: f64,
-        serialize_char: char,
-        serialize_str: &str,
-        serialize_unit_struct: &'static str,
-    }
-
-    serde_if_integer128! {
-        fmt_primitives! {
-            serialize_i128: i128,
-            serialize_u128: u128,
-        }
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> fmt::Result {
-        Display::fmt(variant, self)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Serialize::serialize(value, self)
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_none(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_unit(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
-    where
-        T: Display,
-    {
-        Display::fmt(value, self)
-    }
-}
diff --git a/vendor/serde/src/ser/impls.rs b/vendor/serde/src/ser/impls.rs
deleted file mode 100644
index c254ac65..00000000
--- a/vendor/serde/src/ser/impls.rs
+++ /dev/null
@@ -1,935 +0,0 @@
-use lib::*;
-
-use ser::{Error, Serialize, SerializeTuple, Serializer};
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! primitive_impl {
-    ($ty:ident, $method:ident $($cast:tt)*) => {
-        impl Serialize for $ty {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.$method(*self $($cast)*)
-            }
-        }
-    }
-}
-
-primitive_impl!(bool, serialize_bool);
-primitive_impl!(isize, serialize_i64 as i64);
-primitive_impl!(i8, serialize_i8);
-primitive_impl!(i16, serialize_i16);
-primitive_impl!(i32, serialize_i32);
-primitive_impl!(i64, serialize_i64);
-primitive_impl!(usize, serialize_u64 as u64);
-primitive_impl!(u8, serialize_u8);
-primitive_impl!(u16, serialize_u16);
-primitive_impl!(u32, serialize_u32);
-primitive_impl!(u64, serialize_u64);
-primitive_impl!(f32, serialize_f32);
-primitive_impl!(f64, serialize_f64);
-primitive_impl!(char, serialize_char);
-
-serde_if_integer128! {
-    primitive_impl!(i128, serialize_i128);
-    primitive_impl!(u128, serialize_u128);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for str {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl Serialize for String {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self)
-    }
-}
-
-impl<'a> Serialize for fmt::Arguments<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.collect_str(self)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-impl Serialize for CStr {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(self.to_bytes())
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for CString {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(self.to_bytes())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Option<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Some(ref value) => serializer.serialize_some(value),
-            None => serializer.serialize_none(),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T: ?Sized> Serialize for PhantomData<T> {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_unit_struct("PhantomData")
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Does not require T: Serialize.
-impl<T> Serialize for [T; 0] {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        try!(serializer.serialize_tuple(0)).end()
-    }
-}
-
-macro_rules! array_impls {
-    ($($len:tt)+) => {
-        $(
-            impl<T> Serialize for [T; $len]
-            where
-                T: Serialize,
-            {
-                #[inline]
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    let mut seq = try!(serializer.serialize_tuple($len));
-                    for e in self {
-                        try!(seq.serialize_element(e));
-                    }
-                    seq.end()
-                }
-            }
-        )+
-    }
-}
-
-array_impls! {
-    01 02 03 04 05 06 07 08 09 10
-    11 12 13 14 15 16 17 18 19 20
-    21 22 23 24 25 26 27 28 29 30
-    31 32
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for [T]
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.collect_seq(self)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-macro_rules! seq_impl {
-    ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => {
-        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
-        where
-            T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
-            $($typaram: $bound,)*
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_seq(self)
-            }
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BinaryHeap<T: Ord>);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BTreeSet<T: Ord>);
-
-#[cfg(feature = "std")]
-seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(LinkedList<T>);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(Vec<T>);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(VecDeque<T>);
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<Idx> Serialize for Range<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = try!(serializer.serialize_struct("Range", 2));
-        try!(state.serialize_field("start", &self.start));
-        try!(state.serialize_field("end", &self.end));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(range_inclusive)]
-impl<Idx> Serialize for RangeInclusive<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = try!(serializer.serialize_struct("RangeInclusive", 2));
-        try!(state.serialize_field("start", &self.start()));
-        try!(state.serialize_field("end", &self.end()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(ops_bound, collections_bound))]
-impl<T> Serialize for Bound<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Bound::Unbounded => serializer.serialize_unit_variant("Bound", 0, "Unbounded"),
-            Bound::Included(ref value) => {
-                serializer.serialize_newtype_variant("Bound", 1, "Included", value)
-            }
-            Bound::Excluded(ref value) => {
-                serializer.serialize_newtype_variant("Bound", 2, "Excluded", value)
-            }
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for () {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_unit()
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl Serialize for ! {
-    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        *self
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! tuple_impls {
-    ($($len:expr => ($($n:tt $name:ident)+))+) => {
-        $(
-            impl<$($name),+> Serialize for ($($name,)+)
-            where
-                $($name: Serialize,)+
-            {
-                #[inline]
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    let mut tuple = try!(serializer.serialize_tuple($len));
-                    $(
-                        try!(tuple.serialize_element(&self.$n));
-                    )+
-                    tuple.end()
-                }
-            }
-        )+
-    }
-}
-
-tuple_impls! {
-    1 => (0 T0)
-    2 => (0 T0 1 T1)
-    3 => (0 T0 1 T1 2 T2)
-    4 => (0 T0 1 T1 2 T2 3 T3)
-    5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
-    6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
-    7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
-    8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
-    9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
-    10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
-    11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
-    12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
-    13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
-    14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
-    15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
-    16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-macro_rules! map_impl {
-    ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
-        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
-        where
-            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
-            V: Serialize,
-            $($typaram: $bound,)*
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_map(self)
-            }
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-map_impl!(BTreeMap<K: Ord, V>);
-
-#[cfg(feature = "std")]
-map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! deref_impl {
-    (
-        $(#[doc = $doc:tt])*
-        <$($desc:tt)+
-    ) => {
-        $(#[doc = $doc])*
-        impl <$($desc)+ {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                (**self).serialize(serializer)
-            }
-        }
-    };
-}
-
-deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize);
-deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
-
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Serializing a data structure containing `Rc` will serialize a copy of
-    /// the contents of the `Rc` each time the `Rc` is referenced within the
-    /// data structure. Serialization will not attempt to deduplicate these
-    /// repeated data.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Rc<T> where T: Serialize
-}
-
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Serializing a data structure containing `Arc` will serialize a copy of
-    /// the contents of the `Arc` each time the `Arc` is referenced within the
-    /// data structure. Serialization will not attempt to deduplicate these
-    /// repeated data.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Arc<T> where T: Serialize
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for RcWeak<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.upgrade().serialize(serializer)
-    }
-}
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for ArcWeak<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.upgrade().serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! nonzero_integers {
-    ( $( $T: ident, )+ ) => {
-        $(
-            #[cfg(num_nonzero)]
-            impl Serialize for num::$T {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    self.get().serialize(serializer)
-                }
-            }
-        )+
-    }
-}
-
-nonzero_integers! {
-    NonZeroU8,
-    NonZeroU16,
-    NonZeroU32,
-    NonZeroU64,
-    NonZeroUsize,
-}
-
-#[cfg(num_nonzero_signed)]
-nonzero_integers! {
-    NonZeroI8,
-    NonZeroI16,
-    NonZeroI32,
-    NonZeroI64,
-    NonZeroIsize,
-}
-
-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(num_nonzero_signed)]
-    nonzero_integers! {
-        NonZeroI128,
-    }
-}
-
-impl<T> Serialize for Cell<T>
-where
-    T: Serialize + Copy,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.get().serialize(serializer)
-    }
-}
-
-impl<T> Serialize for RefCell<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.try_borrow() {
-            Ok(value) => value.serialize(serializer),
-            Err(_) => Err(S::Error::custom("already mutably borrowed")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T> Serialize for Mutex<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.lock() {
-            Ok(locked) => locked.serialize(serializer),
-            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T> Serialize for RwLock<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.read() {
-            Ok(locked) => locked.serialize(serializer),
-            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T, E> Serialize for Result<T, E>
-where
-    T: Serialize,
-    E: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
-            Result::Err(ref value) => {
-                serializer.serialize_newtype_variant("Result", 1, "Err", value)
-            }
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(core_duration, feature = "std"))]
-impl Serialize for Duration {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = try!(serializer.serialize_struct("Duration", 2));
-        try!(state.serialize_field("secs", &self.as_secs()));
-        try!(state.serialize_field("nanos", &self.subsec_nanos()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-impl Serialize for SystemTime {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let duration_since_epoch = self
-            .duration_since(UNIX_EPOCH)
-            .map_err(|_| S::Error::custom("SystemTime must be later than UNIX_EPOCH"))?;
-        let mut state = try!(serializer.serialize_struct("SystemTime", 2));
-        try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
-        try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Serialize a value that implements `Display` as a string, when that string is
-/// statically known to never have more than a constant `MAX_LEN` bytes.
-///
-/// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
-#[cfg(feature = "std")]
-macro_rules! serialize_display_bounded_length {
-    ($value:expr, $max:expr, $serializer:expr) => {{
-        let mut buffer = [0u8; $max];
-        let remaining_len = {
-            let mut remaining = &mut buffer[..];
-            write!(remaining, "{}", $value).unwrap();
-            remaining.len()
-        };
-        let written_len = buffer.len() - remaining_len;
-        let written = &buffer[..written_len];
-
-        // write! only provides fmt::Formatter to Display implementations, which
-        // has methods write_str and write_char but no method to write arbitrary
-        // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = str::from_utf8(written).expect("must be valid UTF-8");
-        $serializer.serialize_str(written_str)
-    }};
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::IpAddr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            match *self {
-                net::IpAddr::V4(ref a) => a.serialize(serializer),
-                net::IpAddr::V6(ref a) => a.serialize(serializer),
-            }
-        } else {
-            match *self {
-                net::IpAddr::V4(ref a) => {
-                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
-                }
-                net::IpAddr::V6(ref a) => {
-                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-const DEC_DIGITS_LUT: &'static [u8] = b"\
-      0001020304050607080910111213141516171819\
-      2021222324252627282930313233343536373839\
-      4041424344454647484950515253545556575859\
-      6061626364656667686970717273747576777879\
-      8081828384858687888990919293949596979899";
-
-#[cfg(feature = "std")]
-#[inline]
-fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
-    if n >= 100 {
-        let d1 = ((n % 100) << 1) as usize;
-        n /= 100;
-        out[0] = b'0' + n;
-        out[1] = DEC_DIGITS_LUT[d1];
-        out[2] = DEC_DIGITS_LUT[d1 + 1];
-        3
-    } else if n >= 10 {
-        let d1 = (n << 1) as usize;
-        out[0] = DEC_DIGITS_LUT[d1];
-        out[1] = DEC_DIGITS_LUT[d1 + 1];
-        2
-    } else {
-        out[0] = b'0' + n;
-        1
-    }
-}
-
-#[cfg(feature = "std")]
-#[test]
-fn test_format_u8() {
-    let mut i = 0u8;
-
-    loop {
-        let mut buf = [0u8; 3];
-        let written = format_u8(i, &mut buf);
-        assert_eq!(i.to_string().as_bytes(), &buf[..written]);
-
-        match i.checked_add(1) {
-            Some(next) => i = next,
-            None => break,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::Ipv4Addr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 15;
-            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
-            let mut buf = [b'.'; MAX_LEN];
-            let mut written = format_u8(self.octets()[0], &mut buf);
-            for oct in &self.octets()[1..] {
-                // Skip over delimiters that we initialized buf with
-                written += format_u8(*oct, &mut buf[written + 1..]) + 1;
-            }
-            // We've only written ASCII bytes to the buffer, so it is valid UTF-8
-            serializer.serialize_str(unsafe { str::from_utf8_unchecked(&buf[..written]) })
-        } else {
-            self.octets().serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::Ipv6Addr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 39;
-            debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            self.octets().serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::SocketAddr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            match *self {
-                net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
-                net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
-            }
-        } else {
-            match *self {
-                net::SocketAddr::V4(ref addr) => {
-                    serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
-                }
-                net::SocketAddr::V6(ref addr) => {
-                    serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::SocketAddrV4 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 21;
-            debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            (self.ip(), self.port()).serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for net::SocketAddrV6 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 58;
-            debug_assert_eq!(
-                MAX_LEN,
-                "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len()
-            );
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            (self.ip(), self.port()).serialize(serializer)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-impl Serialize for Path {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.to_str() {
-            Some(s) => s.serialize(serializer),
-            None => Err(Error::custom("path contains invalid UTF-8 characters")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Serialize for PathBuf {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_path().serialize(serializer)
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-impl Serialize for OsStr {
-    #[cfg(unix)]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use std::os::unix::ffi::OsStrExt;
-        serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
-    }
-
-    #[cfg(windows)]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use std::os::windows::ffi::OsStrExt;
-        let val = self.encode_wide().collect::<Vec<_>>();
-        serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-impl Serialize for OsString {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_os_str().serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Wrapping<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(core_reverse)]
-impl<T> Serialize for Reverse<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.0.serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(all(feature = "std", std_atomic))]
-macro_rules! atomic_impl {
-    ($($ty:ident)*) => {
-        $(
-            impl Serialize for $ty {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    self.load(Ordering::SeqCst).serialize(serializer)
-                }
-            }
-        )*
-    }
-}
-
-#[cfg(all(feature = "std", std_atomic))]
-atomic_impl! {
-    AtomicBool
-    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
-    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
-}
-
-#[cfg(all(feature = "std", std_atomic64))]
-atomic_impl! {
-    AtomicI64 AtomicU64
-}
diff --git a/vendor/serde/src/ser/impossible.rs b/vendor/serde/src/ser/impossible.rs
deleted file mode 100644
index e8df9ca7..00000000
--- a/vendor/serde/src/ser/impossible.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-//! This module contains `Impossible` serializer and its implementations.
-
-use lib::*;
-
-use ser::{
-    self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
-    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
-};
-
-/// Helper type for implementing a `Serializer` that does not support
-/// serializing one of the compound types.
-///
-/// This type cannot be instantiated, but implements every one of the traits
-/// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],
-/// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
-/// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
-///
-/// ```edition2018
-/// # use serde::ser::{Serializer, Impossible};
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     type SerializeSeq = Impossible<(), Error>;
-///     /* other associated types */
-///
-///     /// This data format does not support serializing sequences.
-///     fn serialize_seq(self,
-///                      len: Option<usize>)
-///                      -> Result<Self::SerializeSeq, Error> {
-///         // Given Impossible cannot be instantiated, the only
-///         // thing we can do here is to return an error.
-/// #         stringify! {
-///         Err(...)
-/// #         };
-/// #         unimplemented!()
-///     }
-///
-///     /* other Serializer methods */
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// [`Serializer`]: trait.Serializer.html
-/// [`SerializeSeq`]: trait.SerializeSeq.html
-/// [`SerializeTuple`]: trait.SerializeTuple.html
-/// [`SerializeTupleStruct`]: trait.SerializeTupleStruct.html
-/// [`SerializeTupleVariant`]: trait.SerializeTupleVariant.html
-/// [`SerializeMap`]: trait.SerializeMap.html
-/// [`SerializeStruct`]: trait.SerializeStruct.html
-/// [`SerializeStructVariant`]: trait.SerializeStructVariant.html
-pub struct Impossible<Ok, Error> {
-    void: Void,
-    ok: PhantomData<Ok>,
-    error: PhantomData<Error>,
-}
-
-enum Void {}
-
-impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        match self.void {}
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
diff --git a/vendor/serde/src/ser/mod.rs b/vendor/serde/src/ser/mod.rs
deleted file mode 100644
index d5bca09f..00000000
--- a/vendor/serde/src/ser/mod.rs
+++ /dev/null
@@ -1,1986 +0,0 @@
-//! Generic data structure serialization framework.
-//!
-//! The two most important traits in this module are [`Serialize`] and
-//! [`Serializer`].
-//!
-//!  - **A type that implements `Serialize` is a data structure** that can be
-//!    serialized to any data format supported by Serde, and conversely
-//!  - **A type that implements `Serializer` is a data format** that can
-//!    serialize any data structure supported by Serde.
-//!
-//! # The Serialize trait
-//!
-//! Serde provides [`Serialize`] implementations for many Rust primitive and
-//! standard library types. The complete list is below. All of these can be
-//! serialized using Serde out of the box.
-//!
-//! Additionally, Serde provides a procedural macro called [`serde_derive`] to
-//! automatically generate [`Serialize`] implementations for structs and enums
-//! in your program. See the [derive section of the manual] for how to use this.
-//!
-//! In rare cases it may be necessary to implement [`Serialize`] manually for
-//! some type in your program. See the [Implementing `Serialize`] section of the
-//! manual for more about this.
-//!
-//! Third-party crates may provide [`Serialize`] implementations for types that
-//! they expose. For example the [`linked-hash-map`] crate provides a
-//! [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
-//! provides an implementation of [`Serialize`] for it.
-//!
-//! # The Serializer trait
-//!
-//! [`Serializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`bincode`].
-//!
-//! A partial list of well-maintained formats is given on the [Serde
-//! website][data formats].
-//!
-//! # Implementations of Serialize provided by Serde
-//!
-//!  - **Primitive types**:
-//!    - bool
-//!    - i8, i16, i32, i64, i128, isize
-//!    - u8, u16, u32, u64, u128, usize
-//!    - f32, f64
-//!    - char
-//!    - str
-//!    - &T and &mut T
-//!  - **Compound types**:
-//!    - \[T\]
-//!    - \[T; 0\] through \[T; 32\]
-//!    - tuples up to size 16
-//!  - **Common standard library types**:
-//!    - String
-//!    - Option\<T\>
-//!    - Result\<T, E\>
-//!    - PhantomData\<T\>
-//!  - **Wrapper types**:
-//!    - Box\<T\>
-//!    - Cow\<'a, T\>
-//!    - Cell\<T\>
-//!    - RefCell\<T\>
-//!    - Mutex\<T\>
-//!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!  - **Collection types**:
-//!    - BTreeMap\<K, V\>
-//!    - BTreeSet\<T\>
-//!    - BinaryHeap\<T\>
-//!    - HashMap\<K, V, H\>
-//!    - HashSet\<T, H\>
-//!    - LinkedList\<T\>
-//!    - VecDeque\<T\>
-//!    - Vec\<T\>
-//!  - **FFI types**:
-//!    - CStr
-//!    - CString
-//!    - OsStr
-//!    - OsString
-//!  - **Miscellaneous standard library types**:
-//!    - Duration
-//!    - SystemTime
-//!    - Path
-//!    - PathBuf
-//!    - Range\<T\>
-//!    - RangeInclusive\<T\>
-//!    - Bound\<T\>
-//!    - num::NonZero*
-//!    - `!` *(unstable)*
-//!  - **Net types**:
-//!    - IpAddr
-//!    - Ipv4Addr
-//!    - Ipv6Addr
-//!    - SocketAddr
-//!    - SocketAddrV4
-//!    - SocketAddrV6
-//!
-//! [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
-//! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`Serialize`]: ../trait.Serialize.html
-//! [`Serializer`]: ../trait.Serializer.html
-//! [`bincode`]: https://github.com/servo/bincode
-//! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
-//! [`serde_derive`]: https://crates.io/crates/serde_derive
-//! [`serde_json`]: https://github.com/serde-rs/json
-//! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
-//! [derive section of the manual]: https://serde.rs/derive.html
-//! [data formats]: https://serde.rs/#data-formats
-
-use lib::*;
-
-mod fmt;
-mod impls;
-mod impossible;
-
-pub use self::impossible::Impossible;
-
-#[cfg(feature = "std")]
-#[doc(no_inline)]
-pub use std::error::Error as StdError;
-#[cfg(not(feature = "std"))]
-#[doc(no_inline)]
-pub use std_error::Error as StdError;
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! declare_error_trait {
-    (Error: Sized $(+ $($supertrait:ident)::+)*) => {
-        /// Trait used by `Serialize` implementations to generically construct
-        /// errors belonging to the `Serializer` against which they are
-        /// currently running.
-        ///
-        /// # Example implementation
-        ///
-        /// The [example data format] presented on the website shows an error
-        /// type appropriate for a basic JSON data format.
-        ///
-        /// [example data format]: https://serde.rs/data-format.html
-        pub trait Error: Sized $(+ $($supertrait)::+)* {
-            /// Used when a [`Serialize`] implementation encounters any error
-            /// while serializing a type.
-            ///
-            /// The message should not be capitalized and should not end with a
-            /// period.
-            ///
-            /// For example, a filesystem [`Path`] may refuse to serialize
-            /// itself if it contains invalid UTF-8 data.
-            ///
-            /// ```edition2018
-            /// # struct Path;
-            /// #
-            /// # impl Path {
-            /// #     fn to_str(&self) -> Option<&str> {
-            /// #         unimplemented!()
-            /// #     }
-            /// # }
-            /// #
-            /// use serde::ser::{self, Serialize, Serializer};
-            ///
-            /// impl Serialize for Path {
-            ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            ///     where
-            ///         S: Serializer,
-            ///     {
-            ///         match self.to_str() {
-            ///             Some(s) => serializer.serialize_str(s),
-            ///             None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
-            ///         }
-            ///     }
-            /// }
-            /// ```
-            ///
-            /// [`Path`]: https://doc.rust-lang.org/std/path/struct.Path.html
-            /// [`Serialize`]: ../trait.Serialize.html
-            fn custom<T>(msg: T) -> Self
-            where
-                T: Display;
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + StdError);
-
-#[cfg(not(feature = "std"))]
-declare_error_trait!(Error: Sized + Debug + Display);
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data structure** that can be serialized into any data format supported
-/// by Serde.
-///
-/// Serde provides `Serialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][ser]. All of these can
-/// be serialized using Serde out of the box.
-///
-/// Additionally, Serde provides a procedural macro called [`serde_derive`] to
-/// automatically generate `Serialize` implementations for structs and enums in
-/// your program. See the [derive section of the manual] for how to use this.
-///
-/// In rare cases it may be necessary to implement `Serialize` manually for some
-/// type in your program. See the [Implementing `Serialize`] section of the
-/// manual for more about this.
-///
-/// Third-party crates may provide `Serialize` implementations for types that
-/// they expose. For example the [`linked-hash-map`] crate provides a
-/// [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
-/// provides an implementation of `Serialize` for it.
-///
-/// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
-/// [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-/// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
-/// [`serde_derive`]: https://crates.io/crates/serde_derive
-/// [derive section of the manual]: https://serde.rs/derive.html
-/// [ser]: https://docs.serde.rs/serde/ser/index.html
-pub trait Serialize {
-    /// Serialize this value into the given Serde serializer.
-    ///
-    /// See the [Implementing `Serialize`] section of the manual for more
-    /// information about how to implement this method.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
-    ///
-    /// struct Person {
-    ///     name: String,
-    ///     age: u8,
-    ///     phones: Vec<String>,
-    /// }
-    ///
-    /// // This is what #[derive(Serialize)] would generate.
-    /// impl Serialize for Person {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut s = serializer.serialize_struct("Person", 3)?;
-    ///         s.serialize_field("name", &self.name)?;
-    ///         s.serialize_field("age", &self.age)?;
-    ///         s.serialize_field("phones", &self.phones)?;
-    ///         s.end()
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data format** that can serialize any data structure supported by Serde.
-///
-/// The role of this trait is to define the serialization half of the [Serde
-/// data model], which is a way to categorize every Rust data structure into one
-/// of 29 possible types. Each method of the `Serializer` trait corresponds to
-/// one of the types of the data model.
-///
-/// Implementations of `Serialize` map themselves into this data model by
-/// invoking exactly one of the `Serializer` methods.
-///
-/// The types that make up the Serde data model are:
-///
-///  - **14 primitive types**
-///    - bool
-///    - i8, i16, i32, i64, i128
-///    - u8, u16, u32, u64, u128
-///    - f32, f64
-///    - char
-///  - **string**
-///    - UTF-8 bytes with a length and no null terminator.
-///    - When serializing, all strings are handled equally. When deserializing,
-///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - \[u8\]
-///    - Similar to strings, during deserialization byte arrays can be
-///      transient, owned, or borrowed.
-///  - **option**
-///    - Either none or some value.
-///  - **unit**
-///    - The type of `()` in Rust. It represents an anonymous value containing
-///      no data.
-///  - **unit_struct**
-///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
-///      value containing no data.
-///  - **unit_variant**
-///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
-///  - **newtype_struct**
-///    - For example `struct Millimeters(u8)`.
-///  - **newtype_variant**
-///    - For example the `E::N` in `enum E { N(u8) }`.
-///  - **seq**
-///    - A variably sized heterogeneous sequence of values, for example
-///      `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not
-///      be known before iterating through all the data. When deserializing,
-///      the length is determined by looking at the serialized data.
-///  - **tuple**
-///    - A statically sized heterogeneous sequence of values for which the
-///      length will be known at deserialization time without looking at the
-///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
-///      `[u64; 10]`.
-///  - **tuple_struct**
-///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
-///  - **tuple_variant**
-///    - For example the `E::T` in `enum E { T(u8, u8) }`.
-///  - **map**
-///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
-///  - **struct**
-///    - A heterogeneous key-value pairing in which the keys are strings and
-///      will be known at deserialization time without looking at the
-///      serialized data, for example `struct S { r: u8, g: u8, b: u8 }`.
-///  - **struct_variant**
-///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
-///
-/// Many Serde serializers produce text or binary data as output, for example
-/// JSON or Bincode. This is not a requirement of the `Serializer` trait, and
-/// there are serializers that do not produce text or binary output. One example
-/// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
-/// serializer) that produces a `serde_json::Value` data structure in memory as
-/// output.
-///
-/// [Serde data model]: https://serde.rs/data-model.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website contains example code for
-/// a basic JSON `Serializer`.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait Serializer: Sized {
-    /// The output type produced by this `Serializer` during successful
-    /// serialization. Most serializers that produce text or binary output
-    /// should set `Ok = ()` and serialize into an [`io::Write`] or buffer
-    /// contained within the `Serializer` instance. Serializers that build
-    /// in-memory data structures may be simplified by using `Ok` to propagate
-    /// the data structure around.
-    ///
-    /// [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-    type Ok;
-
-    /// The error type when some error occurs during serialization.
-    type Error: Error;
-
-    /// Type returned from [`serialize_seq`] for serializing the content of the
-    /// sequence.
-    ///
-    /// [`serialize_seq`]: #tymethod.serialize_seq
-    type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple`] for serializing the content of
-    /// the tuple.
-    ///
-    /// [`serialize_tuple`]: #tymethod.serialize_tuple
-    type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple_struct`] for serializing the
-    /// content of the tuple struct.
-    ///
-    /// [`serialize_tuple_struct`]: #tymethod.serialize_tuple_struct
-    type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple_variant`] for serializing the
-    /// content of the tuple variant.
-    ///
-    /// [`serialize_tuple_variant`]: #tymethod.serialize_tuple_variant
-    type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_map`] for serializing the content of the
-    /// map.
-    ///
-    /// [`serialize_map`]: #tymethod.serialize_map
-    type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_struct`] for serializing the content of
-    /// the struct.
-    ///
-    /// [`serialize_struct`]: #tymethod.serialize_struct
-    type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_struct_variant`] for serializing the
-    /// content of the struct variant.
-    ///
-    /// [`serialize_struct_variant`]: #tymethod.serialize_struct_variant
-    type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Serialize a `bool` value.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for bool {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_bool(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i8` value.
-    ///
-    /// If the format does not differentiate between `i8` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i8 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i8(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i16` value.
-    ///
-    /// If the format does not differentiate between `i16` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i16 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i16(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i32` value.
-    ///
-    /// If the format does not differentiate between `i32` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i64` value.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
-
-    serde_if_integer128! {
-        /// Serialize an `i128` value.
-        ///
-        /// ```edition2018
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for i128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_i128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("i128 is not supported"))
-        }
-    }
-
-    /// Serialize a `u8` value.
-    ///
-    /// If the format does not differentiate between `u8` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u8 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u8(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u16` value.
-    ///
-    /// If the format does not differentiate between `u16` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u16 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u16(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u32` value.
-    ///
-    /// If the format does not differentiate between `u32` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u64` value.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
-
-    serde_if_integer128! {
-        /// Serialize a `u128` value.
-        ///
-        /// ```edition2018
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for u128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_u128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("u128 is not supported"))
-        }
-    }
-
-    /// Serialize an `f32` value.
-    ///
-    /// If the format does not differentiate between `f32` and `f64`, a
-    /// reasonable implementation would be to cast the value to `f64` and
-    /// forward to `serialize_f64`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for f32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_f32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `f64` value.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for f64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_f64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a character.
-    ///
-    /// If the format does not support characters, it is reasonable to serialize
-    /// it as a single element `str` or a `u32`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for char {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_char(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `&str`.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for str {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_str(self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a chunk of raw byte data.
-    ///
-    /// Enables serializers to serialize byte slices more compactly or more
-    /// efficiently than other types of slices. If no efficient implementation
-    /// is available, a reasonable implementation would be to forward to
-    /// `serialize_seq`. If forwarded, the implementation looks usually just
-    /// like this:
-    ///
-    /// ```edition2018
-    /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::__private::doc::Error;
-    /// #
-    /// # struct MySerializer;
-    /// #
-    /// # impl Serializer for MySerializer {
-    /// #     type Ok = ();
-    /// #     type Error = Error;
-    /// #
-    /// fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
-    ///     let mut seq = self.serialize_seq(Some(v.len()))?;
-    ///     for b in v {
-    ///         seq.serialize_element(b)?;
-    ///     }
-    ///     seq.end()
-    /// }
-    /// #
-    /// #     serde::__serialize_unimplemented! {
-    /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some
-    /// #         unit unit_struct unit_variant newtype_struct newtype_variant
-    /// #         seq tuple tuple_struct tuple_variant map struct struct_variant
-    /// #     }
-    /// # }
-    /// ```
-    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a [`None`] value.
-    ///
-    /// ```edition2018
-    /// # use serde::{Serialize, Serializer};
-    /// #
-    /// # enum Option<T> {
-    /// #     Some(T),
-    /// #     None,
-    /// # }
-    /// #
-    /// # use self::Option::{Some, None};
-    /// #
-    /// impl<T> Serialize for Option<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             Some(ref value) => serializer.serialize_some(value),
-    ///             None => serializer.serialize_none(),
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # fn main() {}
-    /// ```
-    ///
-    /// [`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a [`Some(T)`] value.
-    ///
-    /// ```edition2018
-    /// # use serde::{Serialize, Serializer};
-    /// #
-    /// # enum Option<T> {
-    /// #     Some(T),
-    /// #     None,
-    /// # }
-    /// #
-    /// # use self::Option::{Some, None};
-    /// #
-    /// impl<T> Serialize for Option<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             Some(ref value) => serializer.serialize_some(value),
-    ///             None => serializer.serialize_none(),
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # fn main() {}
-    /// ```
-    ///
-    /// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a `()` value.
-    ///
-    /// ```edition2018
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for () {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_unit()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a unit struct like `struct Unit` or `PhantomData<T>`.
-    ///
-    /// A reasonable implementation would be to forward to `serialize_unit`.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct Nothing;
-    ///
-    /// impl Serialize for Nothing {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_unit_struct("Nothing")
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a unit variant like `E::A` in `enum E { A, B }`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, and the `variant` is the name of the
-    /// variant.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// enum E {
-    ///     A,
-    ///     B,
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::A => serializer.serialize_unit_variant("E", 0, "A"),
-    ///             E::B => serializer.serialize_unit_variant("E", 1, "B"),
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a newtype struct like `struct Millimeters(u8)`.
-    ///
-    /// Serializers are encouraged to treat newtype structs as insignificant
-    /// wrappers around the data they contain. A reasonable implementation would
-    /// be to forward to `value.serialize(self)`.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct Millimeters(u8);
-    ///
-    /// impl Serialize for Millimeters {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_newtype_struct("Millimeters", &self.0)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, and the `variant` is the name of the
-    /// variant. The `value` is the data contained within this newtype variant.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// enum E {
-    ///     M(String),
-    ///     N(u8),
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
-    ///             E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Begin to serialize a variably sized sequence. This call must be
-    /// followed by zero or more calls to `serialize_element`, then a call to
-    /// `end`.
-    ///
-    /// The argument is the number of elements in the sequence, which may or may
-    /// not be computable before the sequence is iterated. Some serializers only
-    /// support sequences whose length is known up front.
-    ///
-    /// ```edition2018
-    /// # use std::marker::PhantomData;
-    /// #
-    /// # struct Vec<T>(PhantomData<T>);
-    /// #
-    /// # impl<T> Vec<T> {
-    /// #     fn len(&self) -> usize {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # impl<'a, T> IntoIterator for &'a Vec<T> {
-    /// #     type Item = &'a T;
-    /// #     type IntoIter = Box<Iterator<Item = &'a T>>;
-    /// #
-    /// #     fn into_iter(self) -> Self::IntoIter {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::ser::{Serialize, Serializer, SerializeSeq};
-    ///
-    /// impl<T> Serialize for Vec<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
-    ///         for element in self {
-    ///             seq.serialize_element(element)?;
-    ///         }
-    ///         seq.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error>;
-
-    /// Begin to serialize a statically sized sequence whose length will be
-    /// known at deserialization time without looking at the serialized data.
-    /// This call must be followed by zero or more calls to `serialize_element`,
-    /// then a call to `end`.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, Serializer, SerializeTuple};
-    ///
-    /// # mod fool {
-    /// #     trait Serialize {}
-    /// impl<A, B, C> Serialize for (A, B, C)
-    /// #     {}
-    /// # }
-    /// #
-    /// # struct Tuple3<A, B, C>(A, B, C);
-    /// #
-    /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-    /// where
-    ///     A: Serialize,
-    ///     B: Serialize,
-    ///     C: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut tup = serializer.serialize_tuple(3)?;
-    ///         tup.serialize_element(&self.0)?;
-    ///         tup.serialize_element(&self.1)?;
-    ///         tup.serialize_element(&self.2)?;
-    ///         tup.end()
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
-    ///
-    /// const VRAM_SIZE: usize = 386;
-    /// struct Vram([u16; VRAM_SIZE]);
-    ///
-    /// impl Serialize for Vram {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
-    ///         for element in &self.0[..] {
-    ///             seq.serialize_element(element)?;
-    ///         }
-    ///         seq.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error>;
-
-    /// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This
-    /// call must be followed by zero or more calls to `serialize_field`, then a
-    /// call to `end`.
-    ///
-    /// The `name` is the name of the tuple struct and the `len` is the number
-    /// of data fields that will be serialized.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
-    ///
-    /// struct Rgb(u8, u8, u8);
-    ///
-    /// impl Serialize for Rgb {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
-    ///         ts.serialize_field(&self.0)?;
-    ///         ts.serialize_field(&self.1)?;
-    ///         ts.serialize_field(&self.2)?;
-    ///         ts.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error>;
-
-    /// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)
-    /// }`. This call must be followed by zero or more calls to
-    /// `serialize_field`, then a call to `end`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, the `variant` is the name of the variant,
-    /// and the `len` is the number of data fields that will be serialized.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
-    ///
-    /// enum E {
-    ///     T(u8, u8),
-    ///     U(String, u32, u32),
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::T(ref a, ref b) => {
-    ///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
-    ///                 tv.serialize_field(a)?;
-    ///                 tv.serialize_field(b)?;
-    ///                 tv.end()
-    ///             }
-    ///             E::U(ref a, ref b, ref c) => {
-    ///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
-    ///                 tv.serialize_field(a)?;
-    ///                 tv.serialize_field(b)?;
-    ///                 tv.serialize_field(c)?;
-    ///                 tv.end()
-    ///             }
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error>;
-
-    /// Begin to serialize a map. This call must be followed by zero or more
-    /// calls to `serialize_key` and `serialize_value`, then a call to `end`.
-    ///
-    /// The argument is the number of elements in the map, which may or may not
-    /// be computable before the map is iterated. Some serializers only support
-    /// maps whose length is known up front.
-    ///
-    /// ```edition2018
-    /// # use std::marker::PhantomData;
-    /// #
-    /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
-    /// #
-    /// # impl<K, V> HashMap<K, V> {
-    /// #     fn len(&self) -> usize {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
-    /// #     type Item = (&'a K, &'a V);
-    /// #     type IntoIter = Box<Iterator<Item = (&'a K, &'a V)>>;
-    /// #
-    /// #     fn into_iter(self) -> Self::IntoIter {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::ser::{Serialize, Serializer, SerializeMap};
-    ///
-    /// impl<K, V> Serialize for HashMap<K, V>
-    /// where
-    ///     K: Serialize,
-    ///     V: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut map = serializer.serialize_map(Some(self.len()))?;
-    ///         for (k, v) in self {
-    ///             map.serialize_entry(k, v)?;
-    ///         }
-    ///         map.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>;
-
-    /// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
-    /// This call must be followed by zero or more calls to `serialize_field`,
-    /// then a call to `end`.
-    ///
-    /// The `name` is the name of the struct and the `len` is the number of
-    /// data fields that will be serialized.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
-    ///
-    /// struct Rgb {
-    ///     r: u8,
-    ///     g: u8,
-    ///     b: u8,
-    /// }
-    ///
-    /// impl Serialize for Rgb {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
-    ///         rgb.serialize_field("r", &self.r)?;
-    ///         rgb.serialize_field("g", &self.g)?;
-    ///         rgb.serialize_field("b", &self.b)?;
-    ///         rgb.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error>;
-
-    /// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,
-    /// g: u8, b: u8 } }`. This call must be followed by zero or more calls to
-    /// `serialize_field`, then a call to `end`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, the `variant` is the name of the variant,
-    /// and the `len` is the number of data fields that will be serialized.
-    ///
-    /// ```edition2018
-    /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
-    ///
-    /// enum E {
-    ///     S { r: u8, g: u8, b: u8 },
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::S {
-    ///                 ref r,
-    ///                 ref g,
-    ///                 ref b,
-    ///             } => {
-    ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
-    ///                 sv.serialize_field("r", r)?;
-    ///                 sv.serialize_field("g", g)?;
-    ///                 sv.serialize_field("b", b)?;
-    ///                 sv.end()
-    ///             }
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_struct_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error>;
-
-    /// Collect an iterator as a sequence.
-    ///
-    /// The default implementation serializes each item yielded by the iterator
-    /// using [`serialize_seq`]. Implementors should not need to override this
-    /// method.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct SecretlyOneHigher {
-    ///     data: Vec<i32>,
-    /// }
-    ///
-    /// impl Serialize for SecretlyOneHigher {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_seq(self.data.iter().map(|x| x + 1))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`serialize_seq`]: #tymethod.serialize_seq
-    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
-    where
-        I: IntoIterator,
-        <I as IntoIterator>::Item: Serialize,
-    {
-        let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
-
-        #[cfg(iterator_try_fold)]
-        {
-            let mut iter = iter;
-            try!(iter.try_for_each(|item| serializer.serialize_element(&item)));
-        }
-
-        #[cfg(not(iterator_try_fold))]
-        {
-            for item in iter {
-                try!(serializer.serialize_element(&item));
-            }
-        }
-
-        serializer.end()
-    }
-
-    /// Collect an iterator as a map.
-    ///
-    /// The default implementation serializes each pair yielded by the iterator
-    /// using [`serialize_map`]. Implementors should not need to override this
-    /// method.
-    ///
-    /// ```edition2018
-    /// use serde::{Serialize, Serializer};
-    /// use std::collections::BTreeSet;
-    ///
-    /// struct MapToUnit {
-    ///     keys: BTreeSet<i32>,
-    /// }
-    ///
-    /// // Serializes as a map in which the values are all unit.
-    /// impl Serialize for MapToUnit {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_map(self.keys.iter().map(|k| (k, ())))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`serialize_map`]: #tymethod.serialize_map
-    fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-        I: IntoIterator<Item = (K, V)>,
-    {
-        let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
-
-        #[cfg(iterator_try_fold)]
-        {
-            let mut iter = iter;
-            try!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value)));
-        }
-
-        #[cfg(not(iterator_try_fold))]
-        {
-            for (key, value) in iter {
-                try!(serializer.serialize_entry(&key, &value));
-            }
-        }
-
-        serializer.end()
-    }
-
-    /// Serialize a string produced by an implementation of `Display`.
-    ///
-    /// The default implementation builds a heap-allocated [`String`] and
-    /// delegates to [`serialize_str`]. Serializers are encouraged to provide a
-    /// more efficient implementation if possible.
-    ///
-    /// ```edition2018
-    /// # struct DateTime;
-    /// #
-    /// # impl DateTime {
-    /// #     fn naive_local(&self) -> () { () }
-    /// #     fn offset(&self) -> () { () }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for DateTime {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_str(&format_args!("{:?}{:?}",
-    ///                                              self.naive_local(),
-    ///                                              self.offset()))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
-    /// [`serialize_str`]: #tymethod.serialize_str
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Display,
-    {
-        self.serialize_str(&value.to_string())
-    }
-
-    /// Serialize a string produced by an implementation of `Display`.
-    ///
-    /// Serializers that use `no_std` are required to provide an implementation
-    /// of this method. If no more sensible behavior is possible, the
-    /// implementation is expected to return an error.
-    ///
-    /// ```edition2018
-    /// # struct DateTime;
-    /// #
-    /// # impl DateTime {
-    /// #     fn naive_local(&self) -> () { () }
-    /// #     fn offset(&self) -> () { () }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for DateTime {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_str(&format_args!("{:?}{:?}",
-    ///                                              self.naive_local(),
-    ///                                              self.offset()))
-    ///     }
-    /// }
-    /// ```
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Display;
-
-    /// Determine whether `Serialize` implementations should serialize in
-    /// human-readable form.
-    ///
-    /// Some types have a human-readable form that may be somewhat expensive to
-    /// construct, as well as a binary form that is compact and efficient.
-    /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Bincode will prefer the
-    /// compact one.
-    ///
-    /// ```edition2018
-    /// # use std::fmt::{self, Display};
-    /// #
-    /// # struct Timestamp;
-    /// #
-    /// # impl Timestamp {
-    /// #     fn seconds_since_epoch(&self) -> u64 { unimplemented!() }
-    /// # }
-    /// #
-    /// # impl Display for Timestamp {
-    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for Timestamp {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         if serializer.is_human_readable() {
-    ///             // Serialize to a human-readable string "2015-05-15T17:01:00Z".
-    ///             self.to_string().serialize(serializer)
-    ///         } else {
-    ///             // Serialize to a compact binary representation.
-    ///             self.seconds_since_epoch().serialize(serializer)
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The default implementation of this method returns `true`. Data formats
-    /// may override this to `false` to request a compact form for types that
-    /// support one. Note that modifying this method to change a format from
-    /// human-readable to compact or vice versa should be regarded as a breaking
-    /// change, as a value serialized in human-readable mode is not required to
-    /// deserialize from the same data in compact mode.
-    #[inline]
-    fn is_human_readable(&self) -> bool {
-        true
-    }
-}
-
-/// Returned from `Serializer::serialize_seq`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// # use std::marker::PhantomData;
-/// #
-/// # struct Vec<T>(PhantomData<T>);
-/// #
-/// # impl<T> Vec<T> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, T> IntoIterator for &'a Vec<T> {
-/// #     type Item = &'a T;
-/// #     type IntoIter = Box<Iterator<Item = &'a T>>;
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, Serializer, SerializeSeq};
-///
-/// impl<T> Serialize for Vec<T>
-/// where
-///     T: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
-///         for element in self {
-///             seq.serialize_element(element)?;
-///         }
-///         seq.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeSeq` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeSeq {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a sequence element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a sequence.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// use serde::ser::{Serialize, Serializer, SerializeTuple};
-///
-/// # mod fool {
-/// #     trait Serialize {}
-/// impl<A, B, C> Serialize for (A, B, C)
-/// #     {}
-/// # }
-/// #
-/// # struct Tuple3<A, B, C>(A, B, C);
-/// #
-/// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-/// where
-///     A: Serialize,
-///     B: Serialize,
-///     C: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut tup = serializer.serialize_tuple(3)?;
-///         tup.serialize_element(&self.0)?;
-///         tup.serialize_element(&self.1)?;
-///         tup.serialize_element(&self.2)?;
-///         tup.end()
-///     }
-/// }
-/// ```
-///
-/// ```edition2018
-/// # use std::marker::PhantomData;
-/// #
-/// # struct Array<T>(PhantomData<T>);
-/// #
-/// # impl<T> Array<T> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, T> IntoIterator for &'a Array<T> {
-/// #     type Item = &'a T;
-/// #     type IntoIter = Box<Iterator<Item = &'a T>>;
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, Serializer, SerializeTuple};
-///
-/// # mod fool {
-/// #     trait Serialize {}
-/// impl<T> Serialize for [T; 16]
-/// #     {}
-/// # }
-/// #
-/// # impl<T> Serialize for Array<T>
-/// where
-///     T: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut seq = serializer.serialize_tuple(16)?;
-///         for element in self {
-///             seq.serialize_element(element)?;
-///         }
-///         seq.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTuple` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTuple {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple_struct`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
-///
-/// struct Rgb(u8, u8, u8);
-///
-/// impl Serialize for Rgb {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
-///         ts.serialize_field(&self.0)?;
-///         ts.serialize_field(&self.1)?;
-///         ts.serialize_field(&self.2)?;
-///         ts.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTupleStruct` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTupleStruct {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple struct field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple struct.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple_variant`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
-///
-/// enum E {
-///     T(u8, u8),
-///     U(String, u32, u32),
-/// }
-///
-/// impl Serialize for E {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         match *self {
-///             E::T(ref a, ref b) => {
-///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
-///                 tv.serialize_field(a)?;
-///                 tv.serialize_field(b)?;
-///                 tv.end()
-///             }
-///             E::U(ref a, ref b, ref c) => {
-///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
-///                 tv.serialize_field(a)?;
-///                 tv.serialize_field(b)?;
-///                 tv.serialize_field(c)?;
-///                 tv.end()
-///             }
-///         }
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTupleVariant` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTupleVariant {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple variant field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple variant.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_map`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// # use std::marker::PhantomData;
-/// #
-/// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
-/// #
-/// # impl<K, V> HashMap<K, V> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
-/// #     type Item = (&'a K, &'a V);
-/// #     type IntoIter = Box<Iterator<Item = (&'a K, &'a V)>>;
-/// #
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, Serializer, SerializeMap};
-///
-/// impl<K, V> Serialize for HashMap<K, V>
-/// where
-///     K: Serialize,
-///     V: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut map = serializer.serialize_map(Some(self.len()))?;
-///         for (k, v) in self {
-///             map.serialize_entry(k, v)?;
-///         }
-///         map.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeMap` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeMap {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a map key.
-    ///
-    /// If possible, `Serialize` implementations are encouraged to use
-    /// `serialize_entry` instead as it may be implemented more efficiently in
-    /// some formats compared to a pair of calls to `serialize_key` and
-    /// `serialize_value`.
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a map value.
-    ///
-    /// # Panics
-    ///
-    /// Calling `serialize_value` before `serialize_key` is incorrect and is
-    /// allowed to panic or produce bogus results.
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a map entry consisting of a key and a value.
-    ///
-    /// Some [`Serialize`] types are not able to hold a key and value in memory
-    /// at the same time so `SerializeMap` implementations are required to
-    /// support [`serialize_key`] and [`serialize_value`] individually. The
-    /// `serialize_entry` method allows serializers to optimize for the case
-    /// where key and value are both available. [`Serialize`] implementations
-    /// are encouraged to use `serialize_entry` if possible.
-    ///
-    /// The default implementation delegates to [`serialize_key`] and
-    /// [`serialize_value`]. This is appropriate for serializers that do not
-    /// care about performance or are not able to optimize `serialize_entry` any
-    /// better than this.
-    ///
-    /// [`Serialize`]: ../trait.Serialize.html
-    /// [`serialize_key`]: #tymethod.serialize_key
-    /// [`serialize_value`]: #tymethod.serialize_value
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-    {
-        try!(self.serialize_key(key));
-        self.serialize_value(value)
-    }
-
-    /// Finish serializing a map.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_struct`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// use serde::ser::{Serialize, SerializeStruct, Serializer};
-///
-/// struct Rgb {
-///     r: u8,
-///     g: u8,
-///     b: u8,
-/// }
-///
-/// impl Serialize for Rgb {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
-///         rgb.serialize_field("r", &self.r)?;
-///         rgb.serialize_field("g", &self.g)?;
-///         rgb.serialize_field("b", &self.b)?;
-///         rgb.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeStruct` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeStruct {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a struct field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Indicate that a struct field has been skipped.
-    #[inline]
-    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
-        let _ = key;
-        Ok(())
-    }
-
-    /// Finish serializing a struct.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_struct_variant`.
-///
-/// # Example use
-///
-/// ```edition2018
-/// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
-///
-/// enum E {
-///     S { r: u8, g: u8, b: u8 },
-/// }
-///
-/// impl Serialize for E {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         match *self {
-///             E::S {
-///                 ref r,
-///                 ref g,
-///                 ref b,
-///             } => {
-///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
-///                 sv.serialize_field("r", r)?;
-///                 sv.serialize_field("g", g)?;
-///                 sv.serialize_field("b", b)?;
-///                 sv.end()
-///             }
-///         }
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeStructVariant` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeStructVariant {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a struct variant field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Indicate that a struct variant field has been skipped.
-    #[inline]
-    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
-        let _ = key;
-        Ok(())
-    }
-
-    /// Finish serializing a struct variant.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-fn iterator_len_hint<I>(iter: &I) -> Option<usize>
-where
-    I: Iterator,
-{
-    match iter.size_hint() {
-        (lo, Some(hi)) if lo == hi => Some(lo),
-        _ => None,
-    }
-}
diff --git a/vendor/serde/src/std_error.rs b/vendor/serde/src/std_error.rs
deleted file mode 100644
index 1055e0ff..00000000
--- a/vendor/serde/src/std_error.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use lib::{Debug, Display};
-
-/// Either a re-export of std::error::Error or a new identical trait, depending
-/// on whether Serde's "std" feature is enabled.
-///
-/// Serde's error traits [`serde::ser::Error`] and [`serde::de::Error`] require
-/// [`std::error::Error`] as a supertrait, but only when Serde is built with
-/// "std" enabled. Data formats that don't care about no\_std support should
-/// generally provide their error types with a `std::error::Error` impl
-/// directly:
-///
-/// ```edition2018
-/// #[derive(Debug)]
-/// struct MySerError {...}
-///
-/// impl serde::ser::Error for MySerError {...}
-///
-/// impl std::fmt::Display for MySerError {...}
-///
-/// // We don't support no_std!
-/// impl std::error::Error for MySerError {}
-/// ```
-///
-/// Data formats that *do* support no\_std may either have a "std" feature of
-/// their own:
-///
-/// ```toml
-/// [features]
-/// std = ["serde/std"]
-/// ```
-///
-/// ```edition2018
-/// #[cfg(feature = "std")]
-/// impl std::error::Error for MySerError {}
-/// ```
-///
-/// ... or else provide the std Error impl unconditionally via Serde's
-/// re-export:
-///
-/// ```edition2018
-/// impl serde::ser::StdError for MySerError {}
-/// ```
-pub trait Error: Debug + Display {
-    /// The underlying cause of this error, if any.
-    fn source(&self) -> Option<&(Error + 'static)> {
-        None
-    }
-}
diff --git a/vendor/serde_derive/.cargo-checksum.json b/vendor/serde_derive/.cargo-checksum.json
deleted file mode 100644
index 445a5fcf..00000000
--- a/vendor/serde_derive/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"6e9e3ab6251f5cea4496386e3fe0d3b43e495316494837573b49fa6d1cda65e5","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"5cf9d2158d70048a2916360ad59d9079f6233c6f68781a7a792e70f8b772d8ce","build.rs":"d0fc2047a792e90b95df7be8d1e75732b231b3a60cb481feebfca46b7edb1209","crates-io.md":"25ed421fe25d0f6f74c4b78674144bef2843a5f78bf552d0a8ec633be69d282b","src/bound.rs":"f3a1a7b76426921ee435e9963c02c2fc7663c15aecfdf6dc1198aacf3f4c2e70","src/de.rs":"c5a41016ce15f8176a2d7a8445ba06d2eb8de0863c1fea0dab51c395dd7dccff","src/dummy.rs":"ad78556876053e74be976e91032200666ffbeeb6f7e92f3a7a8463fea1f60ac5","src/fragment.rs":"5548ba65a53d90a296f60c1328a7a7fb040db467f59c2f5210b2fb320457145d","src/internals/ast.rs":"b019865eef92c1ddbb9029423ac22179f132dc655a51c09fb2a42f4aaef172fd","src/internals/attr.rs":"d3ae0ad0e7d40fbf3c8a5f86c8a8c5b5f289c3318dd79afc6c5c2ce9b3523931","src/internals/case.rs":"9492f0c5142d7b7e8cd39c86d13a855e5ce4489425adb2b96aed89e1b7851ac0","src/internals/check.rs":"11ea94257d2a2ee2276938a6beb4ae11b74c39225c1e342e6df1e7d2b2924496","src/internals/ctxt.rs":"6fa544ae52914498a62a395818ebdc1b36ac2fb5903c60afb741a864ad559f1c","src/internals/mod.rs":"f32138ff19d57eb00f88ba11f6b015efab2102657804f71ebbf386a3698dad91","src/internals/receiver.rs":"ad30c3e4583ef07f74c7905f22a6580af25ebd431fdf1e04878b9a770ca4ede6","src/internals/respan.rs":"899753859c58ce5f532a3ec4584796a52f13ed5a0533191e48c953ba5c1b52ff","src/internals/symbol.rs":"3c9ce461773b7df3bb64d82aa5a0d93052c3bb0e60209db6c0b5c10ee9cfc9cf","src/lib.rs":"441a27da40134a10aad6c11c55e22da62d7b9586fe68381e899a00147194f804","src/pretend.rs":"73fe121ced5804e77d37512bd2c7548be249dcab3eeb0bad59f82e64188f9ace","src/ser.rs":"0d99c841f6c7bc9751ab225fe42d1f8b7fe56e36903efcb4ff10bf6e35c390ba","src/try.rs":"b171b0088c23ebf4bfa07ba457881b41ac5e547d55dd16f737ea988d34badf61"},"package":"ecc0db5cb2556c0e558887d9bbdcf6ac4471e83ff66cf696e5419024d1606276"}
\ No newline at end of file
diff --git a/vendor/serde_derive/Cargo.toml b/vendor/serde_derive/Cargo.toml
deleted file mode 100644
index 6e848460..00000000
--- a/vendor/serde_derive/Cargo.toml
+++ /dev/null
@@ -1,44 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-rust-version = "1.31"
-name = "serde_derive"
-version = "1.0.132"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
-homepage = "https://serde.rs"
-documentation = "https://serde.rs/derive.html"
-readme = "crates-io.md"
-keywords = ["serde", "serialization", "no_std"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/serde-rs/serde"
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[lib]
-name = "serde_derive"
-proc-macro = true
-[dependencies.proc-macro2]
-version = "1.0"
-
-[dependencies.quote]
-version = "1.0"
-
-[dependencies.syn]
-version = "1.0.60"
-[dev-dependencies.serde]
-version = "1.0"
-
-[features]
-default = []
-deserialize_in_place = []
diff --git a/vendor/serde_derive/LICENSE-APACHE b/vendor/serde_derive/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/serde_derive/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/serde_derive/LICENSE-MIT b/vendor/serde_derive/LICENSE-MIT
deleted file mode 100644
index 31aa7938..00000000
--- a/vendor/serde_derive/LICENSE-MIT
+++ /dev/null
@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/serde_derive/README.md b/vendor/serde_derive/README.md
deleted file mode 100644
index 14b00982..00000000
--- a/vendor/serde_derive/README.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
-
-[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/serde/CI/master
-[actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
-[Latest Version]: https://img.shields.io/crates/v/serde.svg
-[crates.io]: https://crates.io/crates/serde
-[serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
-[serde_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-rustc_1.31+-lightgray.svg
-[Rust 1.13]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
-[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-You may be looking for:
-
-- [An overview of Serde](https://serde.rs/)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-<details>
-<summary>
-Click to show Cargo.toml.
-<a href="https://play.rust-lang.org/?edition=2018&gist=72755f28f99afc95e01d63174b28c1f5" target="_blank">Run this code in the playground.</a>
-</summary>
-
-```toml
-[dependencies]
-
-# The core APIs, including the Serialize and Deserialize traits. Always
-# required when using Serde. The "derive" feature is only required when
-# using #[derive(Serialize, Deserialize)] to make Serde work with structs
-# and enums defined in your crate.
-serde = { version = "1.0", features = ["derive"] }
-
-# Each data format lives in its own crate; the sample code below uses JSON
-# but you may be using a different one.
-serde_json = "1.0"
-```
-
-</details>
-<p></p>
-
-```rust
-use serde::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
-}
-```
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
-
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/serde_derive/build.rs b/vendor/serde_derive/build.rs
deleted file mode 100644
index d0c827a6..00000000
--- a/vendor/serde_derive/build.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use std::env;
-use std::process::Command;
-use std::str;
-
-// The rustc-cfg strings below are *not* public API. Please let us know by
-// opening a GitHub issue if your build environment requires some way to enable
-// these cfgs other than by executing our build script.
-fn main() {
-    let minor = match rustc_minor_version() {
-        Some(minor) => minor,
-        None => return,
-    };
-
-    // Underscore const names stabilized in Rust 1.37:
-    // https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
-    if minor >= 37 {
-        println!("cargo:rustc-cfg=underscore_consts");
-    }
-
-    // The ptr::addr_of! macro stabilized in Rust 1.51:
-    // https://blog.rust-lang.org/2021/03/25/Rust-1.51.0.html#stabilized-apis
-    if minor >= 51 {
-        println!("cargo:rustc-cfg=ptr_addr_of");
-    }
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    pieces.next()?.parse().ok()
-}
diff --git a/vendor/serde_derive/crates-io.md b/vendor/serde_derive/crates-io.md
deleted file mode 100644
index 07757614..00000000
--- a/vendor/serde_derive/crates-io.md
+++ /dev/null
@@ -1,62 +0,0 @@
-<!-- Serde readme rendered on crates.io -->
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-You may be looking for:
-
-- [An overview of Serde](https://serde.rs/)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.serde.rs/serde/)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-```rust
-use serde::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
-}
-```
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#general] or [#beginners] channels of the unofficial community Discord, the
-[#rust-usage] channel of the official Rust Project Discord, or the
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
-acceptable to file a support issue in this repo but they tend not to get as many
-eyes as any of the above and may get closed without a response after some time.
-
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
diff --git a/vendor/serde_derive/src/bound.rs b/vendor/serde_derive/src/bound.rs
deleted file mode 100644
index abca467b..00000000
--- a/vendor/serde_derive/src/bound.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-use std::collections::HashSet;
-
-use syn;
-use syn::punctuated::{Pair, Punctuated};
-
-use internals::ast::{Container, Data};
-use internals::{attr, ungroup};
-
-use proc_macro2::Span;
-
-// Remove the default from every type parameter because in the generated impls
-// they look like associated types: "error: associated type bindings are not
-// allowed here".
-pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
-    syn::Generics {
-        params: generics
-            .params
-            .iter()
-            .map(|param| match param {
-                syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
-                    eq_token: None,
-                    default: None,
-                    ..param.clone()
-                }),
-                _ => param.clone(),
-            })
-            .collect(),
-        ..generics.clone()
-    }
-}
-
-pub fn with_where_predicates(
-    generics: &syn::Generics,
-    predicates: &[syn::WherePredicate],
-) -> syn::Generics {
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(predicates.iter().cloned());
-    generics
-}
-
-pub fn with_where_predicates_from_fields(
-    cont: &Container,
-    generics: &syn::Generics,
-    from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
-) -> syn::Generics {
-    let predicates = cont
-        .data
-        .all_fields()
-        .filter_map(|field| from_field(&field.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
-    let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
-    generics
-}
-
-pub fn with_where_predicates_from_variants(
-    cont: &Container,
-    generics: &syn::Generics,
-    from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
-) -> syn::Generics {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return generics.clone();
-        }
-    };
-
-    let predicates = variants
-        .iter()
-        .filter_map(|variant| from_variant(&variant.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
-    let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
-    generics
-}
-
-// Puts the given bound on any generic type parameters that are used in fields
-// for which filter returns true.
-//
-// For example, the following struct needs the bound `A: Serialize, B:
-// Serialize`.
-//
-//     struct S<'b, A, B: 'b, C> {
-//         a: A,
-//         b: Option<&'b B>
-//         #[serde(skip_serializing)]
-//         c: C,
-//     }
-pub fn with_bound(
-    cont: &Container,
-    generics: &syn::Generics,
-    filter: fn(&attr::Field, Option<&attr::Variant>) -> bool,
-    bound: &syn::Path,
-) -> syn::Generics {
-    struct FindTyParams<'ast> {
-        // Set of all generic type parameters on the current struct (A, B, C in
-        // the example). Initialized up front.
-        all_type_params: HashSet<syn::Ident>,
-
-        // Set of generic type parameters used in fields for which filter
-        // returns true (A and B in the example). Filled in as the visitor sees
-        // them.
-        relevant_type_params: HashSet<syn::Ident>,
-
-        // Fields whose type is an associated type of one of the generic type
-        // parameters.
-        associated_type_usage: Vec<&'ast syn::TypePath>,
-    }
-
-    impl<'ast> FindTyParams<'ast> {
-        fn visit_field(&mut self, field: &'ast syn::Field) {
-            if let syn::Type::Path(ty) = ungroup(&field.ty) {
-                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
-                    if self.all_type_params.contains(&t.ident) {
-                        self.associated_type_usage.push(ty);
-                    }
-                }
-            }
-            self.visit_type(&field.ty);
-        }
-
-        fn visit_path(&mut self, path: &'ast syn::Path) {
-            if let Some(seg) = path.segments.last() {
-                if seg.ident == "PhantomData" {
-                    // Hardcoded exception, because PhantomData<T> implements
-                    // Serialize and Deserialize whether or not T implements it.
-                    return;
-                }
-            }
-            if path.leading_colon.is_none() && path.segments.len() == 1 {
-                let id = &path.segments[0].ident;
-                if self.all_type_params.contains(id) {
-                    self.relevant_type_params.insert(id.clone());
-                }
-            }
-            for segment in &path.segments {
-                self.visit_path_segment(segment);
-            }
-        }
-
-        // Everything below is simply traversing the syntax tree.
-
-        fn visit_type(&mut self, ty: &'ast syn::Type) {
-            match ty {
-                syn::Type::Array(ty) => self.visit_type(&ty.elem),
-                syn::Type::BareFn(ty) => {
-                    for arg in &ty.inputs {
-                        self.visit_type(&arg.ty);
-                    }
-                    self.visit_return_type(&ty.output);
-                }
-                syn::Type::Group(ty) => self.visit_type(&ty.elem),
-                syn::Type::ImplTrait(ty) => {
-                    for bound in &ty.bounds {
-                        self.visit_type_param_bound(bound);
-                    }
-                }
-                syn::Type::Macro(ty) => self.visit_macro(&ty.mac),
-                syn::Type::Paren(ty) => self.visit_type(&ty.elem),
-                syn::Type::Path(ty) => {
-                    if let Some(qself) = &ty.qself {
-                        self.visit_type(&qself.ty);
-                    }
-                    self.visit_path(&ty.path);
-                }
-                syn::Type::Ptr(ty) => self.visit_type(&ty.elem),
-                syn::Type::Reference(ty) => self.visit_type(&ty.elem),
-                syn::Type::Slice(ty) => self.visit_type(&ty.elem),
-                syn::Type::TraitObject(ty) => {
-                    for bound in &ty.bounds {
-                        self.visit_type_param_bound(bound);
-                    }
-                }
-                syn::Type::Tuple(ty) => {
-                    for elem in &ty.elems {
-                        self.visit_type(elem);
-                    }
-                }
-
-                syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
-
-                #[cfg(test)]
-                syn::Type::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
-                _ => {}
-            }
-        }
-
-        fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) {
-            self.visit_path_arguments(&segment.arguments);
-        }
-
-        fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) {
-            match arguments {
-                syn::PathArguments::None => {}
-                syn::PathArguments::AngleBracketed(arguments) => {
-                    for arg in &arguments.args {
-                        match arg {
-                            syn::GenericArgument::Type(arg) => self.visit_type(arg),
-                            syn::GenericArgument::Binding(arg) => self.visit_type(&arg.ty),
-                            syn::GenericArgument::Lifetime(_)
-                            | syn::GenericArgument::Constraint(_)
-                            | syn::GenericArgument::Const(_) => {}
-                        }
-                    }
-                }
-                syn::PathArguments::Parenthesized(arguments) => {
-                    for argument in &arguments.inputs {
-                        self.visit_type(argument);
-                    }
-                    self.visit_return_type(&arguments.output);
-                }
-            }
-        }
-
-        fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) {
-            match return_type {
-                syn::ReturnType::Default => {}
-                syn::ReturnType::Type(_, output) => self.visit_type(output),
-            }
-        }
-
-        fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
-            match bound {
-                syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
-                syn::TypeParamBound::Lifetime(_) => {}
-            }
-        }
-
-        // Type parameter should not be considered used by a macro path.
-        //
-        //     struct TypeMacro<T> {
-        //         mac: T!(),
-        //         marker: PhantomData<T>,
-        //     }
-        fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
-    }
-
-    let all_type_params = generics
-        .type_params()
-        .map(|param| param.ident.clone())
-        .collect();
-
-    let mut visitor = FindTyParams {
-        all_type_params,
-        relevant_type_params: HashSet::new(),
-        associated_type_usage: Vec::new(),
-    };
-    match &cont.data {
-        Data::Enum(variants) => {
-            for variant in variants.iter() {
-                let relevant_fields = variant
-                    .fields
-                    .iter()
-                    .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
-                for field in relevant_fields {
-                    visitor.visit_field(field.original);
-                }
-            }
-        }
-        Data::Struct(_, fields) => {
-            for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
-                visitor.visit_field(field.original);
-            }
-        }
-    }
-
-    let relevant_type_params = visitor.relevant_type_params;
-    let associated_type_usage = visitor.associated_type_usage;
-    let new_predicates = generics
-        .type_params()
-        .map(|param| param.ident.clone())
-        .filter(|id| relevant_type_params.contains(id))
-        .map(|id| syn::TypePath {
-            qself: None,
-            path: id.into(),
-        })
-        .chain(associated_type_usage.into_iter().cloned())
-        .map(|bounded_ty| {
-            syn::WherePredicate::Type(syn::PredicateType {
-                lifetimes: None,
-                // the type parameter that is being bounded e.g. T
-                bounded_ty: syn::Type::Path(bounded_ty),
-                colon_token: <Token![:]>::default(),
-                // the bound e.g. Serialize
-                bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
-                    paren_token: None,
-                    modifier: syn::TraitBoundModifier::None,
-                    lifetimes: None,
-                    path: bound.clone(),
-                })]
-                .into_iter()
-                .collect(),
-            })
-        });
-
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(new_predicates);
-    generics
-}
-
-pub fn with_self_bound(
-    cont: &Container,
-    generics: &syn::Generics,
-    bound: &syn::Path,
-) -> syn::Generics {
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .push(syn::WherePredicate::Type(syn::PredicateType {
-            lifetimes: None,
-            // the type that is being bounded e.g. MyStruct<'a, T>
-            bounded_ty: type_of_item(cont),
-            colon_token: <Token![:]>::default(),
-            // the bound e.g. Default
-            bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
-                paren_token: None,
-                modifier: syn::TraitBoundModifier::None,
-                lifetimes: None,
-                path: bound.clone(),
-            })]
-            .into_iter()
-            .collect(),
-        }));
-    generics
-}
-
-pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
-    let bound = syn::Lifetime::new(lifetime, Span::call_site());
-    let def = syn::LifetimeDef {
-        attrs: Vec::new(),
-        lifetime: bound.clone(),
-        colon_token: None,
-        bounds: Punctuated::new(),
-    };
-
-    let params = Some(syn::GenericParam::Lifetime(def))
-        .into_iter()
-        .chain(generics.params.iter().cloned().map(|mut param| {
-            match &mut param {
-                syn::GenericParam::Lifetime(param) => {
-                    param.bounds.push(bound.clone());
-                }
-                syn::GenericParam::Type(param) => {
-                    param
-                        .bounds
-                        .push(syn::TypeParamBound::Lifetime(bound.clone()));
-                }
-                syn::GenericParam::Const(_) => {}
-            }
-            param
-        }))
-        .collect();
-
-    syn::Generics {
-        params,
-        ..generics.clone()
-    }
-}
-
-fn type_of_item(cont: &Container) -> syn::Type {
-    syn::Type::Path(syn::TypePath {
-        qself: None,
-        path: syn::Path {
-            leading_colon: None,
-            segments: vec![syn::PathSegment {
-                ident: cont.ident.clone(),
-                arguments: syn::PathArguments::AngleBracketed(
-                    syn::AngleBracketedGenericArguments {
-                        colon2_token: None,
-                        lt_token: <Token![<]>::default(),
-                        args: cont
-                            .generics
-                            .params
-                            .iter()
-                            .map(|param| match param {
-                                syn::GenericParam::Type(param) => {
-                                    syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
-                                        qself: None,
-                                        path: param.ident.clone().into(),
-                                    }))
-                                }
-                                syn::GenericParam::Lifetime(param) => {
-                                    syn::GenericArgument::Lifetime(param.lifetime.clone())
-                                }
-                                syn::GenericParam::Const(_) => {
-                                    panic!("Serde does not support const generics yet");
-                                }
-                            })
-                            .collect(),
-                        gt_token: <Token![>]>::default(),
-                    },
-                ),
-            }]
-            .into_iter()
-            .collect(),
-        },
-    })
-}
diff --git a/vendor/serde_derive/src/de.rs b/vendor/serde_derive/src/de.rs
deleted file mode 100644
index ff7bc42f..00000000
--- a/vendor/serde_derive/src/de.rs
+++ /dev/null
@@ -1,3132 +0,0 @@
-use proc_macro2::{Literal, Span, TokenStream};
-use quote::ToTokens;
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{self, Ident, Index, Member};
-
-use bound;
-use dummy;
-use fragment::{Expr, Fragment, Match, Stmts};
-use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
-use pretend;
-
-use std::collections::BTreeSet;
-use std::ptr;
-
-pub fn expand_derive_deserialize(
-    input: &mut syn::DeriveInput,
-) -> Result<TokenStream, Vec<syn::Error>> {
-    replace_receiver(input);
-
-    let ctxt = Ctxt::new();
-    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
-        Some(cont) => cont,
-        None => return Err(ctxt.check().unwrap_err()),
-    };
-    precondition(&ctxt, &cont);
-    ctxt.check()?;
-
-    let ident = &cont.ident;
-    let params = Parameters::new(&cont);
-    let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
-    let body = Stmts(deserialize_body(&cont, &params));
-    let delife = params.borrowed.de_lifetime();
-    let serde = cont.attrs.serde_path();
-
-    let impl_block = if let Some(remote) = cont.attrs.remote() {
-        let vis = &input.vis;
-        let used = pretend::pretend_used(&cont, params.is_packed);
-        quote! {
-            impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<#remote #ty_generics, __D::Error>
-                where
-                    __D: #serde::Deserializer<#delife>,
-                {
-                    #used
-                    #body
-                }
-            }
-        }
-    } else {
-        let fn_deserialize_in_place = deserialize_in_place_body(&cont, &params);
-
-        quote! {
-            #[automatically_derived]
-            impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<Self, __D::Error>
-                where
-                    __D: #serde::Deserializer<#delife>,
-                {
-                    #body
-                }
-
-                #fn_deserialize_in_place
-            }
-        }
-    };
-
-    Ok(dummy::wrap_in_const(
-        cont.attrs.custom_serde_path(),
-        "DESERIALIZE",
-        ident,
-        impl_block,
-    ))
-}
-
-fn precondition(cx: &Ctxt, cont: &Container) {
-    precondition_sized(cx, cont);
-    precondition_no_de_lifetime(cx, cont);
-}
-
-fn precondition_sized(cx: &Ctxt, cont: &Container) {
-    if let Data::Struct(_, fields) = &cont.data {
-        if let Some(last) = fields.last() {
-            if let syn::Type::Slice(_) = ungroup(last.ty) {
-                cx.error_spanned_by(
-                    cont.original,
-                    "cannot deserialize a dynamically sized struct",
-                );
-            }
-        }
-    }
-}
-
-fn precondition_no_de_lifetime(cx: &Ctxt, cont: &Container) {
-    if let BorrowedLifetimes::Borrowed(_) = borrowed_lifetimes(cont) {
-        for param in cont.generics.lifetimes() {
-            if param.lifetime.to_string() == "'de" {
-                cx.error_spanned_by(
-                    &param.lifetime,
-                    "cannot deserialize when there is a lifetime parameter called 'de",
-                );
-                return;
-            }
-        }
-    }
-}
-
-struct Parameters {
-    /// Name of the type the `derive` is on.
-    local: syn::Ident,
-
-    /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
-
-    /// Generics including any explicit and inferred bounds for the impl.
-    generics: syn::Generics,
-
-    /// Lifetimes borrowed from the deserializer. These will become bounds on
-    /// the `'de` lifetime of the deserializer.
-    borrowed: BorrowedLifetimes,
-
-    /// At least one field has a serde(getter) attribute, implying that the
-    /// remote type has a private field.
-    has_getter: bool,
-
-    /// Type has a repr(packed) attribute.
-    is_packed: bool,
-}
-
-impl Parameters {
-    fn new(cont: &Container) -> Self {
-        let local = cont.ident.clone();
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
-        let borrowed = borrowed_lifetimes(cont);
-        let generics = build_generics(cont, &borrowed);
-        let has_getter = cont.data.has_getter();
-        let is_packed = cont.attrs.is_packed();
-
-        Parameters {
-            local,
-            this,
-            generics,
-            borrowed,
-            has_getter,
-            is_packed,
-        }
-    }
-
-    /// Type name to use in error messages and `&'static str` arguments to
-    /// various Deserializer methods.
-    fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
-    }
-}
-
-// All the generics in the input, plus a bound `T: Deserialize` for each generic
-// field type that will be deserialized by us, plus a bound `T: Default` for
-// each generic field type that will be set to a default value.
-fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generics {
-    let generics = bound::without_defaults(cont.generics);
-
-    let generics = bound::with_where_predicates_from_fields(cont, &generics, attr::Field::de_bound);
-
-    let generics =
-        bound::with_where_predicates_from_variants(cont, &generics, attr::Variant::de_bound);
-
-    match cont.attrs.de_bound() {
-        Some(predicates) => bound::with_where_predicates(&generics, predicates),
-        None => {
-            let generics = match *cont.attrs.default() {
-                attr::Default::Default => bound::with_self_bound(
-                    cont,
-                    &generics,
-                    &parse_quote!(_serde::__private::Default),
-                ),
-                attr::Default::None | attr::Default::Path(_) => generics,
-            };
-
-            let delife = borrowed.de_lifetime();
-            let generics = bound::with_bound(
-                cont,
-                &generics,
-                needs_deserialize_bound,
-                &parse_quote!(_serde::Deserialize<#delife>),
-            );
-
-            bound::with_bound(
-                cont,
-                &generics,
-                requires_default,
-                &parse_quote!(_serde::__private::Default),
-            )
-        }
-    }
-}
-
-// Fields with a `skip_deserializing` or `deserialize_with` attribute, or which
-// belong to a variant with a `skip_deserializing` or `deserialize_with`
-// attribute, are not deserialized by us so we do not generate a bound. Fields
-// with a `bound` attribute specify their own bound so we do not generate one.
-// All other fields may need a `T: Deserialize` bound where T is the type of the
-// field.
-fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_deserializing()
-        && field.deserialize_with().is_none()
-        && field.de_bound().is_none()
-        && variant.map_or(true, |variant| {
-            !variant.skip_deserializing()
-                && variant.deserialize_with().is_none()
-                && variant.de_bound().is_none()
-        })
-}
-
-// Fields with a `default` attribute (not `default=...`), and fields with a
-// `skip_deserializing` attribute that do not also have `default=...`.
-fn requires_default(field: &attr::Field, _variant: Option<&attr::Variant>) -> bool {
-    if let attr::Default::Default = *field.default() {
-        true
-    } else {
-        false
-    }
-}
-
-enum BorrowedLifetimes {
-    Borrowed(BTreeSet<syn::Lifetime>),
-    Static,
-}
-
-impl BorrowedLifetimes {
-    fn de_lifetime(&self) -> syn::Lifetime {
-        match *self {
-            BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new("'de", Span::call_site()),
-            BorrowedLifetimes::Static => syn::Lifetime::new("'static", Span::call_site()),
-        }
-    }
-
-    fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
-        match self {
-            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: bounds.iter().cloned().collect(),
-            }),
-            BorrowedLifetimes::Static => None,
-        }
-    }
-}
-
-// The union of lifetimes borrowed by each field of the container.
-//
-// These turn into bounds on the `'de` lifetime of the Deserialize impl. If
-// lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is:
-//
-//     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>
-//
-// If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant
-// and we use plain `'static` instead of `'de`.
-fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
-    let mut lifetimes = BTreeSet::new();
-    for field in cont.data.all_fields() {
-        if !field.attrs.skip_deserializing() {
-            lifetimes.extend(field.attrs.borrowed_lifetimes().iter().cloned());
-        }
-    }
-    if lifetimes.iter().any(|b| b.to_string() == "'static") {
-        BorrowedLifetimes::Static
-    } else {
-        BorrowedLifetimes::Borrowed(lifetimes)
-    }
-}
-
-fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
-    if cont.attrs.transparent() {
-        deserialize_transparent(cont, params)
-    } else if let Some(type_from) = cont.attrs.type_from() {
-        deserialize_from(type_from)
-    } else if let Some(type_try_from) = cont.attrs.type_try_from() {
-        deserialize_try_from(type_try_from)
-    } else if let attr::Identifier::No = cont.attrs.identifier() {
-        match &cont.data {
-            Data::Enum(variants) => deserialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, fields) => {
-                deserialize_struct(None, params, fields, &cont.attrs, None, &Untagged::No)
-            }
-            Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-                deserialize_tuple(None, params, fields, &cont.attrs, None)
-            }
-            Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
-        }
-    } else {
-        match &cont.data {
-            Data::Enum(variants) => deserialize_custom_identifier(params, variants, &cont.attrs),
-            Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
-        }
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<Stmts> {
-    // Only remote derives have getters, and we do not generate
-    // deserialize_in_place for remote derives.
-    assert!(!params.has_getter);
-
-    if cont.attrs.transparent()
-        || cont.attrs.type_from().is_some()
-        || cont.attrs.type_try_from().is_some()
-        || cont.attrs.identifier().is_some()
-        || cont
-            .data
-            .all_fields()
-            .all(|f| f.attrs.deserialize_with().is_some())
-    {
-        return None;
-    }
-
-    let code = match &cont.data {
-        Data::Struct(Style::Struct, fields) => {
-            deserialize_struct_in_place(None, params, fields, &cont.attrs, None)?
-        }
-        Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-            deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
-        }
-        Data::Enum(_) | Data::Struct(Style::Unit, _) => {
-            return None;
-        }
-    };
-
-    let delife = params.borrowed.de_lifetime();
-    let stmts = Stmts(code);
-
-    let fn_deserialize_in_place = quote_block! {
-        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::__private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<#delife>,
-        {
-            #stmts
-        }
-    };
-
-    Some(Stmts(fn_deserialize_in_place))
-}
-
-#[cfg(not(feature = "deserialize_in_place"))]
-fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<Stmts> {
-    None
-}
-
-fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match &cont.data {
-        Data::Struct(_, fields) => fields,
-        Data::Enum(_) => unreachable!(),
-    };
-
-    let this = &params.this;
-    let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
-
-    let path = match transparent_field.attrs.deserialize_with() {
-        Some(path) => quote!(#path),
-        None => {
-            let span = transparent_field.original.span();
-            quote_spanned!(span=> _serde::Deserialize::deserialize)
-        }
-    };
-
-    let assign = fields.iter().map(|field| {
-        let member = &field.member;
-        if ptr::eq(field, transparent_field) {
-            quote!(#member: __transparent)
-        } else {
-            let value = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::__private::Default::default()),
-                attr::Default::Path(path) => quote!(#path()),
-                attr::Default::None => quote!(_serde::__private::PhantomData),
-            };
-            quote!(#member: #value)
-        }
-    });
-
-    quote_block! {
-        _serde::__private::Result::map(
-            #path(__deserializer),
-            |__transparent| #this { #(#assign),* })
-    }
-}
-
-fn deserialize_from(type_from: &syn::Type) -> Fragment {
-    quote_block! {
-        _serde::__private::Result::map(
-            <#type_from as _serde::Deserialize>::deserialize(__deserializer),
-            _serde::__private::From::from)
-    }
-}
-
-fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
-    quote_block! {
-        _serde::__private::Result::and_then(
-            <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
-            |v| _serde::__private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
-    }
-}
-
-fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
-    let this = &params.this;
-    let type_name = cattrs.name().deserialize_name();
-
-    let expecting = format!("unit struct {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    quote_block! {
-        struct __Visitor;
-
-        impl<'de> _serde::de::Visitor<'de> for __Visitor {
-            type Value = #this;
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #[inline]
-            fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(#this)
-            }
-        }
-
-        _serde::Deserializer::deserialize_unit_struct(__deserializer, #type_name, __Visitor)
-    }
-}
-
-fn deserialize_tuple(
-    variant_ident: Option<&syn::Ident>,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    deserializer: Option<TokenStream>,
-) -> Fragment {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    assert!(!cattrs.has_flatten());
-
-    // If there are getters (implying private fields), construct the local type
-    // and use an `Into` conversion to get the remote type. If there are no
-    // getters then construct the target type directly.
-    let construct = if params.has_getter {
-        let local = &params.local;
-        quote!(#local)
-    } else {
-        quote!(#this)
-    };
-
-    let is_enum = variant_ident.is_some();
-    let type_path = match variant_ident {
-        Some(variant_ident) => quote!(#construct::#variant_ident),
-        None => construct,
-    };
-    let expecting = match variant_ident {
-        Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
-        None => format!("tuple struct {}", params.type_name()),
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let nfields = fields.len();
-
-    let visit_newtype_struct = if !is_enum && nfields == 1 {
-        Some(deserialize_newtype_struct(&type_path, params, &fields[0]))
-    } else {
-        None
-    };
-
-    let visit_seq = Stmts(deserialize_seq(
-        &type_path, params, fields, false, cattrs, expecting,
-    ));
-
-    let visitor_expr = quote! {
-        __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
-        }
-    };
-    let dispatch = if let Some(deserializer) = deserializer {
-        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
-    } else if is_enum {
-        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
-    } else if nfields == 1 {
-        let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
-    } else {
-        let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    quote_block! {
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_newtype_struct
-
-            #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-        }
-
-        #dispatch
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_tuple_in_place(
-    variant_ident: Option<syn::Ident>,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    deserializer: Option<TokenStream>,
-) -> Fragment {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    assert!(!cattrs.has_flatten());
-
-    let is_enum = variant_ident.is_some();
-    let expecting = match variant_ident {
-        Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
-        None => format!("tuple struct {}", params.type_name()),
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let nfields = fields.len();
-
-    let visit_newtype_struct = if !is_enum && nfields == 1 {
-        Some(deserialize_newtype_struct_in_place(params, &fields[0]))
-    } else {
-        None
-    };
-
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
-
-    let visitor_expr = quote! {
-        __Visitor {
-            place: __place,
-            lifetime: _serde::__private::PhantomData,
-        }
-    };
-
-    let dispatch = if let Some(deserializer) = deserializer {
-        quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr))
-    } else if is_enum {
-        quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr))
-    } else if nfields == 1 {
-        let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
-    } else {
-        let type_name = cattrs.name().deserialize_name();
-        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #nfields, #visitor_expr))
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    let in_place_impl_generics = de_impl_generics.in_place();
-    let in_place_ty_generics = de_ty_generics.in_place();
-    let place_life = place_lifetime();
-
-    quote_block! {
-        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
-            type Value = ();
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_newtype_struct
-
-            #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-        }
-
-        #dispatch
-    }
-}
-
-fn deserialize_seq(
-    type_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    is_struct: bool,
-    cattrs: &attr::Container,
-    expecting: &str,
-) -> Fragment {
-    let vars = (0..fields.len()).map(field_i as fn(_) -> _);
-
-    let deserialized_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-    let expecting = if deserialized_count == 1 {
-        format!("{} with 1 element", expecting)
-    } else {
-        format!("{} with {} elements", expecting, deserialized_count)
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let mut index_in_seq = 0_usize;
-    let let_values = vars.clone().zip(fields).map(|(var, field)| {
-        if field.attrs.skip_deserializing() {
-            let default = Expr(expr_is_missing(field, cattrs));
-            quote! {
-                let #var = #default;
-            }
-        } else {
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    let field_ty = field.ty;
-                    let span = field.original.span();
-                    let func =
-                        quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
-                    quote!(try!(#func(&mut __seq)))
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        _serde::__private::Option::map(
-                            try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
-                            |__wrap| __wrap.value)
-                    })
-                }
-            };
-            let value_if_none = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::__private::Default::default()),
-                attr::Default::Path(path) => quote!(#path()),
-                attr::Default::None => quote!(
-                    return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
-                ),
-            };
-            let assign = quote! {
-                let #var = match #visit {
-                    _serde::__private::Some(__value) => __value,
-                    _serde::__private::None => {
-                        #value_if_none
-                    }
-                };
-            };
-            index_in_seq += 1;
-            assign
-        }
-    });
-
-    let mut result = if is_struct {
-        let names = fields.iter().map(|f| &f.member);
-        quote! {
-            #type_path { #( #names: #vars ),* }
-        }
-    } else {
-        quote! {
-            #type_path ( #(#vars),* )
-        }
-    };
-
-    if params.has_getter {
-        let this = &params.this;
-        result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
-        };
-    }
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::__private::Default::default();
-        )),
-        attr::Default::Path(path) => Some(quote!(
-            let __default: Self::Value = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #let_default
-        #(#let_values)*
-        _serde::__private::Ok(#result)
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_seq_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    expecting: &str,
-) -> Fragment {
-    let deserialized_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-    let expecting = if deserialized_count == 1 {
-        format!("{} with 1 element", expecting)
-    } else {
-        format!("{} with {} elements", expecting, deserialized_count)
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let mut index_in_seq = 0usize;
-    let write_values = fields.iter().map(|field| {
-        let member = &field.member;
-
-        if field.attrs.skip_deserializing() {
-            let default = Expr(expr_is_missing(field, cattrs));
-            quote! {
-                self.place.#member = #default;
-            }
-        } else {
-            let value_if_none = match field.attrs.default() {
-                attr::Default::Default => quote!(
-                    self.place.#member = _serde::__private::Default::default();
-                ),
-                attr::Default::Path(path) => quote!(
-                    self.place.#member = #path();
-                ),
-                attr::Default::None => quote!(
-                    return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
-                ),
-            };
-            let write = match field.attrs.deserialize_with() {
-                None => {
-                    quote! {
-                        if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
-                            _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
-                        {
-                            #value_if_none
-                        }
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
-                            _serde::__private::Some(__wrap) => {
-                                self.place.#member = __wrap.value;
-                            }
-                            _serde::__private::None => {
-                                #value_if_none
-                            }
-                        }
-                    })
-                }
-            };
-            index_in_seq += 1;
-            write
-        }
-    });
-
-    let this = &params.this;
-    let (_, ty_generics, _) = params.generics.split_for_impl();
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics  = _serde::__private::Default::default();
-        )),
-        attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics  = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #let_default
-        #(#write_values)*
-        _serde::__private::Ok(())
-    }
-}
-
-fn deserialize_newtype_struct(
-    type_path: &TokenStream,
-    params: &Parameters,
-    field: &Field,
-) -> TokenStream {
-    let delife = params.borrowed.de_lifetime();
-    let field_ty = field.ty;
-
-    let value = match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
-            quote! {
-                try!(#func(__e))
-            }
-        }
-        Some(path) => {
-            quote! {
-                try!(#path(__e))
-            }
-        }
-    };
-
-    let mut result = quote!(#type_path(__field0));
-    if params.has_getter {
-        let this = &params.this;
-        result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
-        };
-    }
-
-    quote! {
-        #[inline]
-        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
-        where
-            __E: _serde::Deserializer<#delife>,
-        {
-            let __field0: #field_ty = #value;
-            _serde::__private::Ok(#result)
-        }
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> TokenStream {
-    // We do not generate deserialize_in_place if every field has a
-    // deserialize_with.
-    assert!(field.attrs.deserialize_with().is_none());
-
-    let delife = params.borrowed.de_lifetime();
-
-    quote! {
-        #[inline]
-        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
-        where
-            __E: _serde::Deserializer<#delife>,
-        {
-            _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
-        }
-    }
-}
-
-enum Untagged {
-    Yes,
-    No,
-}
-
-fn deserialize_struct(
-    variant_ident: Option<&syn::Ident>,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    deserializer: Option<TokenStream>,
-    untagged: &Untagged,
-) -> Fragment {
-    let is_enum = variant_ident.is_some();
-
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    // If there are getters (implying private fields), construct the local type
-    // and use an `Into` conversion to get the remote type. If there are no
-    // getters then construct the target type directly.
-    let construct = if params.has_getter {
-        let local = &params.local;
-        quote!(#local)
-    } else {
-        quote!(#this)
-    };
-
-    let type_path = match variant_ident {
-        Some(variant_ident) => quote!(#construct::#variant_ident),
-        None => construct,
-    };
-    let expecting = match variant_ident {
-        Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
-        None => format!("struct {}", params.type_name()),
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let visit_seq = Stmts(deserialize_seq(
-        &type_path, params, fields, true, cattrs, expecting,
-    ));
-
-    let (field_visitor, fields_stmt, visit_map) = if cattrs.has_flatten() {
-        deserialize_struct_as_map_visitor(&type_path, params, fields, cattrs)
-    } else {
-        deserialize_struct_as_struct_visitor(&type_path, params, fields, cattrs)
-    };
-    let field_visitor = Stmts(field_visitor);
-    let fields_stmt = fields_stmt.map(Stmts);
-    let visit_map = Stmts(visit_map);
-
-    let visitor_expr = quote! {
-        __Visitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
-        }
-    };
-    let dispatch = if let Some(deserializer) = deserializer {
-        quote! {
-            _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
-        }
-    } else if is_enum && cattrs.has_flatten() {
-        quote! {
-            _serde::de::VariantAccess::newtype_variant_seed(__variant, #visitor_expr)
-        }
-    } else if is_enum {
-        quote! {
-            _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
-        }
-    } else if cattrs.has_flatten() {
-        quote! {
-            _serde::Deserializer::deserialize_map(__deserializer, #visitor_expr)
-        }
-    } else {
-        let type_name = cattrs.name().deserialize_name();
-        quote! {
-            _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
-        }
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    // untagged struct variants do not get a visit_seq method. The same applies to
-    // structs that only have a map representation.
-    let visit_seq = match *untagged {
-        Untagged::No if !cattrs.has_flatten() => Some(quote! {
-            #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-        }),
-        _ => None,
-    };
-
-    let visitor_seed = if is_enum && cattrs.has_flatten() {
-        Some(quote! {
-            impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
-                type Value = #this #ty_generics;
-
-                fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
-                where
-                    __D: _serde::Deserializer<'de>,
-                {
-                    _serde::Deserializer::deserialize_map(__deserializer, self)
-                }
-            }
-        })
-    } else {
-        None
-    };
-
-    quote_block! {
-        #field_visitor
-
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_seq
-
-            #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                #visit_map
-            }
-        }
-
-        #visitor_seed
-
-        #fields_stmt
-
-        #dispatch
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_struct_in_place(
-    variant_ident: Option<syn::Ident>,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    deserializer: Option<TokenStream>,
-) -> Option<Fragment> {
-    let is_enum = variant_ident.is_some();
-
-    // for now we do not support in_place deserialization for structs that
-    // are represented as map.
-    if cattrs.has_flatten() {
-        return None;
-    }
-
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    let expecting = match variant_ident {
-        Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
-        None => format!("struct {}", params.type_name()),
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
-
-    let (field_visitor, fields_stmt, visit_map) =
-        deserialize_struct_as_struct_in_place_visitor(params, fields, cattrs);
-
-    let field_visitor = Stmts(field_visitor);
-    let fields_stmt = Stmts(fields_stmt);
-    let visit_map = Stmts(visit_map);
-
-    let visitor_expr = quote! {
-        __Visitor {
-            place: __place,
-            lifetime: _serde::__private::PhantomData,
-        }
-    };
-    let dispatch = if let Some(deserializer) = deserializer {
-        quote! {
-            _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
-        }
-    } else if is_enum {
-        quote! {
-            _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
-        }
-    } else {
-        let type_name = cattrs.name().deserialize_name();
-        quote! {
-            _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
-        }
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let visitor_var = if all_skipped {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    let visit_seq = quote! {
-        #[inline]
-        fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-        where
-            __A: _serde::de::SeqAccess<#delife>,
-        {
-            #visit_seq
-        }
-    };
-
-    let in_place_impl_generics = de_impl_generics.in_place();
-    let in_place_ty_generics = de_ty_generics.in_place();
-    let place_life = place_lifetime();
-
-    Some(quote_block! {
-        #field_visitor
-
-        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this #ty_generics,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
-            type Value = ();
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_seq
-
-            #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                #visit_map
-            }
-        }
-
-        #fields_stmt
-
-        #dispatch
-    })
-}
-
-fn deserialize_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    match cattrs.tag() {
-        attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
-        attr::TagType::Internal { tag } => {
-            deserialize_internally_tagged_enum(params, variants, cattrs, tag)
-        }
-        attr::TagType::Adjacent { tag, content } => {
-            deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content)
-        }
-        attr::TagType::None => deserialize_untagged_enum(params, variants, cattrs),
-    }
-}
-
-fn prepare_enum_variant_enum(
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> (TokenStream, Stmts) {
-    let mut deserialized_variants = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing());
-
-    let variant_names_idents: Vec<_> = deserialized_variants
-        .clone()
-        .map(|(i, variant)| {
-            (
-                variant.attrs.name().deserialize_name(),
-                field_i(i),
-                variant.attrs.aliases(),
-            )
-        })
-        .collect();
-
-    let other_idx = deserialized_variants.position(|(_, variant)| variant.attrs.other());
-
-    let variants_stmt = {
-        let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
-        quote! {
-            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
-        }
-    };
-
-    let variant_visitor = Stmts(deserialize_generated_identifier(
-        &variant_names_idents,
-        cattrs,
-        true,
-        other_idx,
-    ));
-
-    (variants_stmt, variant_visitor)
-}
-
-fn deserialize_externally_tagged_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    let type_name = cattrs.name().deserialize_name();
-    let expecting = format!("enum {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
-
-    // Match arms to extract a variant from a string
-    let variant_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_name = field_i(i);
-
-            let block = Match(deserialize_externally_tagged_variant(
-                params, variant, cattrs,
-            ));
-
-            quote! {
-                (__Field::#variant_name, __variant) => #block
-            }
-        });
-
-    let all_skipped = variants
-        .iter()
-        .all(|variant| variant.attrs.skip_deserializing());
-    let match_variant = if all_skipped {
-        // This is an empty enum like `enum Impossible {}` or an enum in which
-        // all variants have `#[serde(skip_deserializing)]`.
-        quote! {
-            // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
-            // _serde::__private::Err(__err)
-            _serde::__private::Result::map(
-                _serde::de::EnumAccess::variant::<__Field>(__data),
-                |(__impossible, _)| match __impossible {})
-        }
-    } else {
-        quote! {
-            match try!(_serde::de::EnumAccess::variant(__data)) {
-                #(#variant_arms)*
-            }
-        }
-    };
-
-    quote_block! {
-        #variant_visitor
-
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            fn visit_enum<__A>(self, __data: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::EnumAccess<#delife>,
-            {
-                #match_variant
-            }
-        }
-
-        #variants_stmt
-
-        _serde::Deserializer::deserialize_enum(
-            __deserializer,
-            #type_name,
-            VARIANTS,
-            __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
-                lifetime: _serde::__private::PhantomData,
-            },
-        )
-    }
-}
-
-fn deserialize_internally_tagged_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-    tag: &str,
-) -> Fragment {
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
-
-    // Match arms to extract a variant from a string
-    let variant_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_name = field_i(i);
-
-            let block = Match(deserialize_internally_tagged_variant(
-                params,
-                variant,
-                cattrs,
-                quote! {
-                    _serde::__private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
-                },
-            ));
-
-            quote! {
-                __Field::#variant_name => #block
-            }
-        });
-
-    let expecting = format!("internally tagged enum {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    quote_block! {
-        #variant_visitor
-
-        #variants_stmt
-
-        let __tagged = try!(_serde::Deserializer::deserialize_any(
-            __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
-
-        match __tagged.tag {
-            #(#variant_arms)*
-        }
-    }
-}
-
-fn deserialize_adjacently_tagged_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-    tag: &str,
-    content: &str,
-) -> Fragment {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
-
-    let variant_arms: &Vec<_> = &variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_index = field_i(i);
-
-            let block = Match(deserialize_untagged_variant(
-                params,
-                variant,
-                cattrs,
-                quote!(__deserializer),
-            ));
-
-            quote! {
-                __Field::#variant_index => #block
-            }
-        })
-        .collect();
-
-    let expecting = format!("adjacently tagged enum {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-    let type_name = cattrs.name().deserialize_name();
-    let deny_unknown_fields = cattrs.deny_unknown_fields();
-
-    // If unknown fields are allowed, we pick the visitor that can step over
-    // those. Otherwise we pick the visitor that fails on unknown keys.
-    let field_visitor_ty = if deny_unknown_fields {
-        quote! { _serde::__private::de::TagOrContentFieldVisitor }
-    } else {
-        quote! { _serde::__private::de::TagContentOtherFieldVisitor }
-    };
-
-    let tag_or_content = quote! {
-        #field_visitor_ty {
-            tag: #tag,
-            content: #content,
-        }
-    };
-
-    let mut missing_content = quote! {
-        _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
-    };
-    let mut missing_content_fallthrough = quote!();
-    let missing_content_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .filter_map(|(i, variant)| {
-            let variant_index = field_i(i);
-            let variant_ident = &variant.ident;
-
-            let arm = match variant.style {
-                Style::Unit => quote! {
-                    _serde::__private::Ok(#this::#variant_ident)
-                },
-                Style::Newtype if variant.attrs.deserialize_with().is_none() => {
-                    let span = variant.original.span();
-                    let func = quote_spanned!(span=> _serde::__private::de::missing_field);
-                    quote! {
-                        #func(#content).map(#this::#variant_ident)
-                    }
-                }
-                _ => {
-                    missing_content_fallthrough = quote!(_ => #missing_content);
-                    return None;
-                }
-            };
-            Some(quote! {
-                __Field::#variant_index => #arm,
-            })
-        })
-        .collect::<Vec<_>>();
-    if !missing_content_arms.is_empty() {
-        missing_content = quote! {
-            match __field {
-                #(#missing_content_arms)*
-                #missing_content_fallthrough
-            }
-        };
-    }
-
-    // Advance the map by one key, returning early in case of error.
-    let next_key = quote! {
-        try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content))
-    };
-
-    // When allowing unknown fields, we want to transparently step through keys
-    // we don't care about until we find `tag`, `content`, or run out of keys.
-    let next_relevant_key = if deny_unknown_fields {
-        next_key
-    } else {
-        quote!({
-            let mut __rk : _serde::__private::Option<_serde::__private::de::TagOrContentField> = _serde::__private::None;
-            while let _serde::__private::Some(__k) = #next_key {
-                match __k {
-                    _serde::__private::de::TagContentOtherField::Other => {
-                        let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
-                        continue;
-                    },
-                    _serde::__private::de::TagContentOtherField::Tag => {
-                        __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag);
-                        break;
-                    }
-                    _serde::__private::de::TagContentOtherField::Content => {
-                        __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Content);
-                        break;
-                    }
-                }
-            }
-
-            __rk
-        })
-    };
-
-    // Step through remaining keys, looking for duplicates of previously-seen
-    // keys. When unknown fields are denied, any key that isn't a duplicate will
-    // at this point immediately produce an error.
-    let visit_remaining_keys = quote! {
-        match #next_relevant_key {
-            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
-            }
-            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
-            }
-            _serde::__private::None => _serde::__private::Ok(__ret),
-        }
-    };
-
-    let finish_content_then_tag = if variant_arms.is_empty() {
-        quote! {
-            match try!(_serde::de::MapAccess::next_value::<__Field>(&mut __map)) {}
-        }
-    } else {
-        quote! {
-            let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) {
-                // Deserialize the buffered content now that we know the variant.
-                #(#variant_arms)*
-            });
-            // Visit remaining keys, looking for duplicates.
-            #visit_remaining_keys
-        }
-    };
-
-    quote_block! {
-        #variant_visitor
-
-        #variants_stmt
-
-        struct __Seed #de_impl_generics #where_clause {
-            field: __Field,
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
-            where
-                __D: _serde::Deserializer<#delife>,
-            {
-                match self.field {
-                    #(#variant_arms)*
-                }
-            }
-        }
-
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                // Visit the first relevant key.
-                match #next_relevant_key {
-                    // First key is the tag.
-                    _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                        // Parse the tag.
-                        let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
-                        // Visit the second key.
-                        match #next_relevant_key {
-                            // Second key is a duplicate of the tag.
-                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
-                            }
-                            // Second key is the content.
-                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                                let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
-                                    __Seed {
-                                        field: __field,
-                                        marker: _serde::__private::PhantomData,
-                                        lifetime: _serde::__private::PhantomData,
-                                    }));
-                                // Visit remaining keys, looking for duplicates.
-                                #visit_remaining_keys
-                            }
-                            // There is no second key; might be okay if the we have a unit variant.
-                            _serde::__private::None => #missing_content
-                        }
-                    }
-                    // First key is the content.
-                    _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                        // Buffer up the content.
-                        let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map));
-                        // Visit the second key.
-                        match #next_relevant_key {
-                            // Second key is the tag.
-                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                                let __deserializer = _serde::__private::de::ContentDeserializer::<__A::Error>::new(__content);
-                                #finish_content_then_tag
-                            }
-                            // Second key is a duplicate of the content.
-                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
-                            }
-                            // There is no second key.
-                            _serde::__private::None => {
-                                _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
-                            }
-                        }
-                    }
-                    // There is no first key.
-                    _serde::__private::None => {
-                        _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
-                    }
-                }
-            }
-
-            fn visit_seq<__A>(self, mut __seq: __A) -> _serde::__private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                // Visit the first element - the tag.
-                match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
-                    _serde::__private::Some(__field) => {
-                        // Visit the second element - the content.
-                        match try!(_serde::de::SeqAccess::next_element_seed(
-                            &mut __seq,
-                            __Seed {
-                                field: __field,
-                                marker: _serde::__private::PhantomData,
-                                lifetime: _serde::__private::PhantomData,
-                            },
-                        )) {
-                            _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
-                            // There is no second element.
-                            _serde::__private::None => {
-                                _serde::__private::Err(_serde::de::Error::invalid_length(1, &self))
-                            }
-                        }
-                    }
-                    // There is no first element.
-                    _serde::__private::None => {
-                        _serde::__private::Err(_serde::de::Error::invalid_length(0, &self))
-                    }
-                }
-            }
-        }
-
-        const FIELDS: &'static [&'static str] = &[#tag, #content];
-        _serde::Deserializer::deserialize_struct(
-            __deserializer,
-            #type_name,
-            FIELDS,
-            __Visitor {
-                marker: _serde::__private::PhantomData::<#this #ty_generics>,
-                lifetime: _serde::__private::PhantomData,
-            },
-        )
-    }
-}
-
-fn deserialize_untagged_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let attempts = variants
-        .iter()
-        .filter(|variant| !variant.attrs.skip_deserializing())
-        .map(|variant| {
-            Expr(deserialize_untagged_variant(
-                params,
-                variant,
-                cattrs,
-                quote!(
-                    _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content)
-                ),
-            ))
-        });
-
-    // TODO this message could be better by saving the errors from the failed
-    // attempts. The heuristic used by TOML was to count the number of fields
-    // processed before an error, and use the error that happened after the
-    // largest number of fields. I'm not sure I like that. Maybe it would be
-    // better to save all the errors and combine them into one message that
-    // explains why none of the variants matched.
-    let fallthrough_msg = format!(
-        "data did not match any variant of untagged enum {}",
-        params.type_name()
-    );
-    let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
-
-    quote_block! {
-        let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
-
-        #(
-            if let _serde::__private::Ok(__ok) = #attempts {
-                return _serde::__private::Ok(__ok);
-            }
-        )*
-
-        _serde::__private::Err(_serde::de::Error::custom(#fallthrough_msg))
-    }
-}
-
-fn deserialize_externally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-) -> Fragment {
-    if let Some(path) = variant.attrs.deserialize_with() {
-        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
-        return quote_block! {
-            #wrapper
-            _serde::__private::Result::map(
-                _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
-        };
-    }
-
-    let variant_ident = &variant.ident;
-
-    match variant.style {
-        Style::Unit => {
-            let this = &params.this;
-            quote_block! {
-                try!(_serde::de::VariantAccess::unit_variant(__variant));
-                _serde::__private::Ok(#this::#variant_ident)
-            }
-        }
-        Style::Newtype => deserialize_externally_tagged_newtype_variant(
-            variant_ident,
-            params,
-            &variant.fields[0],
-            cattrs,
-        ),
-        Style::Tuple => {
-            deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
-        }
-        Style::Struct => deserialize_struct(
-            Some(variant_ident),
-            params,
-            &variant.fields,
-            cattrs,
-            None,
-            &Untagged::No,
-        ),
-    }
-}
-
-// Generates significant part of the visit_seq and visit_map bodies of visitors
-// for the variants of internally tagged enum.
-fn deserialize_internally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-    deserializer: TokenStream,
-) -> Fragment {
-    if variant.attrs.deserialize_with().is_some() {
-        return deserialize_untagged_variant(params, variant, cattrs, deserializer);
-    }
-
-    let variant_ident = &variant.ident;
-
-    match effective_style(variant) {
-        Style::Unit => {
-            let this = &params.this;
-            let type_name = params.type_name();
-            let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
-                let default = Expr(expr_is_missing(field, cattrs));
-                quote!((#default))
-            });
-            quote_block! {
-                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::__private::Ok(#this::#variant_ident #default)
-            }
-        }
-        Style::Newtype => deserialize_untagged_newtype_variant(
-            variant_ident,
-            params,
-            &variant.fields[0],
-            &deserializer,
-        ),
-        Style::Struct => deserialize_struct(
-            Some(variant_ident),
-            params,
-            &variant.fields,
-            cattrs,
-            Some(deserializer),
-            &Untagged::No,
-        ),
-        Style::Tuple => unreachable!("checked in serde_derive_internals"),
-    }
-}
-
-fn deserialize_untagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-    deserializer: TokenStream,
-) -> Fragment {
-    if let Some(path) = variant.attrs.deserialize_with() {
-        let unwrap_fn = unwrap_to_variant_closure(params, variant, false);
-        return quote_block! {
-            _serde::__private::Result::map(#path(#deserializer), #unwrap_fn)
-        };
-    }
-
-    let variant_ident = &variant.ident;
-
-    match effective_style(variant) {
-        Style::Unit => {
-            let this = &params.this;
-            let type_name = params.type_name();
-            let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
-                let default = Expr(expr_is_missing(field, cattrs));
-                quote!((#default))
-            });
-            quote_expr! {
-                match _serde::Deserializer::deserialize_any(
-                    #deserializer,
-                    _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
-                ) {
-                    _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
-                    _serde::__private::Err(__err) => _serde::__private::Err(__err),
-                }
-            }
-        }
-        Style::Newtype => deserialize_untagged_newtype_variant(
-            variant_ident,
-            params,
-            &variant.fields[0],
-            &deserializer,
-        ),
-        Style::Tuple => deserialize_tuple(
-            Some(variant_ident),
-            params,
-            &variant.fields,
-            cattrs,
-            Some(deserializer),
-        ),
-        Style::Struct => deserialize_struct(
-            Some(variant_ident),
-            params,
-            &variant.fields,
-            cattrs,
-            Some(deserializer),
-            &Untagged::Yes,
-        ),
-    }
-}
-
-fn deserialize_externally_tagged_newtype_variant(
-    variant_ident: &syn::Ident,
-    params: &Parameters,
-    field: &Field,
-    cattrs: &attr::Container,
-) -> Fragment {
-    let this = &params.this;
-
-    if field.attrs.skip_deserializing() {
-        let this = &params.this;
-        let default = Expr(expr_is_missing(field, cattrs));
-        return quote_block! {
-            try!(_serde::de::VariantAccess::unit_variant(__variant));
-            _serde::__private::Ok(#this::#variant_ident(#default))
-        };
-    }
-
-    match field.attrs.deserialize_with() {
-        None => {
-            let field_ty = field.ty;
-            let span = field.original.span();
-            let func =
-                quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
-            quote_expr! {
-                _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
-            }
-        }
-        Some(path) => {
-            let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-            quote_block! {
-                #wrapper
-                _serde::__private::Result::map(
-                    _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
-                    |__wrapper| #this::#variant_ident(__wrapper.value))
-            }
-        }
-    }
-}
-
-fn deserialize_untagged_newtype_variant(
-    variant_ident: &syn::Ident,
-    params: &Parameters,
-    field: &Field,
-    deserializer: &TokenStream,
-) -> Fragment {
-    let this = &params.this;
-    let field_ty = field.ty;
-    match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
-            quote_expr! {
-                _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
-            }
-        }
-        Some(path) => {
-            quote_block! {
-                let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
-                _serde::__private::Result::map(__value, #this::#variant_ident)
-            }
-        }
-    }
-}
-
-fn deserialize_generated_identifier(
-    fields: &[(String, Ident, Vec<String>)],
-    cattrs: &attr::Container,
-    is_variant: bool,
-    other_idx: Option<usize>,
-) -> Fragment {
-    let this = quote!(__Field);
-    let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
-
-    let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
-        let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
-        let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
-        (Some(ignore_variant), Some(fallthrough))
-    } else if let Some(other_idx) = other_idx {
-        let ignore_variant = fields[other_idx].1.clone();
-        let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant));
-        (None, Some(fallthrough))
-    } else if is_variant || cattrs.deny_unknown_fields() {
-        (None, None)
-    } else {
-        let ignore_variant = quote!(__ignore,);
-        let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
-        (Some(ignore_variant), Some(fallthrough))
-    };
-
-    let visitor_impl = Stmts(deserialize_identifier(
-        &this,
-        fields,
-        is_variant,
-        fallthrough,
-        None,
-        !is_variant && cattrs.has_flatten(),
-        None,
-    ));
-
-    let lifetime = if !is_variant && cattrs.has_flatten() {
-        Some(quote!(<'de>))
-    } else {
-        None
-    };
-
-    quote_block! {
-        #[allow(non_camel_case_types)]
-        enum __Field #lifetime {
-            #(#field_idents,)*
-            #ignore_variant
-        }
-
-        struct __FieldVisitor;
-
-        impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-            type Value = __Field #lifetime;
-
-            #visitor_impl
-        }
-
-        impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
-            #[inline]
-            fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
-            where
-                __D: _serde::Deserializer<'de>,
-            {
-                _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
-            }
-        }
-    }
-}
-
-// Generates `Deserialize::deserialize` body for an enum with
-// `serde(field_identifier)` or `serde(variant_identifier)` attribute.
-fn deserialize_custom_identifier(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let is_variant = match cattrs.identifier() {
-        attr::Identifier::Variant => true,
-        attr::Identifier::Field => false,
-        attr::Identifier::No => unreachable!(),
-    };
-
-    let this = &params.this;
-    let this = quote!(#this);
-
-    let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
-        let last_ident = &last.ident;
-        if last.attrs.other() {
-            // Process `serde(other)` attribute. It would always be found on the
-            // last variant (checked in `check_identifier`), so all preceding
-            // are ordinary variants.
-            let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
-            (ordinary, Some(fallthrough), None)
-        } else if let Style::Newtype = last.style {
-            let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = |value| {
-                quote! {
-                    _serde::__private::Result::map(
-                        _serde::Deserialize::deserialize(
-                            _serde::__private::de::IdentifierDeserializer::from(#value)
-                        ),
-                        #this::#last_ident)
-                }
-            };
-            (
-                ordinary,
-                Some(fallthrough(quote!(__value))),
-                Some(fallthrough(quote!(_serde::__private::de::Borrowed(
-                    __value
-                )))),
-            )
-        } else {
-            (variants, None, None)
-        }
-    } else {
-        (variants, None, None)
-    };
-
-    let names_idents: Vec<_> = ordinary
-        .iter()
-        .map(|variant| {
-            (
-                variant.attrs.name().deserialize_name(),
-                variant.ident.clone(),
-                variant.attrs.aliases(),
-            )
-        })
-        .collect();
-
-    let names = names_idents.iter().map(|(name, _, _)| name);
-
-    let names_const = if fallthrough.is_some() {
-        None
-    } else if is_variant {
-        let variants = quote! {
-            const VARIANTS: &'static [&'static str] = &[ #(#names),* ];
-        };
-        Some(variants)
-    } else {
-        let fields = quote! {
-            const FIELDS: &'static [&'static str] = &[ #(#names),* ];
-        };
-        Some(fields)
-    };
-
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-    let visitor_impl = Stmts(deserialize_identifier(
-        &this,
-        &names_idents,
-        is_variant,
-        fallthrough,
-        fallthrough_borrowed,
-        false,
-        cattrs.expecting(),
-    ));
-
-    quote_block! {
-        #names_const
-
-        struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
-            type Value = #this #ty_generics;
-
-            #visitor_impl
-        }
-
-        let __visitor = __FieldVisitor {
-            marker: _serde::__private::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
-        };
-        _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
-    }
-}
-
-fn deserialize_identifier(
-    this: &TokenStream,
-    fields: &[(String, Ident, Vec<String>)],
-    is_variant: bool,
-    fallthrough: Option<TokenStream>,
-    fallthrough_borrowed: Option<TokenStream>,
-    collect_other_fields: bool,
-    expecting: Option<&str>,
-) -> Fragment {
-    let mut flat_fields = Vec::new();
-    for (_, ident, aliases) in fields {
-        flat_fields.extend(aliases.iter().map(|alias| (alias, ident)));
-    }
-
-    let field_strs: &Vec<_> = &flat_fields.iter().map(|(name, _)| name).collect();
-    let field_bytes: &Vec<_> = &flat_fields
-        .iter()
-        .map(|(name, _)| Literal::byte_string(name.as_bytes()))
-        .collect();
-
-    let constructors: &Vec<_> = &flat_fields
-        .iter()
-        .map(|(_, ident)| quote!(#this::#ident))
-        .collect();
-    let main_constructors: &Vec<_> = &fields
-        .iter()
-        .map(|(_, ident, _)| quote!(#this::#ident))
-        .collect();
-
-    let expecting = expecting.unwrap_or(if is_variant {
-        "variant identifier"
-    } else {
-        "field identifier"
-    });
-
-    let index_expecting = if is_variant { "variant" } else { "field" };
-
-    let bytes_to_str = if fallthrough.is_some() || collect_other_fields {
-        None
-    } else {
-        Some(quote! {
-            let __value = &_serde::__private::from_utf8_lossy(__value);
-        })
-    };
-
-    let (
-        value_as_str_content,
-        value_as_borrowed_str_content,
-        value_as_bytes_content,
-        value_as_borrowed_bytes_content,
-    ) = if collect_other_fields {
-        (
-            Some(quote! {
-                let __value = _serde::__private::de::Content::String(_serde::__private::ToString::to_string(__value));
-            }),
-            Some(quote! {
-                let __value = _serde::__private::de::Content::Str(__value);
-            }),
-            Some(quote! {
-                let __value = _serde::__private::de::Content::ByteBuf(__value.to_vec());
-            }),
-            Some(quote! {
-                let __value = _serde::__private::de::Content::Bytes(__value);
-            }),
-        )
-    } else {
-        (None, None, None, None)
-    };
-
-    let fallthrough_arm_tokens;
-    let fallthrough_arm = if let Some(fallthrough) = &fallthrough {
-        fallthrough
-    } else if is_variant {
-        fallthrough_arm_tokens = quote! {
-            _serde::__private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
-        };
-        &fallthrough_arm_tokens
-    } else {
-        fallthrough_arm_tokens = quote! {
-            _serde::__private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
-        };
-        &fallthrough_arm_tokens
-    };
-
-    let u64_fallthrough_arm_tokens;
-    let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough {
-        fallthrough
-    } else {
-        let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
-        u64_fallthrough_arm_tokens = quote! {
-            _serde::__private::Err(_serde::de::Error::invalid_value(
-                _serde::de::Unexpected::Unsigned(__value),
-                &#fallthrough_msg,
-            ))
-        };
-        &u64_fallthrough_arm_tokens
-    };
-
-    let variant_indices = 0_u64..;
-    let visit_other = if collect_other_fields {
-        quote! {
-            fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Bool(__value)))
-            }
-
-            fn visit_i8<__E>(self, __value: i8) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I8(__value)))
-            }
-
-            fn visit_i16<__E>(self, __value: i16) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I16(__value)))
-            }
-
-            fn visit_i32<__E>(self, __value: i32) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I32(__value)))
-            }
-
-            fn visit_i64<__E>(self, __value: i64) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I64(__value)))
-            }
-
-            fn visit_u8<__E>(self, __value: u8) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U8(__value)))
-            }
-
-            fn visit_u16<__E>(self, __value: u16) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U16(__value)))
-            }
-
-            fn visit_u32<__E>(self, __value: u32) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U32(__value)))
-            }
-
-            fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U64(__value)))
-            }
-
-            fn visit_f32<__E>(self, __value: f32) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F32(__value)))
-            }
-
-            fn visit_f64<__E>(self, __value: f64) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F64(__value)))
-            }
-
-            fn visit_char<__E>(self, __value: char) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Char(__value)))
-            }
-
-            fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Unit))
-            }
-        }
-    } else {
-        quote! {
-            fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(
-                        #variant_indices => _serde::__private::Ok(#main_constructors),
-                    )*
-                    _ => #u64_fallthrough_arm,
-                }
-            }
-        }
-    };
-
-    let visit_borrowed = if fallthrough_borrowed.is_some() || collect_other_fields {
-        let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(fallthrough_arm);
-        Some(quote! {
-            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(
-                        #field_strs => _serde::__private::Ok(#constructors),
-                    )*
-                    _ => {
-                        #value_as_borrowed_str_content
-                        #fallthrough_borrowed_arm
-                    }
-                }
-            }
-
-            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(
-                        #field_bytes => _serde::__private::Ok(#constructors),
-                    )*
-                    _ => {
-                        #bytes_to_str
-                        #value_as_borrowed_bytes_content
-                        #fallthrough_borrowed_arm
-                    }
-                }
-            }
-        })
-    } else {
-        None
-    };
-
-    quote_block! {
-        fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-            _serde::__private::Formatter::write_str(__formatter, #expecting)
-        }
-
-        #visit_other
-
-        fn visit_str<__E>(self, __value: &str) -> _serde::__private::Result<Self::Value, __E>
-        where
-            __E: _serde::de::Error,
-        {
-            match __value {
-                #(
-                    #field_strs => _serde::__private::Ok(#constructors),
-                )*
-                _ => {
-                    #value_as_str_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
-        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::__private::Result<Self::Value, __E>
-        where
-            __E: _serde::de::Error,
-        {
-            match __value {
-                #(
-                    #field_bytes => _serde::__private::Ok(#constructors),
-                )*
-                _ => {
-                    #bytes_to_str
-                    #value_as_bytes_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
-        #visit_borrowed
-    }
-}
-
-fn deserialize_struct_as_struct_visitor(
-    struct_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> (Fragment, Option<Fragment>, Fragment) {
-    assert!(!cattrs.has_flatten());
-
-    let field_names_idents: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .filter(|&(_, field)| !field.attrs.skip_deserializing())
-        .map(|(i, field)| {
-            (
-                field.attrs.name().deserialize_name(),
-                field_i(i),
-                field.attrs.aliases(),
-            )
-        })
-        .collect();
-
-    let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
-        quote_block! {
-            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
-        }
-    };
-
-    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
-
-    let visit_map = deserialize_map(struct_path, params, fields, cattrs);
-
-    (field_visitor, Some(fields_stmt), visit_map)
-}
-
-fn deserialize_struct_as_map_visitor(
-    struct_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> (Fragment, Option<Fragment>, Fragment) {
-    let field_names_idents: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .filter(|&(_, field)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(i, field)| {
-            (
-                field.attrs.name().deserialize_name(),
-                field_i(i),
-                field.attrs.aliases(),
-            )
-        })
-        .collect();
-
-    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
-
-    let visit_map = deserialize_map(struct_path, params, fields, cattrs);
-
-    (field_visitor, None, visit_map)
-}
-
-fn deserialize_map(
-    struct_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    // Create the field names for the fields.
-    let fields_names: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| (field, field_i(i)))
-        .collect();
-
-    // Declare each field that will be deserialized.
-    let let_values = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let field_ty = field.ty;
-            quote! {
-                let mut #name: _serde::__private::Option<#field_ty> = _serde::__private::None;
-            }
-        });
-
-    // Collect contents for flatten fields into a buffer
-    let let_collect = if cattrs.has_flatten() {
-        Some(quote! {
-            let mut __collect = _serde::__private::Vec::<_serde::__private::Option<(
-                _serde::__private::de::Content,
-                _serde::__private::de::Content
-            )>>::new();
-        })
-    } else {
-        None
-    };
-
-    // Match arms to extract a value for a field.
-    let value_arms = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let deser_name = field.attrs.name().deserialize_name();
-
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    let field_ty = field.ty;
-                    let span = field.original.span();
-                    let func =
-                        quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
-                    quote! {
-                        try!(#func(&mut __map))
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::__private::Ok(__wrapper) => __wrapper.value,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        }
-                    })
-                }
-            };
-            quote! {
-                __Field::#name => {
-                    if _serde::__private::Option::is_some(&#name) {
-                        return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
-                    }
-                    #name = _serde::__private::Some(#visit);
-                }
-            }
-        });
-
-    // Visit ignored values to consume them
-    let ignored_arm = if cattrs.has_flatten() {
-        Some(quote! {
-            __Field::__other(__name) => {
-                __collect.push(_serde::__private::Some((
-                    __name,
-                    try!(_serde::de::MapAccess::next_value(&mut __map)))));
-            }
-        })
-    } else if cattrs.deny_unknown_fields() {
-        None
-    } else {
-        Some(quote! {
-            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
-        })
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
-        quote! {
-            // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
-            _serde::__private::Option::map(
-                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
-                |__impossible| match __impossible {});
-        }
-    } else {
-        quote! {
-            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
-                match __key {
-                    #(#value_arms)*
-                    #ignored_arm
-                }
-            }
-        }
-    };
-
-    let extract_values = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let missing_expr = Match(expr_is_missing(field, cattrs));
-
-            quote! {
-                let #name = match #name {
-                    _serde::__private::Some(#name) => #name,
-                    _serde::__private::None => #missing_expr
-                };
-            }
-        });
-
-    let extract_collected = fields_names
-        .iter()
-        .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let field_ty = field.ty;
-            let func = match field.attrs.deserialize_with() {
-                None => {
-                    let span = field.original.span();
-                    quote_spanned!(span=> _serde::de::Deserialize::deserialize)
-                }
-                Some(path) => quote!(#path),
-            };
-            quote! {
-                let #name: #field_ty = try!(#func(
-                    _serde::__private::de::FlatMapDeserializer(
-                        &mut __collect,
-                        _serde::__private::PhantomData)));
-            }
-        });
-
-    let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
-        Some(quote! {
-            if let _serde::__private::Some(_serde::__private::Some((__key, _))) =
-                __collect.into_iter().filter(_serde::__private::Option::is_some).next()
-            {
-                if let _serde::__private::Some(__key) = __key.as_str() {
-                    return _serde::__private::Err(
-                        _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
-                } else {
-                    return _serde::__private::Err(
-                        _serde::de::Error::custom(format_args!("unexpected map key")));
-                }
-            }
-        })
-    } else {
-        None
-    };
-
-    let result = fields_names.iter().map(|(field, name)| {
-        let member = &field.member;
-        if field.attrs.skip_deserializing() {
-            let value = Expr(expr_is_missing(field, cattrs));
-            quote!(#member: #value)
-        } else {
-            quote!(#member: #name)
-        }
-    });
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::__private::Default::default();
-        )),
-        attr::Default::Path(path) => Some(quote!(
-            let __default: Self::Value = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    let mut result = quote!(#struct_path { #(#result),* });
-    if params.has_getter {
-        let this = &params.this;
-        result = quote! {
-            _serde::__private::Into::<#this>::into(#result)
-        };
-    }
-
-    quote_block! {
-        #(#let_values)*
-
-        #let_collect
-
-        #match_keys
-
-        #let_default
-
-        #(#extract_values)*
-
-        #(#extract_collected)*
-
-        #collected_deny_unknown_fields
-
-        _serde::__private::Ok(#result)
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_struct_as_struct_in_place_visitor(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> (Fragment, Fragment, Fragment) {
-    assert!(!cattrs.has_flatten());
-
-    let field_names_idents: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .filter(|&(_, field)| !field.attrs.skip_deserializing())
-        .map(|(i, field)| {
-            (
-                field.attrs.name().deserialize_name(),
-                field_i(i),
-                field.attrs.aliases(),
-            )
-        })
-        .collect();
-
-    let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
-        quote_block! {
-            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
-        }
-    };
-
-    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
-
-    let visit_map = deserialize_map_in_place(params, fields, cattrs);
-
-    (field_visitor, fields_stmt, visit_map)
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_map_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    assert!(!cattrs.has_flatten());
-
-    // Create the field names for the fields.
-    let fields_names: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| (field, field_i(i)))
-        .collect();
-
-    // For deserialize_in_place, declare booleans for each field that will be
-    // deserialized.
-    let let_flags = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(_, name)| {
-            quote! {
-                let mut #name: bool = false;
-            }
-        });
-
-    // Match arms to extract a value for a field.
-    let value_arms_from = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let deser_name = field.attrs.name().deserialize_name();
-            let member = &field.member;
-
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    quote! {
-                        try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::__private::Ok(__wrapper) => __wrapper.value,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
-                            }
-                        };
-                    })
-                }
-            };
-            quote! {
-                __Field::#name => {
-                    if #name {
-                        return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
-                    }
-                    #visit;
-                    #name = true;
-                }
-            }
-        });
-
-    // Visit ignored values to consume them
-    let ignored_arm = if cattrs.deny_unknown_fields() {
-        None
-    } else {
-        Some(quote! {
-            _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); }
-        })
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-
-    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
-        quote! {
-            // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
-            _serde::__private::Option::map(
-                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
-                |__impossible| match __impossible {});
-        }
-    } else {
-        quote! {
-            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
-                match __key {
-                    #(#value_arms_from)*
-                    #ignored_arm
-                }
-            }
-        }
-    };
-
-    let check_flags = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let missing_expr = expr_is_missing(field, cattrs);
-            // If missing_expr unconditionally returns an error, don't try
-            // to assign its value to self.place.
-            if field.attrs.default().is_none()
-                && cattrs.default().is_none()
-                && field.attrs.deserialize_with().is_some()
-            {
-                let missing_expr = Stmts(missing_expr);
-                quote! {
-                    if !#name {
-                        #missing_expr;
-                    }
-                }
-            } else {
-                let member = &field.member;
-                let missing_expr = Expr(missing_expr);
-                quote! {
-                    if !#name {
-                        self.place.#member = #missing_expr;
-                    };
-                }
-            }
-        });
-
-    let this = &params.this;
-    let (_, _, ty_generics, _) = split_with_de_lifetime(params);
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics = _serde::__private::Default::default();
-        )),
-        attr::Default::Path(path) => Some(quote!(
-            let __default: #this #ty_generics = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #(#let_flags)*
-
-        #match_keys
-
-        #let_default
-
-        #(#check_flags)*
-
-        _serde::__private::Ok(())
-    }
-}
-
-fn field_i(i: usize) -> Ident {
-    Ident::new(&format!("__field{}", i), Span::call_site())
-}
-
-/// This function wraps the expression in `#[serde(deserialize_with = "...")]`
-/// in a trait to prevent it from accessing the internal `Deserialize` state.
-fn wrap_deserialize_with(
-    params: &Parameters,
-    value_ty: &TokenStream,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream) {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    let wrapper = quote! {
-        struct __DeserializeWith #de_impl_generics #where_clause {
-            value: #value_ty,
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
-        }
-
-        impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
-            fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
-            where
-                __D: _serde::Deserializer<#delife>,
-            {
-                _serde::__private::Ok(__DeserializeWith {
-                    value: try!(#deserialize_with(__deserializer)),
-                    phantom: _serde::__private::PhantomData,
-                    lifetime: _serde::__private::PhantomData,
-                })
-            }
-        }
-    };
-
-    let wrapper_ty = quote!(__DeserializeWith #de_ty_generics);
-
-    (wrapper, wrapper_ty)
-}
-
-fn wrap_deserialize_field_with(
-    params: &Parameters,
-    field_ty: &syn::Type,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream) {
-    wrap_deserialize_with(params, &quote!(#field_ty), deserialize_with)
-}
-
-fn wrap_deserialize_variant_with(
-    params: &Parameters,
-    variant: &Variant,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream, TokenStream) {
-    let field_tys = variant.fields.iter().map(|field| field.ty);
-    let (wrapper, wrapper_ty) =
-        wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
-
-    let unwrap_fn = unwrap_to_variant_closure(params, variant, true);
-
-    (wrapper, wrapper_ty, unwrap_fn)
-}
-
-// Generates closure that converts single input parameter to the final value.
-fn unwrap_to_variant_closure(
-    params: &Parameters,
-    variant: &Variant,
-    with_wrapper: bool,
-) -> TokenStream {
-    let this = &params.this;
-    let variant_ident = &variant.ident;
-
-    let (arg, wrapper) = if with_wrapper {
-        (quote! { __wrap }, quote! { __wrap.value })
-    } else {
-        let field_tys = variant.fields.iter().map(|field| field.ty);
-        (quote! { __wrap: (#(#field_tys),*) }, quote! { __wrap })
-    };
-
-    let field_access = (0..variant.fields.len()).map(|n| {
-        Member::Unnamed(Index {
-            index: n as u32,
-            span: Span::call_site(),
-        })
-    });
-
-    match variant.style {
-        Style::Struct if variant.fields.len() == 1 => {
-            let member = &variant.fields[0].member;
-            quote! {
-                |#arg| #this::#variant_ident { #member: #wrapper }
-            }
-        }
-        Style::Struct => {
-            let members = variant.fields.iter().map(|field| &field.member);
-            quote! {
-                |#arg| #this::#variant_ident { #(#members: #wrapper.#field_access),* }
-            }
-        }
-        Style::Tuple => quote! {
-            |#arg| #this::#variant_ident(#(#wrapper.#field_access),*)
-        },
-        Style::Newtype => quote! {
-            |#arg| #this::#variant_ident(#wrapper)
-        },
-        Style::Unit => quote! {
-            |#arg| #this::#variant_ident
-        },
-    }
-}
-
-fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
-    match field.attrs.default() {
-        attr::Default::Default => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::__private::Default::default);
-            return quote_expr!(#func());
-        }
-        attr::Default::Path(path) => {
-            return quote_expr!(#path());
-        }
-        attr::Default::None => { /* below */ }
-    }
-
-    match *cattrs.default() {
-        attr::Default::Default | attr::Default::Path(_) => {
-            let member = &field.member;
-            return quote_expr!(__default.#member);
-        }
-        attr::Default::None => { /* below */ }
-    }
-
-    let name = field.attrs.name().deserialize_name();
-    match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::__private::de::missing_field);
-            quote_expr! {
-                try!(#func(#name))
-            }
-        }
-        Some(_) => {
-            quote_expr! {
-                return _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
-            }
-        }
-    }
-}
-
-fn effective_style(variant: &Variant) -> Style {
-    match variant.style {
-        Style::Newtype if variant.fields[0].attrs.skip_deserializing() => Style::Unit,
-        other => other,
-    }
-}
-
-struct DeImplGenerics<'a>(&'a Parameters);
-#[cfg(feature = "deserialize_in_place")]
-struct InPlaceImplGenerics<'a>(&'a Parameters);
-
-impl<'a> ToTokens for DeImplGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
-            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (impl_generics, _, _) = generics.split_for_impl();
-        impl_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> ToTokens for InPlaceImplGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let place_lifetime = place_lifetime();
-        let mut generics = self.0.generics.clone();
-
-        // Add lifetime for `&'place mut Self, and `'a: 'place`
-        for param in &mut generics.params {
-            match param {
-                syn::GenericParam::Lifetime(param) => {
-                    param.bounds.push(place_lifetime.lifetime.clone());
-                }
-                syn::GenericParam::Type(param) => {
-                    param.bounds.push(syn::TypeParamBound::Lifetime(
-                        place_lifetime.lifetime.clone(),
-                    ));
-                }
-                syn::GenericParam::Const(_) => {}
-            }
-        }
-        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime))
-            .into_iter()
-            .chain(generics.params)
-            .collect();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
-            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (impl_generics, _, _) = generics.split_for_impl();
-        impl_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> DeImplGenerics<'a> {
-    fn in_place(self) -> InPlaceImplGenerics<'a> {
-        InPlaceImplGenerics(self.0)
-    }
-}
-
-struct DeTypeGenerics<'a>(&'a Parameters);
-#[cfg(feature = "deserialize_in_place")]
-struct InPlaceTypeGenerics<'a>(&'a Parameters);
-
-impl<'a> ToTokens for DeTypeGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: Punctuated::new(),
-            };
-            generics.params = Some(syn::GenericParam::Lifetime(def))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (_, ty_generics, _) = generics.split_for_impl();
-        ty_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime()))
-            .into_iter()
-            .chain(generics.params)
-            .collect();
-
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: Punctuated::new(),
-            };
-            generics.params = Some(syn::GenericParam::Lifetime(def))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (_, ty_generics, _) = generics.split_for_impl();
-        ty_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> DeTypeGenerics<'a> {
-    fn in_place(self) -> InPlaceTypeGenerics<'a> {
-        InPlaceTypeGenerics(self.0)
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn place_lifetime() -> syn::LifetimeDef {
-    syn::LifetimeDef {
-        attrs: Vec::new(),
-        lifetime: syn::Lifetime::new("'place", Span::call_site()),
-        colon_token: None,
-        bounds: Punctuated::new(),
-    }
-}
-
-fn split_with_de_lifetime(
-    params: &Parameters,
-) -> (
-    DeImplGenerics,
-    DeTypeGenerics,
-    syn::TypeGenerics,
-    Option<&syn::WhereClause>,
-) {
-    let de_impl_generics = DeImplGenerics(params);
-    let de_ty_generics = DeTypeGenerics(params);
-    let (_, ty_generics, where_clause) = params.generics.split_for_impl();
-    (de_impl_generics, de_ty_generics, ty_generics, where_clause)
-}
diff --git a/vendor/serde_derive/src/dummy.rs b/vendor/serde_derive/src/dummy.rs
deleted file mode 100644
index 29de2601..00000000
--- a/vendor/serde_derive/src/dummy.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use proc_macro2::{Ident, TokenStream};
-use quote::format_ident;
-
-use syn;
-use try;
-
-pub fn wrap_in_const(
-    serde_path: Option<&syn::Path>,
-    trait_: &str,
-    ty: &Ident,
-    code: TokenStream,
-) -> TokenStream {
-    let try_replacement = try::replacement();
-
-    let dummy_const = if cfg!(underscore_consts) {
-        format_ident!("_")
-    } else {
-        format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
-    };
-
-    let use_serde = match serde_path {
-        Some(path) => quote! {
-            use #path as _serde;
-        },
-        None => quote! {
-            #[allow(unused_extern_crates, clippy::useless_attribute)]
-            extern crate serde as _serde;
-        },
-    };
-
-    quote! {
-        #[doc(hidden)]
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
-            #use_serde
-            #try_replacement
-            #code
-        };
-    }
-}
-
-#[allow(deprecated)]
-fn unraw(ident: &Ident) -> String {
-    // str::trim_start_matches was added in 1.30, trim_left_matches deprecated
-    // in 1.33. We currently support rustc back to 1.15 so we need to continue
-    // to use the deprecated one.
-    ident.to_string().trim_left_matches("r#").to_owned()
-}
diff --git a/vendor/serde_derive/src/fragment.rs b/vendor/serde_derive/src/fragment.rs
deleted file mode 100644
index 324504aa..00000000
--- a/vendor/serde_derive/src/fragment.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-use syn::token;
-
-pub enum Fragment {
-    /// Tokens that can be used as an expression.
-    Expr(TokenStream),
-    /// Tokens that can be used inside a block. The surrounding curly braces are
-    /// not part of these tokens.
-    Block(TokenStream),
-}
-
-macro_rules! quote_expr {
-    ($($tt:tt)*) => {
-        $crate::fragment::Fragment::Expr(quote!($($tt)*))
-    }
-}
-
-macro_rules! quote_block {
-    ($($tt:tt)*) => {
-        $crate::fragment::Fragment::Block(quote!($($tt)*))
-    }
-}
-
-/// Interpolate a fragment in place of an expression. This involves surrounding
-/// Block fragments in curly braces.
-pub struct Expr(pub Fragment);
-impl ToTokens for Expr {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => expr.to_tokens(out),
-            Fragment::Block(block) => {
-                token::Brace::default().surround(out, |out| block.to_tokens(out));
-            }
-        }
-    }
-}
-
-/// Interpolate a fragment as the statements of a block.
-pub struct Stmts(pub Fragment);
-impl ToTokens for Stmts {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => expr.to_tokens(out),
-            Fragment::Block(block) => block.to_tokens(out),
-        }
-    }
-}
-
-/// Interpolate a fragment as the value part of a `match` expression. This
-/// involves putting a comma after expressions and curly braces around blocks.
-pub struct Match(pub Fragment);
-impl ToTokens for Match {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => {
-                expr.to_tokens(out);
-                <Token![,]>::default().to_tokens(out);
-            }
-            Fragment::Block(block) => {
-                token::Brace::default().surround(out, |out| block.to_tokens(out));
-            }
-        }
-    }
-}
-
-impl AsRef<TokenStream> for Fragment {
-    fn as_ref(&self) -> &TokenStream {
-        match self {
-            Fragment::Expr(expr) => expr,
-            Fragment::Block(block) => block,
-        }
-    }
-}
diff --git a/vendor/serde_derive/src/internals/ast.rs b/vendor/serde_derive/src/internals/ast.rs
deleted file mode 100644
index 2a6950b2..00000000
--- a/vendor/serde_derive/src/internals/ast.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-//! A Serde ast, parsed from the Syn ast and ready to generate Rust code.
-
-use internals::attr;
-use internals::check;
-use internals::{Ctxt, Derive};
-use syn;
-use syn::punctuated::Punctuated;
-
-/// A source data structure annotated with `#[derive(Serialize)]` and/or `#[derive(Deserialize)]`,
-/// parsed into an internal representation.
-pub struct Container<'a> {
-    /// The struct or enum name (without generics).
-    pub ident: syn::Ident,
-    /// Attributes on the structure, parsed for Serde.
-    pub attrs: attr::Container,
-    /// The contents of the struct or enum.
-    pub data: Data<'a>,
-    /// Any generics on the struct or enum.
-    pub generics: &'a syn::Generics,
-    /// Original input.
-    pub original: &'a syn::DeriveInput,
-}
-
-/// The fields of a struct or enum.
-///
-/// Analogous to `syn::Data`.
-pub enum Data<'a> {
-    Enum(Vec<Variant<'a>>),
-    Struct(Style, Vec<Field<'a>>),
-}
-
-/// A variant of an enum.
-pub struct Variant<'a> {
-    pub ident: syn::Ident,
-    pub attrs: attr::Variant,
-    pub style: Style,
-    pub fields: Vec<Field<'a>>,
-    pub original: &'a syn::Variant,
-}
-
-/// A field of a struct.
-pub struct Field<'a> {
-    pub member: syn::Member,
-    pub attrs: attr::Field,
-    pub ty: &'a syn::Type,
-    pub original: &'a syn::Field,
-}
-
-#[derive(Copy, Clone)]
-pub enum Style {
-    /// Named fields.
-    Struct,
-    /// Many unnamed fields.
-    Tuple,
-    /// One unnamed field.
-    Newtype,
-    /// No fields.
-    Unit,
-}
-
-impl<'a> Container<'a> {
-    /// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`.
-    pub fn from_ast(
-        cx: &Ctxt,
-        item: &'a syn::DeriveInput,
-        derive: Derive,
-    ) -> Option<Container<'a>> {
-        let mut attrs = attr::Container::from_ast(cx, item);
-
-        let mut data = match &item.data {
-            syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
-            syn::Data::Struct(data) => {
-                let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
-                Data::Struct(style, fields)
-            }
-            syn::Data::Union(_) => {
-                cx.error_spanned_by(item, "Serde does not support derive for unions");
-                return None;
-            }
-        };
-
-        let mut has_flatten = false;
-        match &mut data {
-            Data::Enum(variants) => {
-                for variant in variants {
-                    variant.attrs.rename_by_rules(attrs.rename_all_rules());
-                    for field in &mut variant.fields {
-                        if field.attrs.flatten() {
-                            has_flatten = true;
-                        }
-                        field
-                            .attrs
-                            .rename_by_rules(variant.attrs.rename_all_rules());
-                    }
-                }
-            }
-            Data::Struct(_, fields) => {
-                for field in fields {
-                    if field.attrs.flatten() {
-                        has_flatten = true;
-                    }
-                    field.attrs.rename_by_rules(attrs.rename_all_rules());
-                }
-            }
-        }
-
-        if has_flatten {
-            attrs.mark_has_flatten();
-        }
-
-        let mut item = Container {
-            ident: item.ident.clone(),
-            attrs,
-            data,
-            generics: &item.generics,
-            original: item,
-        };
-        check::check(cx, &mut item, derive);
-        Some(item)
-    }
-}
-
-impl<'a> Data<'a> {
-    pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
-        match self {
-            Data::Enum(variants) => {
-                Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
-            }
-            Data::Struct(_, fields) => Box::new(fields.iter()),
-        }
-    }
-
-    pub fn has_getter(&self) -> bool {
-        self.all_fields().any(|f| f.attrs.getter().is_some())
-    }
-}
-
-fn enum_from_ast<'a>(
-    cx: &Ctxt,
-    variants: &'a Punctuated<syn::Variant, Token![,]>,
-    container_default: &attr::Default,
-) -> Vec<Variant<'a>> {
-    variants
-        .iter()
-        .map(|variant| {
-            let attrs = attr::Variant::from_ast(cx, variant);
-            let (style, fields) =
-                struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
-            Variant {
-                ident: variant.ident.clone(),
-                attrs,
-                style,
-                fields,
-                original: variant,
-            }
-        })
-        .collect()
-}
-
-fn struct_from_ast<'a>(
-    cx: &Ctxt,
-    fields: &'a syn::Fields,
-    attrs: Option<&attr::Variant>,
-    container_default: &attr::Default,
-) -> (Style, Vec<Field<'a>>) {
-    match fields {
-        syn::Fields::Named(fields) => (
-            Style::Struct,
-            fields_from_ast(cx, &fields.named, attrs, container_default),
-        ),
-        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
-            Style::Newtype,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
-        ),
-        syn::Fields::Unnamed(fields) => (
-            Style::Tuple,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
-        ),
-        syn::Fields::Unit => (Style::Unit, Vec::new()),
-    }
-}
-
-fn fields_from_ast<'a>(
-    cx: &Ctxt,
-    fields: &'a Punctuated<syn::Field, Token![,]>,
-    attrs: Option<&attr::Variant>,
-    container_default: &attr::Default,
-) -> Vec<Field<'a>> {
-    fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| Field {
-            member: match &field.ident {
-                Some(ident) => syn::Member::Named(ident.clone()),
-                None => syn::Member::Unnamed(i.into()),
-            },
-            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
-            ty: &field.ty,
-            original: field,
-        })
-        .collect()
-}
diff --git a/vendor/serde_derive/src/internals/attr.rs b/vendor/serde_derive/src/internals/attr.rs
deleted file mode 100644
index 13f55250..00000000
--- a/vendor/serde_derive/src/internals/attr.rs
+++ /dev/null
@@ -1,1954 +0,0 @@
-use internals::respan::respan;
-use internals::symbol::*;
-use internals::{ungroup, Ctxt};
-use proc_macro2::{Spacing, Span, TokenStream, TokenTree};
-use quote::ToTokens;
-use std::borrow::Cow;
-use std::collections::BTreeSet;
-use syn;
-use syn::parse::{self, Parse, ParseStream};
-use syn::punctuated::Punctuated;
-use syn::Ident;
-use syn::Meta::{List, NameValue, Path};
-use syn::NestedMeta::{Lit, Meta};
-
-// This module handles parsing of `#[serde(...)]` attributes. The entrypoints
-// are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
-// `attr::Field::from_ast`. Each returns an instance of the corresponding
-// struct. Note that none of them return a Result. Unrecognized, malformed, or
-// duplicated attributes result in a span_err but otherwise are ignored. The
-// user will see errors simultaneously for all bad attributes in the crate
-// rather than just the first.
-
-pub use internals::case::RenameRule;
-
-struct Attr<'c, T> {
-    cx: &'c Ctxt,
-    name: Symbol,
-    tokens: TokenStream,
-    value: Option<T>,
-}
-
-impl<'c, T> Attr<'c, T> {
-    fn none(cx: &'c Ctxt, name: Symbol) -> Self {
-        Attr {
-            cx,
-            name,
-            tokens: TokenStream::new(),
-            value: None,
-        }
-    }
-
-    fn set<A: ToTokens>(&mut self, obj: A, value: T) {
-        let tokens = obj.into_token_stream();
-
-        if self.value.is_some() {
-            self.cx
-                .error_spanned_by(tokens, format!("duplicate serde attribute `{}`", self.name));
-        } else {
-            self.tokens = tokens;
-            self.value = Some(value);
-        }
-    }
-
-    fn set_opt<A: ToTokens>(&mut self, obj: A, value: Option<T>) {
-        if let Some(value) = value {
-            self.set(obj, value);
-        }
-    }
-
-    fn set_if_none(&mut self, value: T) {
-        if self.value.is_none() {
-            self.value = Some(value);
-        }
-    }
-
-    fn get(self) -> Option<T> {
-        self.value
-    }
-
-    fn get_with_tokens(self) -> Option<(TokenStream, T)> {
-        match self.value {
-            Some(v) => Some((self.tokens, v)),
-            None => None,
-        }
-    }
-}
-
-struct BoolAttr<'c>(Attr<'c, ()>);
-
-impl<'c> BoolAttr<'c> {
-    fn none(cx: &'c Ctxt, name: Symbol) -> Self {
-        BoolAttr(Attr::none(cx, name))
-    }
-
-    fn set_true<A: ToTokens>(&mut self, obj: A) {
-        self.0.set(obj, ());
-    }
-
-    fn get(&self) -> bool {
-        self.0.value.is_some()
-    }
-}
-
-struct VecAttr<'c, T> {
-    cx: &'c Ctxt,
-    name: Symbol,
-    first_dup_tokens: TokenStream,
-    values: Vec<T>,
-}
-
-impl<'c, T> VecAttr<'c, T> {
-    fn none(cx: &'c Ctxt, name: Symbol) -> Self {
-        VecAttr {
-            cx,
-            name,
-            first_dup_tokens: TokenStream::new(),
-            values: Vec::new(),
-        }
-    }
-
-    fn insert<A: ToTokens>(&mut self, obj: A, value: T) {
-        if self.values.len() == 1 {
-            self.first_dup_tokens = obj.into_token_stream();
-        }
-        self.values.push(value);
-    }
-
-    fn at_most_one(mut self) -> Result<Option<T>, ()> {
-        if self.values.len() > 1 {
-            let dup_token = self.first_dup_tokens;
-            self.cx.error_spanned_by(
-                dup_token,
-                format!("duplicate serde attribute `{}`", self.name),
-            );
-            Err(())
-        } else {
-            Ok(self.values.pop())
-        }
-    }
-
-    fn get(self) -> Vec<T> {
-        self.values
-    }
-}
-
-pub struct Name {
-    serialize: String,
-    serialize_renamed: bool,
-    deserialize: String,
-    deserialize_renamed: bool,
-    deserialize_aliases: Vec<String>,
-}
-
-#[allow(deprecated)]
-fn unraw(ident: &Ident) -> String {
-    // str::trim_start_matches was added in 1.30, trim_left_matches deprecated
-    // in 1.33. We currently support rustc back to 1.15 so we need to continue
-    // to use the deprecated one.
-    ident.to_string().trim_left_matches("r#").to_owned()
-}
-
-impl Name {
-    fn from_attrs(
-        source_name: String,
-        ser_name: Attr<String>,
-        de_name: Attr<String>,
-        de_aliases: Option<VecAttr<String>>,
-    ) -> Name {
-        let deserialize_aliases = match de_aliases {
-            Some(de_aliases) => {
-                let mut alias_list = BTreeSet::new();
-                for alias_name in de_aliases.get() {
-                    alias_list.insert(alias_name);
-                }
-                alias_list.into_iter().collect()
-            }
-            None => Vec::new(),
-        };
-
-        let ser_name = ser_name.get();
-        let ser_renamed = ser_name.is_some();
-        let de_name = de_name.get();
-        let de_renamed = de_name.is_some();
-        Name {
-            serialize: ser_name.unwrap_or_else(|| source_name.clone()),
-            serialize_renamed: ser_renamed,
-            deserialize: de_name.unwrap_or(source_name),
-            deserialize_renamed: de_renamed,
-            deserialize_aliases,
-        }
-    }
-
-    /// Return the container name for the container when serializing.
-    pub fn serialize_name(&self) -> String {
-        self.serialize.clone()
-    }
-
-    /// Return the container name for the container when deserializing.
-    pub fn deserialize_name(&self) -> String {
-        self.deserialize.clone()
-    }
-
-    fn deserialize_aliases(&self) -> Vec<String> {
-        let mut aliases = self.deserialize_aliases.clone();
-        let main_name = self.deserialize_name();
-        if !aliases.contains(&main_name) {
-            aliases.push(main_name);
-        }
-        aliases
-    }
-}
-
-pub struct RenameAllRules {
-    serialize: RenameRule,
-    deserialize: RenameRule,
-}
-
-/// Represents struct or enum attribute information.
-pub struct Container {
-    name: Name,
-    transparent: bool,
-    deny_unknown_fields: bool,
-    default: Default,
-    rename_all_rules: RenameAllRules,
-    ser_bound: Option<Vec<syn::WherePredicate>>,
-    de_bound: Option<Vec<syn::WherePredicate>>,
-    tag: TagType,
-    type_from: Option<syn::Type>,
-    type_try_from: Option<syn::Type>,
-    type_into: Option<syn::Type>,
-    remote: Option<syn::Path>,
-    identifier: Identifier,
-    has_flatten: bool,
-    serde_path: Option<syn::Path>,
-    is_packed: bool,
-    /// Error message generated when type can't be deserialized
-    expecting: Option<String>,
-}
-
-/// Styles of representing an enum.
-pub enum TagType {
-    /// The default.
-    ///
-    /// ```json
-    /// {"variant1": {"key1": "value1", "key2": "value2"}}
-    /// ```
-    External,
-
-    /// `#[serde(tag = "type")]`
-    ///
-    /// ```json
-    /// {"type": "variant1", "key1": "value1", "key2": "value2"}
-    /// ```
-    Internal { tag: String },
-
-    /// `#[serde(tag = "t", content = "c")]`
-    ///
-    /// ```json
-    /// {"t": "variant1", "c": {"key1": "value1", "key2": "value2"}}
-    /// ```
-    Adjacent { tag: String, content: String },
-
-    /// `#[serde(untagged)]`
-    ///
-    /// ```json
-    /// {"key1": "value1", "key2": "value2"}
-    /// ```
-    None,
-}
-
-/// Whether this enum represents the fields of a struct or the variants of an
-/// enum.
-#[derive(Copy, Clone)]
-pub enum Identifier {
-    /// It does not.
-    No,
-
-    /// This enum represents the fields of a struct. All of the variants must be
-    /// unit variants, except possibly one which is annotated with
-    /// `#[serde(other)]` and is a newtype variant.
-    Field,
-
-    /// This enum represents the variants of an enum. All of the variants must
-    /// be unit variants.
-    Variant,
-}
-
-impl Identifier {
-    #[cfg(feature = "deserialize_in_place")]
-    pub fn is_some(self) -> bool {
-        match self {
-            Identifier::No => false,
-            Identifier::Field | Identifier::Variant => true,
-        }
-    }
-}
-
-impl Container {
-    /// Extract out the `#[serde(...)]` attributes from an item.
-    pub fn from_ast(cx: &Ctxt, item: &syn::DeriveInput) -> Self {
-        let mut ser_name = Attr::none(cx, RENAME);
-        let mut de_name = Attr::none(cx, RENAME);
-        let mut transparent = BoolAttr::none(cx, TRANSPARENT);
-        let mut deny_unknown_fields = BoolAttr::none(cx, DENY_UNKNOWN_FIELDS);
-        let mut default = Attr::none(cx, DEFAULT);
-        let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
-        let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
-        let mut ser_bound = Attr::none(cx, BOUND);
-        let mut de_bound = Attr::none(cx, BOUND);
-        let mut untagged = BoolAttr::none(cx, UNTAGGED);
-        let mut internal_tag = Attr::none(cx, TAG);
-        let mut content = Attr::none(cx, CONTENT);
-        let mut type_from = Attr::none(cx, FROM);
-        let mut type_try_from = Attr::none(cx, TRY_FROM);
-        let mut type_into = Attr::none(cx, INTO);
-        let mut remote = Attr::none(cx, REMOTE);
-        let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
-        let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
-        let mut serde_path = Attr::none(cx, CRATE);
-        let mut expecting = Attr::none(cx, EXPECTING);
-
-        for meta_item in item
-            .attrs
-            .iter()
-            .flat_map(|attr| get_serde_meta_items(cx, attr))
-            .flatten()
-        {
-            match &meta_item {
-                // Parse `#[serde(rename = "foo")]`
-                Meta(NameValue(m)) if m.path == RENAME => {
-                    if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
-                        ser_name.set(&m.path, s.value());
-                        de_name.set(&m.path, s.value());
-                    }
-                }
-
-                // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
-                Meta(List(m)) if m.path == RENAME => {
-                    if let Ok((ser, de)) = get_renames(cx, &m.nested) {
-                        ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
-                        de_name.set_opt(&m.path, de.map(syn::LitStr::value));
-                    }
-                }
-
-                // Parse `#[serde(rename_all = "foo")]`
-                Meta(NameValue(m)) if m.path == RENAME_ALL => {
-                    if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
-                        match RenameRule::from_str(&s.value()) {
-                            Ok(rename_rule) => {
-                                rename_all_ser_rule.set(&m.path, rename_rule);
-                                rename_all_de_rule.set(&m.path, rename_rule);
-                            }
-                            Err(err) => cx.error_spanned_by(s, err),
-                        }
-                    }
-                }
-
-                // Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
-                Meta(List(m)) if m.path == RENAME_ALL => {
-                    if let Ok((ser, de)) = get_renames(cx, &m.nested) {
-                        if let Some(ser) = ser {
-                            match RenameRule::from_str(&ser.value()) {
-                                Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(err) => cx.error_spanned_by(ser, err),
-                            }
-                        }
-                        if let Some(de) = de {
-                            match RenameRule::from_str(&de.value()) {
-                                Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(err) => cx.error_spanned_by(de, err),
-                            }
-                        }
-                    }
-                }
-
-                // Parse `#[serde(transparent)]`
-                Meta(Path(word)) if word == TRANSPARENT => {
-                    transparent.set_true(word);
-                }
-
-                // Parse `#[serde(deny_unknown_fields)]`
-                Meta(Path(word)) if word == DENY_UNKNOWN_FIELDS => {
-                    deny_unknown_fields.set_true(word);
-                }
-
-                // Parse `#[serde(default)]`
-                Meta(Path(word)) if word == DEFAULT => match &item.data {
-                    syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
-                        syn::Fields::Named(_) => {
-                            default.set(word, Default::Default);
-                        }
-                        syn::Fields::Unnamed(_) | syn::Fields::Unit => cx.error_spanned_by(
-                            fields,
-                            "#[serde(default)] can only be used on structs with named fields",
-                        ),
-                    },
-                    syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx.error_spanned_by(
-                        enum_token,
-                        "#[serde(default)] can only be used on structs with named fields",
-                    ),
-                    syn::Data::Union(syn::DataUnion { union_token, .. }) => cx.error_spanned_by(
-                        union_token,
-                        "#[serde(default)] can only be used on structs with named fields",
-                    ),
-                },
-
-                // Parse `#[serde(default = "...")]`
-                Meta(NameValue(m)) if m.path == DEFAULT => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
-                        match &item.data {
-                            syn::Data::Struct(syn::DataStruct { fields, .. }) => {
-                                match fields {
-                                    syn::Fields::Named(_) => {
-                                        default.set(&m.path, Default::Path(path));
-                                    }
-                                    syn::Fields::Unnamed(_) | syn::Fields::Unit => cx
-                                        .error_spanned_by(
-                                            fields,
-                                            "#[serde(default = \"...\")] can only be used on structs with named fields",
-                                        ),
-                                }
-                            }
-                            syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx
-                                .error_spanned_by(
-                                    enum_token,
-                                    "#[serde(default = \"...\")] can only be used on structs with named fields",
-                                ),
-                            syn::Data::Union(syn::DataUnion {
-                                union_token, ..
-                            }) => cx.error_spanned_by(
-                                union_token,
-                                "#[serde(default = \"...\")] can only be used on structs with named fields",
-                            ),
-                        }
-                    }
-                }
-
-                // Parse `#[serde(bound = "T: SomeBound")]`
-                Meta(NameValue(m)) if m.path == BOUND => {
-                    if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
-                        ser_bound.set(&m.path, where_predicates.clone());
-                        de_bound.set(&m.path, where_predicates);
-                    }
-                }
-
-                // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
-                Meta(List(m)) if m.path == BOUND => {
-                    if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
-                        ser_bound.set_opt(&m.path, ser);
-                        de_bound.set_opt(&m.path, de);
-                    }
-                }
-
-                // Parse `#[serde(untagged)]`
-                Meta(Path(word)) if word == UNTAGGED => match item.data {
-                    syn::Data::Enum(_) => {
-                        untagged.set_true(word);
-                    }
-                    syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
-                        cx.error_spanned_by(
-                            struct_token,
-                            "#[serde(untagged)] can only be used on enums",
-                        );
-                    }
-                    syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                        cx.error_spanned_by(
-                            union_token,
-                            "#[serde(untagged)] can only be used on enums",
-                        );
-                    }
-                },
-
-                // Parse `#[serde(tag = "type")]`
-                Meta(NameValue(m)) if m.path == TAG => {
-                    if let Ok(s) = get_lit_str(cx, TAG, &m.lit) {
-                        match &item.data {
-                            syn::Data::Enum(_) => {
-                                internal_tag.set(&m.path, s.value());
-                            }
-                            syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
-                                syn::Fields::Named(_) => {
-                                    internal_tag.set(&m.path, s.value());
-                                }
-                                syn::Fields::Unnamed(_) | syn::Fields::Unit => {
-                                    cx.error_spanned_by(
-                                            fields,
-                                            "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
-                                        );
-                                }
-                            },
-                            syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                                cx.error_spanned_by(
-                                    union_token,
-                                    "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
-                                );
-                            }
-                        }
-                    }
-                }
-
-                // Parse `#[serde(content = "c")]`
-                Meta(NameValue(m)) if m.path == CONTENT => {
-                    if let Ok(s) = get_lit_str(cx, CONTENT, &m.lit) {
-                        match &item.data {
-                            syn::Data::Enum(_) => {
-                                content.set(&m.path, s.value());
-                            }
-                            syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
-                                cx.error_spanned_by(
-                                    struct_token,
-                                    "#[serde(content = \"...\")] can only be used on enums",
-                                );
-                            }
-                            syn::Data::Union(syn::DataUnion { union_token, .. }) => {
-                                cx.error_spanned_by(
-                                    union_token,
-                                    "#[serde(content = \"...\")] can only be used on enums",
-                                );
-                            }
-                        }
-                    }
-                }
-
-                // Parse `#[serde(from = "Type")]
-                Meta(NameValue(m)) if m.path == FROM => {
-                    if let Ok(from_ty) = parse_lit_into_ty(cx, FROM, &m.lit) {
-                        type_from.set_opt(&m.path, Some(from_ty));
-                    }
-                }
-
-                // Parse `#[serde(try_from = "Type")]
-                Meta(NameValue(m)) if m.path == TRY_FROM => {
-                    if let Ok(try_from_ty) = parse_lit_into_ty(cx, TRY_FROM, &m.lit) {
-                        type_try_from.set_opt(&m.path, Some(try_from_ty));
-                    }
-                }
-
-                // Parse `#[serde(into = "Type")]
-                Meta(NameValue(m)) if m.path == INTO => {
-                    if let Ok(into_ty) = parse_lit_into_ty(cx, INTO, &m.lit) {
-                        type_into.set_opt(&m.path, Some(into_ty));
-                    }
-                }
-
-                // Parse `#[serde(remote = "...")]`
-                Meta(NameValue(m)) if m.path == REMOTE => {
-                    if let Ok(path) = parse_lit_into_path(cx, REMOTE, &m.lit) {
-                        if is_primitive_path(&path, "Self") {
-                            remote.set(&m.path, item.ident.clone().into());
-                        } else {
-                            remote.set(&m.path, path);
-                        }
-                    }
-                }
-
-                // Parse `#[serde(field_identifier)]`
-                Meta(Path(word)) if word == FIELD_IDENTIFIER => {
-                    field_identifier.set_true(word);
-                }
-
-                // Parse `#[serde(variant_identifier)]`
-                Meta(Path(word)) if word == VARIANT_IDENTIFIER => {
-                    variant_identifier.set_true(word);
-                }
-
-                // Parse `#[serde(crate = "foo")]`
-                Meta(NameValue(m)) if m.path == CRATE => {
-                    if let Ok(path) = parse_lit_into_path(cx, CRATE, &m.lit) {
-                        serde_path.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(expecting = "a message")]`
-                Meta(NameValue(m)) if m.path == EXPECTING => {
-                    if let Ok(s) = get_lit_str(cx, EXPECTING, &m.lit) {
-                        expecting.set(&m.path, s.value());
-                    }
-                }
-
-                Meta(meta_item) => {
-                    let path = meta_item
-                        .path()
-                        .into_token_stream()
-                        .to_string()
-                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde container attribute `{}`", path),
-                    );
-                }
-
-                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde container attribute");
-                }
-            }
-        }
-
-        let mut is_packed = false;
-        for attr in &item.attrs {
-            if attr.path.is_ident("repr") {
-                let _ = attr.parse_args_with(|input: ParseStream| {
-                    while let Some(token) = input.parse()? {
-                        if let TokenTree::Ident(ident) = token {
-                            is_packed |= ident == "packed";
-                        }
-                    }
-                    Ok(())
-                });
-            }
-        }
-
-        Container {
-            name: Name::from_attrs(unraw(&item.ident), ser_name, de_name, None),
-            transparent: transparent.get(),
-            deny_unknown_fields: deny_unknown_fields.get(),
-            default: default.get().unwrap_or(Default::None),
-            rename_all_rules: RenameAllRules {
-                serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
-                deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
-            },
-            ser_bound: ser_bound.get(),
-            de_bound: de_bound.get(),
-            tag: decide_tag(cx, item, untagged, internal_tag, content),
-            type_from: type_from.get(),
-            type_try_from: type_try_from.get(),
-            type_into: type_into.get(),
-            remote: remote.get(),
-            identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
-            has_flatten: false,
-            serde_path: serde_path.get(),
-            is_packed,
-            expecting: expecting.get(),
-        }
-    }
-
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn rename_all_rules(&self) -> &RenameAllRules {
-        &self.rename_all_rules
-    }
-
-    pub fn transparent(&self) -> bool {
-        self.transparent
-    }
-
-    pub fn deny_unknown_fields(&self) -> bool {
-        self.deny_unknown_fields
-    }
-
-    pub fn default(&self) -> &Default {
-        &self.default
-    }
-
-    pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.ser_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.de_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn tag(&self) -> &TagType {
-        &self.tag
-    }
-
-    pub fn type_from(&self) -> Option<&syn::Type> {
-        self.type_from.as_ref()
-    }
-
-    pub fn type_try_from(&self) -> Option<&syn::Type> {
-        self.type_try_from.as_ref()
-    }
-
-    pub fn type_into(&self) -> Option<&syn::Type> {
-        self.type_into.as_ref()
-    }
-
-    pub fn remote(&self) -> Option<&syn::Path> {
-        self.remote.as_ref()
-    }
-
-    pub fn is_packed(&self) -> bool {
-        self.is_packed
-    }
-
-    pub fn identifier(&self) -> Identifier {
-        self.identifier
-    }
-
-    pub fn has_flatten(&self) -> bool {
-        self.has_flatten
-    }
-
-    pub fn mark_has_flatten(&mut self) {
-        self.has_flatten = true;
-    }
-
-    pub fn custom_serde_path(&self) -> Option<&syn::Path> {
-        self.serde_path.as_ref()
-    }
-
-    pub fn serde_path(&self) -> Cow<syn::Path> {
-        self.custom_serde_path()
-            .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
-    }
-
-    /// Error message generated when type can't be deserialized.
-    /// If `None`, default message will be used
-    pub fn expecting(&self) -> Option<&str> {
-        self.expecting.as_ref().map(String::as_ref)
-    }
-}
-
-fn decide_tag(
-    cx: &Ctxt,
-    item: &syn::DeriveInput,
-    untagged: BoolAttr,
-    internal_tag: Attr<String>,
-    content: Attr<String>,
-) -> TagType {
-    match (
-        untagged.0.get_with_tokens(),
-        internal_tag.get_with_tokens(),
-        content.get_with_tokens(),
-    ) {
-        (None, None, None) => TagType::External,
-        (Some(_), None, None) => TagType::None,
-        (None, Some((_, tag)), None) => {
-            // Check that there are no tuple variants.
-            if let syn::Data::Enum(data) = &item.data {
-                for variant in &data.variants {
-                    match &variant.fields {
-                        syn::Fields::Named(_) | syn::Fields::Unit => {}
-                        syn::Fields::Unnamed(fields) => {
-                            if fields.unnamed.len() != 1 {
-                                cx.error_spanned_by(
-                                    variant,
-                                    "#[serde(tag = \"...\")] cannot be used with tuple variants",
-                                );
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            TagType::Internal { tag }
-        }
-        (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "enum cannot be both untagged and internally tagged",
-            );
-            cx.error_spanned_by(
-                tag_tokens,
-                "enum cannot be both untagged and internally tagged",
-            );
-            TagType::External // doesn't matter, will error
-        }
-        (None, None, Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                content_tokens,
-                "#[serde(tag = \"...\", content = \"...\")] must be used together",
-            );
-            TagType::External
-        }
-        (Some((untagged_tokens, _)), None, Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "untagged enum cannot have #[serde(content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                content_tokens,
-                "untagged enum cannot have #[serde(content = \"...\")]",
-            );
-            TagType::External
-        }
-        (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content },
-        (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => {
-            cx.error_spanned_by(
-                untagged_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                tag_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
-            cx.error_spanned_by(
-                content_tokens,
-                "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
-            );
-            TagType::External
-        }
-    }
-}
-
-fn decide_identifier(
-    cx: &Ctxt,
-    item: &syn::DeriveInput,
-    field_identifier: BoolAttr,
-    variant_identifier: BoolAttr,
-) -> Identifier {
-    match (
-        &item.data,
-        field_identifier.0.get_with_tokens(),
-        variant_identifier.0.get_with_tokens(),
-    ) {
-        (_, None, None) => Identifier::No,
-        (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
-            cx.error_spanned_by(
-                field_identifier_tokens,
-                "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
-            );
-            cx.error_spanned_by(
-                variant_identifier_tokens,
-                "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
-            );
-            Identifier::No
-        }
-        (syn::Data::Enum(_), Some(_), None) => Identifier::Field,
-        (syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
-        (syn::Data::Struct(syn::DataStruct { struct_token, .. }), Some(_), None) => {
-            cx.error_spanned_by(
-                struct_token,
-                "#[serde(field_identifier)] can only be used on an enum",
-            );
-            Identifier::No
-        }
-        (syn::Data::Union(syn::DataUnion { union_token, .. }), Some(_), None) => {
-            cx.error_spanned_by(
-                union_token,
-                "#[serde(field_identifier)] can only be used on an enum",
-            );
-            Identifier::No
-        }
-        (syn::Data::Struct(syn::DataStruct { struct_token, .. }), None, Some(_)) => {
-            cx.error_spanned_by(
-                struct_token,
-                "#[serde(variant_identifier)] can only be used on an enum",
-            );
-            Identifier::No
-        }
-        (syn::Data::Union(syn::DataUnion { union_token, .. }), None, Some(_)) => {
-            cx.error_spanned_by(
-                union_token,
-                "#[serde(variant_identifier)] can only be used on an enum",
-            );
-            Identifier::No
-        }
-    }
-}
-
-/// Represents variant attribute information
-pub struct Variant {
-    name: Name,
-    rename_all_rules: RenameAllRules,
-    ser_bound: Option<Vec<syn::WherePredicate>>,
-    de_bound: Option<Vec<syn::WherePredicate>>,
-    skip_deserializing: bool,
-    skip_serializing: bool,
-    other: bool,
-    serialize_with: Option<syn::ExprPath>,
-    deserialize_with: Option<syn::ExprPath>,
-    borrow: Option<syn::Meta>,
-}
-
-impl Variant {
-    pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
-        let mut ser_name = Attr::none(cx, RENAME);
-        let mut de_name = Attr::none(cx, RENAME);
-        let mut de_aliases = VecAttr::none(cx, RENAME);
-        let mut skip_deserializing = BoolAttr::none(cx, SKIP_DESERIALIZING);
-        let mut skip_serializing = BoolAttr::none(cx, SKIP_SERIALIZING);
-        let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
-        let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
-        let mut ser_bound = Attr::none(cx, BOUND);
-        let mut de_bound = Attr::none(cx, BOUND);
-        let mut other = BoolAttr::none(cx, OTHER);
-        let mut serialize_with = Attr::none(cx, SERIALIZE_WITH);
-        let mut deserialize_with = Attr::none(cx, DESERIALIZE_WITH);
-        let mut borrow = Attr::none(cx, BORROW);
-
-        for meta_item in variant
-            .attrs
-            .iter()
-            .flat_map(|attr| get_serde_meta_items(cx, attr))
-            .flatten()
-        {
-            match &meta_item {
-                // Parse `#[serde(rename = "foo")]`
-                Meta(NameValue(m)) if m.path == RENAME => {
-                    if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
-                        ser_name.set(&m.path, s.value());
-                        de_name.set_if_none(s.value());
-                        de_aliases.insert(&m.path, s.value());
-                    }
-                }
-
-                // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
-                Meta(List(m)) if m.path == RENAME => {
-                    if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
-                        ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
-                        for de_value in de {
-                            de_name.set_if_none(de_value.value());
-                            de_aliases.insert(&m.path, de_value.value());
-                        }
-                    }
-                }
-
-                // Parse `#[serde(alias = "foo")]`
-                Meta(NameValue(m)) if m.path == ALIAS => {
-                    if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
-                        de_aliases.insert(&m.path, s.value());
-                    }
-                }
-
-                // Parse `#[serde(rename_all = "foo")]`
-                Meta(NameValue(m)) if m.path == RENAME_ALL => {
-                    if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
-                        match RenameRule::from_str(&s.value()) {
-                            Ok(rename_rule) => {
-                                rename_all_ser_rule.set(&m.path, rename_rule);
-                                rename_all_de_rule.set(&m.path, rename_rule);
-                            }
-                            Err(err) => cx.error_spanned_by(s, err),
-                        }
-                    }
-                }
-
-                // Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
-                Meta(List(m)) if m.path == RENAME_ALL => {
-                    if let Ok((ser, de)) = get_renames(cx, &m.nested) {
-                        if let Some(ser) = ser {
-                            match RenameRule::from_str(&ser.value()) {
-                                Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(err) => cx.error_spanned_by(ser, err),
-                            }
-                        }
-                        if let Some(de) = de {
-                            match RenameRule::from_str(&de.value()) {
-                                Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(err) => cx.error_spanned_by(de, err),
-                            }
-                        }
-                    }
-                }
-
-                // Parse `#[serde(skip)]`
-                Meta(Path(word)) if word == SKIP => {
-                    skip_serializing.set_true(word);
-                    skip_deserializing.set_true(word);
-                }
-
-                // Parse `#[serde(skip_deserializing)]`
-                Meta(Path(word)) if word == SKIP_DESERIALIZING => {
-                    skip_deserializing.set_true(word);
-                }
-
-                // Parse `#[serde(skip_serializing)]`
-                Meta(Path(word)) if word == SKIP_SERIALIZING => {
-                    skip_serializing.set_true(word);
-                }
-
-                // Parse `#[serde(other)]`
-                Meta(Path(word)) if word == OTHER => {
-                    other.set_true(word);
-                }
-
-                // Parse `#[serde(bound = "T: SomeBound")]`
-                Meta(NameValue(m)) if m.path == BOUND => {
-                    if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
-                        ser_bound.set(&m.path, where_predicates.clone());
-                        de_bound.set(&m.path, where_predicates);
-                    }
-                }
-
-                // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
-                Meta(List(m)) if m.path == BOUND => {
-                    if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
-                        ser_bound.set_opt(&m.path, ser);
-                        de_bound.set_opt(&m.path, de);
-                    }
-                }
-
-                // Parse `#[serde(with = "...")]`
-                Meta(NameValue(m)) if m.path == WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
-                        let mut ser_path = path.clone();
-                        ser_path
-                            .path
-                            .segments
-                            .push(Ident::new("serialize", Span::call_site()).into());
-                        serialize_with.set(&m.path, ser_path);
-                        let mut de_path = path;
-                        de_path
-                            .path
-                            .segments
-                            .push(Ident::new("deserialize", Span::call_site()).into());
-                        deserialize_with.set(&m.path, de_path);
-                    }
-                }
-
-                // Parse `#[serde(serialize_with = "...")]`
-                Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
-                        serialize_with.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(deserialize_with = "...")]`
-                Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
-                        deserialize_with.set(&m.path, path);
-                    }
-                }
-
-                // Defer `#[serde(borrow)]` and `#[serde(borrow = "'a + 'b")]`
-                Meta(m) if m.path() == BORROW => match &variant.fields {
-                    syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
-                        borrow.set(m.path(), m.clone());
-                    }
-                    _ => {
-                        cx.error_spanned_by(
-                            variant,
-                            "#[serde(borrow)] may only be used on newtype variants",
-                        );
-                    }
-                },
-
-                Meta(meta_item) => {
-                    let path = meta_item
-                        .path()
-                        .into_token_stream()
-                        .to_string()
-                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde variant attribute `{}`", path),
-                    );
-                }
-
-                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
-                }
-            }
-        }
-
-        Variant {
-            name: Name::from_attrs(unraw(&variant.ident), ser_name, de_name, Some(de_aliases)),
-            rename_all_rules: RenameAllRules {
-                serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
-                deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
-            },
-            ser_bound: ser_bound.get(),
-            de_bound: de_bound.get(),
-            skip_deserializing: skip_deserializing.get(),
-            skip_serializing: skip_serializing.get(),
-            other: other.get(),
-            serialize_with: serialize_with.get(),
-            deserialize_with: deserialize_with.get(),
-            borrow: borrow.get(),
-        }
-    }
-
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn aliases(&self) -> Vec<String> {
-        self.name.deserialize_aliases()
-    }
-
-    pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
-        if !self.name.serialize_renamed {
-            self.name.serialize = rules.serialize.apply_to_variant(&self.name.serialize);
-        }
-        if !self.name.deserialize_renamed {
-            self.name.deserialize = rules.deserialize.apply_to_variant(&self.name.deserialize);
-        }
-    }
-
-    pub fn rename_all_rules(&self) -> &RenameAllRules {
-        &self.rename_all_rules
-    }
-
-    pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.ser_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.de_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn skip_deserializing(&self) -> bool {
-        self.skip_deserializing
-    }
-
-    pub fn skip_serializing(&self) -> bool {
-        self.skip_serializing
-    }
-
-    pub fn other(&self) -> bool {
-        self.other
-    }
-
-    pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
-        self.serialize_with.as_ref()
-    }
-
-    pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
-        self.deserialize_with.as_ref()
-    }
-}
-
-/// Represents field attribute information
-pub struct Field {
-    name: Name,
-    skip_serializing: bool,
-    skip_deserializing: bool,
-    skip_serializing_if: Option<syn::ExprPath>,
-    default: Default,
-    serialize_with: Option<syn::ExprPath>,
-    deserialize_with: Option<syn::ExprPath>,
-    ser_bound: Option<Vec<syn::WherePredicate>>,
-    de_bound: Option<Vec<syn::WherePredicate>>,
-    borrowed_lifetimes: BTreeSet<syn::Lifetime>,
-    getter: Option<syn::ExprPath>,
-    flatten: bool,
-    transparent: bool,
-}
-
-/// Represents the default to use for a field when deserializing.
-pub enum Default {
-    /// Field must always be specified because it does not have a default.
-    None,
-    /// The default is given by `std::default::Default::default()`.
-    Default,
-    /// The default is given by this function.
-    Path(syn::ExprPath),
-}
-
-impl Default {
-    pub fn is_none(&self) -> bool {
-        match self {
-            Default::None => true,
-            Default::Default | Default::Path(_) => false,
-        }
-    }
-}
-
-impl Field {
-    /// Extract out the `#[serde(...)]` attributes from a struct field.
-    pub fn from_ast(
-        cx: &Ctxt,
-        index: usize,
-        field: &syn::Field,
-        attrs: Option<&Variant>,
-        container_default: &Default,
-    ) -> Self {
-        let mut ser_name = Attr::none(cx, RENAME);
-        let mut de_name = Attr::none(cx, RENAME);
-        let mut de_aliases = VecAttr::none(cx, RENAME);
-        let mut skip_serializing = BoolAttr::none(cx, SKIP_SERIALIZING);
-        let mut skip_deserializing = BoolAttr::none(cx, SKIP_DESERIALIZING);
-        let mut skip_serializing_if = Attr::none(cx, SKIP_SERIALIZING_IF);
-        let mut default = Attr::none(cx, DEFAULT);
-        let mut serialize_with = Attr::none(cx, SERIALIZE_WITH);
-        let mut deserialize_with = Attr::none(cx, DESERIALIZE_WITH);
-        let mut ser_bound = Attr::none(cx, BOUND);
-        let mut de_bound = Attr::none(cx, BOUND);
-        let mut borrowed_lifetimes = Attr::none(cx, BORROW);
-        let mut getter = Attr::none(cx, GETTER);
-        let mut flatten = BoolAttr::none(cx, FLATTEN);
-
-        let ident = match &field.ident {
-            Some(ident) => unraw(ident),
-            None => index.to_string(),
-        };
-
-        let variant_borrow = attrs
-            .and_then(|variant| variant.borrow.as_ref())
-            .map(|borrow| Meta(borrow.clone()));
-
-        for meta_item in field
-            .attrs
-            .iter()
-            .flat_map(|attr| get_serde_meta_items(cx, attr))
-            .flatten()
-            .chain(variant_borrow)
-        {
-            match &meta_item {
-                // Parse `#[serde(rename = "foo")]`
-                Meta(NameValue(m)) if m.path == RENAME => {
-                    if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
-                        ser_name.set(&m.path, s.value());
-                        de_name.set_if_none(s.value());
-                        de_aliases.insert(&m.path, s.value());
-                    }
-                }
-
-                // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
-                Meta(List(m)) if m.path == RENAME => {
-                    if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
-                        ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
-                        for de_value in de {
-                            de_name.set_if_none(de_value.value());
-                            de_aliases.insert(&m.path, de_value.value());
-                        }
-                    }
-                }
-
-                // Parse `#[serde(alias = "foo")]`
-                Meta(NameValue(m)) if m.path == ALIAS => {
-                    if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
-                        de_aliases.insert(&m.path, s.value());
-                    }
-                }
-
-                // Parse `#[serde(default)]`
-                Meta(Path(word)) if word == DEFAULT => {
-                    default.set(word, Default::Default);
-                }
-
-                // Parse `#[serde(default = "...")]`
-                Meta(NameValue(m)) if m.path == DEFAULT => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
-                        default.set(&m.path, Default::Path(path));
-                    }
-                }
-
-                // Parse `#[serde(skip_serializing)]`
-                Meta(Path(word)) if word == SKIP_SERIALIZING => {
-                    skip_serializing.set_true(word);
-                }
-
-                // Parse `#[serde(skip_deserializing)]`
-                Meta(Path(word)) if word == SKIP_DESERIALIZING => {
-                    skip_deserializing.set_true(word);
-                }
-
-                // Parse `#[serde(skip)]`
-                Meta(Path(word)) if word == SKIP => {
-                    skip_serializing.set_true(word);
-                    skip_deserializing.set_true(word);
-                }
-
-                // Parse `#[serde(skip_serializing_if = "...")]`
-                Meta(NameValue(m)) if m.path == SKIP_SERIALIZING_IF => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, SKIP_SERIALIZING_IF, &m.lit) {
-                        skip_serializing_if.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(serialize_with = "...")]`
-                Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
-                        serialize_with.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(deserialize_with = "...")]`
-                Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
-                        deserialize_with.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(with = "...")]`
-                Meta(NameValue(m)) if m.path == WITH => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
-                        let mut ser_path = path.clone();
-                        ser_path
-                            .path
-                            .segments
-                            .push(Ident::new("serialize", Span::call_site()).into());
-                        serialize_with.set(&m.path, ser_path);
-                        let mut de_path = path;
-                        de_path
-                            .path
-                            .segments
-                            .push(Ident::new("deserialize", Span::call_site()).into());
-                        deserialize_with.set(&m.path, de_path);
-                    }
-                }
-
-                // Parse `#[serde(bound = "T: SomeBound")]`
-                Meta(NameValue(m)) if m.path == BOUND => {
-                    if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
-                        ser_bound.set(&m.path, where_predicates.clone());
-                        de_bound.set(&m.path, where_predicates);
-                    }
-                }
-
-                // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
-                Meta(List(m)) if m.path == BOUND => {
-                    if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
-                        ser_bound.set_opt(&m.path, ser);
-                        de_bound.set_opt(&m.path, de);
-                    }
-                }
-
-                // Parse `#[serde(borrow)]`
-                Meta(Path(word)) if word == BORROW => {
-                    if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
-                        borrowed_lifetimes.set(word, borrowable);
-                    }
-                }
-
-                // Parse `#[serde(borrow = "'a + 'b")]`
-                Meta(NameValue(m)) if m.path == BORROW => {
-                    if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, BORROW, &m.lit) {
-                        if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
-                            for lifetime in &lifetimes {
-                                if !borrowable.contains(lifetime) {
-                                    cx.error_spanned_by(
-                                        field,
-                                        format!(
-                                            "field `{}` does not have lifetime {}",
-                                            ident, lifetime
-                                        ),
-                                    );
-                                }
-                            }
-                            borrowed_lifetimes.set(&m.path, lifetimes);
-                        }
-                    }
-                }
-
-                // Parse `#[serde(getter = "...")]`
-                Meta(NameValue(m)) if m.path == GETTER => {
-                    if let Ok(path) = parse_lit_into_expr_path(cx, GETTER, &m.lit) {
-                        getter.set(&m.path, path);
-                    }
-                }
-
-                // Parse `#[serde(flatten)]`
-                Meta(Path(word)) if word == FLATTEN => {
-                    flatten.set_true(word);
-                }
-
-                Meta(meta_item) => {
-                    let path = meta_item
-                        .path()
-                        .into_token_stream()
-                        .to_string()
-                        .replace(' ', "");
-                    cx.error_spanned_by(
-                        meta_item.path(),
-                        format!("unknown serde field attribute `{}`", path),
-                    );
-                }
-
-                Lit(lit) => {
-                    cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
-                }
-            }
-        }
-
-        // Is skip_deserializing, initialize the field to Default::default() unless a
-        // different default is specified by `#[serde(default = "...")]` on
-        // ourselves or our container (e.g. the struct we are in).
-        if let Default::None = *container_default {
-            if skip_deserializing.0.value.is_some() {
-                default.set_if_none(Default::Default);
-            }
-        }
-
-        let mut borrowed_lifetimes = borrowed_lifetimes.get().unwrap_or_default();
-        if !borrowed_lifetimes.is_empty() {
-            // Cow<str> and Cow<[u8]> never borrow by default:
-            //
-            //     impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
-            //
-            // A #[serde(borrow)] attribute enables borrowing that corresponds
-            // roughly to these impls:
-            //
-            //     impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, str>
-            //     impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]>
-            if is_cow(&field.ty, is_str) {
-                let mut path = syn::Path {
-                    leading_colon: None,
-                    segments: Punctuated::new(),
-                };
-                let span = Span::call_site();
-                path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("__private", span).into());
-                path.segments.push(Ident::new("de", span).into());
-                path.segments
-                    .push(Ident::new("borrow_cow_str", span).into());
-                let expr = syn::ExprPath {
-                    attrs: Vec::new(),
-                    qself: None,
-                    path,
-                };
-                deserialize_with.set_if_none(expr);
-            } else if is_cow(&field.ty, is_slice_u8) {
-                let mut path = syn::Path {
-                    leading_colon: None,
-                    segments: Punctuated::new(),
-                };
-                let span = Span::call_site();
-                path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("__private", span).into());
-                path.segments.push(Ident::new("de", span).into());
-                path.segments
-                    .push(Ident::new("borrow_cow_bytes", span).into());
-                let expr = syn::ExprPath {
-                    attrs: Vec::new(),
-                    qself: None,
-                    path,
-                };
-                deserialize_with.set_if_none(expr);
-            }
-        } else if is_implicitly_borrowed(&field.ty) {
-            // Types &str and &[u8] are always implicitly borrowed. No need for
-            // a #[serde(borrow)].
-            collect_lifetimes(&field.ty, &mut borrowed_lifetimes);
-        }
-
-        Field {
-            name: Name::from_attrs(ident, ser_name, de_name, Some(de_aliases)),
-            skip_serializing: skip_serializing.get(),
-            skip_deserializing: skip_deserializing.get(),
-            skip_serializing_if: skip_serializing_if.get(),
-            default: default.get().unwrap_or(Default::None),
-            serialize_with: serialize_with.get(),
-            deserialize_with: deserialize_with.get(),
-            ser_bound: ser_bound.get(),
-            de_bound: de_bound.get(),
-            borrowed_lifetimes,
-            getter: getter.get(),
-            flatten: flatten.get(),
-            transparent: false,
-        }
-    }
-
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn aliases(&self) -> Vec<String> {
-        self.name.deserialize_aliases()
-    }
-
-    pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
-        if !self.name.serialize_renamed {
-            self.name.serialize = rules.serialize.apply_to_field(&self.name.serialize);
-        }
-        if !self.name.deserialize_renamed {
-            self.name.deserialize = rules.deserialize.apply_to_field(&self.name.deserialize);
-        }
-    }
-
-    pub fn skip_serializing(&self) -> bool {
-        self.skip_serializing
-    }
-
-    pub fn skip_deserializing(&self) -> bool {
-        self.skip_deserializing
-    }
-
-    pub fn skip_serializing_if(&self) -> Option<&syn::ExprPath> {
-        self.skip_serializing_if.as_ref()
-    }
-
-    pub fn default(&self) -> &Default {
-        &self.default
-    }
-
-    pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
-        self.serialize_with.as_ref()
-    }
-
-    pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
-        self.deserialize_with.as_ref()
-    }
-
-    pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.ser_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
-        self.de_bound.as_ref().map(|vec| &vec[..])
-    }
-
-    pub fn borrowed_lifetimes(&self) -> &BTreeSet<syn::Lifetime> {
-        &self.borrowed_lifetimes
-    }
-
-    pub fn getter(&self) -> Option<&syn::ExprPath> {
-        self.getter.as_ref()
-    }
-
-    pub fn flatten(&self) -> bool {
-        self.flatten
-    }
-
-    pub fn transparent(&self) -> bool {
-        self.transparent
-    }
-
-    pub fn mark_transparent(&mut self) {
-        self.transparent = true;
-    }
-}
-
-type SerAndDe<T> = (Option<T>, Option<T>);
-
-fn get_ser_and_de<'a, 'b, T, F>(
-    cx: &'b Ctxt,
-    attr_name: Symbol,
-    metas: &'a Punctuated<syn::NestedMeta, Token![,]>,
-    f: F,
-) -> Result<(VecAttr<'b, T>, VecAttr<'b, T>), ()>
-where
-    T: 'a,
-    F: Fn(&Ctxt, Symbol, Symbol, &'a syn::Lit) -> Result<T, ()>,
-{
-    let mut ser_meta = VecAttr::none(cx, attr_name);
-    let mut de_meta = VecAttr::none(cx, attr_name);
-
-    for meta in metas {
-        match meta {
-            Meta(NameValue(meta)) if meta.path == SERIALIZE => {
-                if let Ok(v) = f(cx, attr_name, SERIALIZE, &meta.lit) {
-                    ser_meta.insert(&meta.path, v);
-                }
-            }
-
-            Meta(NameValue(meta)) if meta.path == DESERIALIZE => {
-                if let Ok(v) = f(cx, attr_name, DESERIALIZE, &meta.lit) {
-                    de_meta.insert(&meta.path, v);
-                }
-            }
-
-            _ => {
-                cx.error_spanned_by(
-                    meta,
-                    format!(
-                        "malformed {0} attribute, expected `{0}(serialize = ..., deserialize = ...)`",
-                        attr_name
-                    ),
-                );
-                return Err(());
-            }
-        }
-    }
-
-    Ok((ser_meta, de_meta))
-}
-
-fn get_renames<'a>(
-    cx: &Ctxt,
-    items: &'a Punctuated<syn::NestedMeta, Token![,]>,
-) -> Result<SerAndDe<&'a syn::LitStr>, ()> {
-    let (ser, de) = get_ser_and_de(cx, RENAME, items, get_lit_str2)?;
-    Ok((ser.at_most_one()?, de.at_most_one()?))
-}
-
-fn get_multiple_renames<'a>(
-    cx: &Ctxt,
-    items: &'a Punctuated<syn::NestedMeta, Token![,]>,
-) -> Result<(Option<&'a syn::LitStr>, Vec<&'a syn::LitStr>), ()> {
-    let (ser, de) = get_ser_and_de(cx, RENAME, items, get_lit_str2)?;
-    Ok((ser.at_most_one()?, de.get()))
-}
-
-fn get_where_predicates(
-    cx: &Ctxt,
-    items: &Punctuated<syn::NestedMeta, Token![,]>,
-) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()> {
-    let (ser, de) = get_ser_and_de(cx, BOUND, items, parse_lit_into_where)?;
-    Ok((ser.at_most_one()?, de.at_most_one()?))
-}
-
-pub fn get_serde_meta_items(cx: &Ctxt, attr: &syn::Attribute) -> Result<Vec<syn::NestedMeta>, ()> {
-    if attr.path != SERDE {
-        return Ok(Vec::new());
-    }
-
-    match attr.parse_meta() {
-        Ok(List(meta)) => Ok(meta.nested.into_iter().collect()),
-        Ok(other) => {
-            cx.error_spanned_by(other, "expected #[serde(...)]");
-            Err(())
-        }
-        Err(err) => {
-            cx.syn_error(err);
-            Err(())
-        }
-    }
-}
-
-fn get_lit_str<'a>(cx: &Ctxt, attr_name: Symbol, lit: &'a syn::Lit) -> Result<&'a syn::LitStr, ()> {
-    get_lit_str2(cx, attr_name, attr_name, lit)
-}
-
-fn get_lit_str2<'a>(
-    cx: &Ctxt,
-    attr_name: Symbol,
-    meta_item_name: Symbol,
-    lit: &'a syn::Lit,
-) -> Result<&'a syn::LitStr, ()> {
-    if let syn::Lit::Str(lit) = lit {
-        Ok(lit)
-    } else {
-        cx.error_spanned_by(
-            lit,
-            format!(
-                "expected serde {} attribute to be a string: `{} = \"...\"`",
-                attr_name, meta_item_name
-            ),
-        );
-        Err(())
-    }
-}
-
-fn parse_lit_into_path(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Path, ()> {
-    let string = get_lit_str(cx, attr_name, lit)?;
-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
-    })
-}
-
-fn parse_lit_into_expr_path(
-    cx: &Ctxt,
-    attr_name: Symbol,
-    lit: &syn::Lit,
-) -> Result<syn::ExprPath, ()> {
-    let string = get_lit_str(cx, attr_name, lit)?;
-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
-    })
-}
-
-fn parse_lit_into_where(
-    cx: &Ctxt,
-    attr_name: Symbol,
-    meta_item_name: Symbol,
-    lit: &syn::Lit,
-) -> Result<Vec<syn::WherePredicate>, ()> {
-    let string = get_lit_str2(cx, attr_name, meta_item_name, lit)?;
-    if string.value().is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let where_string = syn::LitStr::new(&format!("where {}", string.value()), string.span());
-
-    parse_lit_str::<syn::WhereClause>(&where_string)
-        .map(|wh| wh.predicates.into_iter().collect())
-        .map_err(|err| cx.error_spanned_by(lit, err))
-}
-
-fn parse_lit_into_ty(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Type, ()> {
-    let string = get_lit_str(cx, attr_name, lit)?;
-
-    parse_lit_str(string).map_err(|_| {
-        cx.error_spanned_by(
-            lit,
-            format!("failed to parse type: {} = {:?}", attr_name, string.value()),
-        );
-    })
-}
-
-// Parses a string literal like "'a + 'b + 'c" containing a nonempty list of
-// lifetimes separated by `+`.
-fn parse_lit_into_lifetimes(
-    cx: &Ctxt,
-    attr_name: Symbol,
-    lit: &syn::Lit,
-) -> Result<BTreeSet<syn::Lifetime>, ()> {
-    let string = get_lit_str(cx, attr_name, lit)?;
-    if string.value().is_empty() {
-        cx.error_spanned_by(lit, "at least one lifetime must be borrowed");
-        return Err(());
-    }
-
-    struct BorrowedLifetimes(Punctuated<syn::Lifetime, Token![+]>);
-
-    impl Parse for BorrowedLifetimes {
-        fn parse(input: ParseStream) -> parse::Result<Self> {
-            Punctuated::parse_separated_nonempty(input).map(BorrowedLifetimes)
-        }
-    }
-
-    if let Ok(BorrowedLifetimes(lifetimes)) = parse_lit_str(string) {
-        let mut set = BTreeSet::new();
-        for lifetime in lifetimes {
-            if !set.insert(lifetime.clone()) {
-                cx.error_spanned_by(lit, format!("duplicate borrowed lifetime `{}`", lifetime));
-            }
-        }
-        return Ok(set);
-    }
-
-    cx.error_spanned_by(
-        lit,
-        format!("failed to parse borrowed lifetimes: {:?}", string.value()),
-    );
-    Err(())
-}
-
-fn is_implicitly_borrowed(ty: &syn::Type) -> bool {
-    is_implicitly_borrowed_reference(ty) || is_option(ty, is_implicitly_borrowed_reference)
-}
-
-fn is_implicitly_borrowed_reference(ty: &syn::Type) -> bool {
-    is_reference(ty, is_str) || is_reference(ty, is_slice_u8)
-}
-
-// Whether the type looks like it might be `std::borrow::Cow<T>` where elem="T".
-// This can have false negatives and false positives.
-//
-// False negative:
-//
-//     use std::borrow::Cow as Pig;
-//
-//     #[derive(Deserialize)]
-//     struct S<'a> {
-//         #[serde(borrow)]
-//         pig: Pig<'a, str>,
-//     }
-//
-// False positive:
-//
-//     type str = [i16];
-//
-//     #[derive(Deserialize)]
-//     struct S<'a> {
-//         #[serde(borrow)]
-//         cow: Cow<'a, str>,
-//     }
-fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    let path = match ungroup(ty) {
-        syn::Type::Path(ty) => &ty.path,
-        _ => {
-            return false;
-        }
-    };
-    let seg = match path.segments.last() {
-        Some(seg) => seg,
-        None => {
-            return false;
-        }
-    };
-    let args = match &seg.arguments {
-        syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
-        _ => {
-            return false;
-        }
-    };
-    seg.ident == "Cow"
-        && args.len() == 2
-        && match (&args[0], &args[1]) {
-            (syn::GenericArgument::Lifetime(_), syn::GenericArgument::Type(arg)) => elem(arg),
-            _ => false,
-        }
-}
-
-fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    let path = match ungroup(ty) {
-        syn::Type::Path(ty) => &ty.path,
-        _ => {
-            return false;
-        }
-    };
-    let seg = match path.segments.last() {
-        Some(seg) => seg,
-        None => {
-            return false;
-        }
-    };
-    let args = match &seg.arguments {
-        syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
-        _ => {
-            return false;
-        }
-    };
-    seg.ident == "Option"
-        && args.len() == 1
-        && match &args[0] {
-            syn::GenericArgument::Type(arg) => elem(arg),
-            _ => false,
-        }
-}
-
-// Whether the type looks like it might be `&T` where elem="T". This can have
-// false negatives and false positives.
-//
-// False negative:
-//
-//     type Yarn = str;
-//
-//     #[derive(Deserialize)]
-//     struct S<'a> {
-//         r: &'a Yarn,
-//     }
-//
-// False positive:
-//
-//     type str = [i16];
-//
-//     #[derive(Deserialize)]
-//     struct S<'a> {
-//         r: &'a str,
-//     }
-fn is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    match ungroup(ty) {
-        syn::Type::Reference(ty) => ty.mutability.is_none() && elem(&ty.elem),
-        _ => false,
-    }
-}
-
-fn is_str(ty: &syn::Type) -> bool {
-    is_primitive_type(ty, "str")
-}
-
-fn is_slice_u8(ty: &syn::Type) -> bool {
-    match ungroup(ty) {
-        syn::Type::Slice(ty) => is_primitive_type(&ty.elem, "u8"),
-        _ => false,
-    }
-}
-
-fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
-    match ungroup(ty) {
-        syn::Type::Path(ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
-        _ => false,
-    }
-}
-
-fn is_primitive_path(path: &syn::Path, primitive: &str) -> bool {
-    path.leading_colon.is_none()
-        && path.segments.len() == 1
-        && path.segments[0].ident == primitive
-        && path.segments[0].arguments.is_empty()
-}
-
-// All lifetimes that this type could borrow from a Deserializer.
-//
-// For example a type `S<'a, 'b>` could borrow `'a` and `'b`. On the other hand
-// a type `for<'a> fn(&'a str)` could not borrow `'a` from the Deserializer.
-//
-// This is used when there is an explicit or implicit `#[serde(borrow)]`
-// attribute on the field so there must be at least one borrowable lifetime.
-fn borrowable_lifetimes(
-    cx: &Ctxt,
-    name: &str,
-    field: &syn::Field,
-) -> Result<BTreeSet<syn::Lifetime>, ()> {
-    let mut lifetimes = BTreeSet::new();
-    collect_lifetimes(&field.ty, &mut lifetimes);
-    if lifetimes.is_empty() {
-        cx.error_spanned_by(
-            field,
-            format!("field `{}` has no lifetimes to borrow", name),
-        );
-        Err(())
-    } else {
-        Ok(lifetimes)
-    }
-}
-
-fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
-    match ty {
-        syn::Type::Slice(ty) => {
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Array(ty) => {
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Ptr(ty) => {
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Reference(ty) => {
-            out.extend(ty.lifetime.iter().cloned());
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Tuple(ty) => {
-            for elem in &ty.elems {
-                collect_lifetimes(elem, out);
-            }
-        }
-        syn::Type::Path(ty) => {
-            if let Some(qself) = &ty.qself {
-                collect_lifetimes(&qself.ty, out);
-            }
-            for seg in &ty.path.segments {
-                if let syn::PathArguments::AngleBracketed(bracketed) = &seg.arguments {
-                    for arg in &bracketed.args {
-                        match arg {
-                            syn::GenericArgument::Lifetime(lifetime) => {
-                                out.insert(lifetime.clone());
-                            }
-                            syn::GenericArgument::Type(ty) => {
-                                collect_lifetimes(ty, out);
-                            }
-                            syn::GenericArgument::Binding(binding) => {
-                                collect_lifetimes(&binding.ty, out);
-                            }
-                            syn::GenericArgument::Constraint(_)
-                            | syn::GenericArgument::Const(_) => {}
-                        }
-                    }
-                }
-            }
-        }
-        syn::Type::Paren(ty) => {
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Group(ty) => {
-            collect_lifetimes(&ty.elem, out);
-        }
-        syn::Type::Macro(ty) => {
-            collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
-        }
-        syn::Type::BareFn(_)
-        | syn::Type::Never(_)
-        | syn::Type::TraitObject(_)
-        | syn::Type::ImplTrait(_)
-        | syn::Type::Infer(_)
-        | syn::Type::Verbatim(_) => {}
-
-        #[cfg(test)]
-        syn::Type::__TestExhaustive(_) => unimplemented!(),
-        #[cfg(not(test))]
-        _ => {}
-    }
-}
-
-fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>) {
-    let mut iter = tokens.into_iter();
-    while let Some(tt) = iter.next() {
-        match &tt {
-            TokenTree::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
-                if let Some(TokenTree::Ident(ident)) = iter.next() {
-                    out.insert(syn::Lifetime {
-                        apostrophe: op.span(),
-                        ident,
-                    });
-                }
-            }
-            TokenTree::Group(group) => {
-                let tokens = group.stream();
-                collect_lifetimes_from_tokens(tokens, out);
-            }
-            _ => {}
-        }
-    }
-}
-
-fn parse_lit_str<T>(s: &syn::LitStr) -> parse::Result<T>
-where
-    T: Parse,
-{
-    let tokens = spanned_tokens(s)?;
-    syn::parse2(tokens)
-}
-
-fn spanned_tokens(s: &syn::LitStr) -> parse::Result<TokenStream> {
-    let stream = syn::parse_str(&s.value())?;
-    Ok(respan(stream, s.span()))
-}
diff --git a/vendor/serde_derive/src/internals/case.rs b/vendor/serde_derive/src/internals/case.rs
deleted file mode 100644
index 55450516..00000000
--- a/vendor/serde_derive/src/internals/case.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-//! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the
-//! case of the source (e.g. `my-field`, `MY_FIELD`).
-
-// See https://users.rust-lang.org/t/psa-dealing-with-warning-unused-import-std-ascii-asciiext-in-today-s-nightly/13726
-#[allow(deprecated, unused_imports)]
-use std::ascii::AsciiExt;
-
-use std::fmt::{self, Debug, Display};
-
-use self::RenameRule::*;
-
-/// The different possible ways to change case of fields in a struct, or variants in an enum.
-#[derive(Copy, Clone, PartialEq)]
-pub enum RenameRule {
-    /// Don't apply a default rename rule.
-    None,
-    /// Rename direct children to "lowercase" style.
-    LowerCase,
-    /// Rename direct children to "UPPERCASE" style.
-    UpperCase,
-    /// Rename direct children to "PascalCase" style, as typically used for
-    /// enum variants.
-    PascalCase,
-    /// Rename direct children to "camelCase" style.
-    CamelCase,
-    /// Rename direct children to "snake_case" style, as commonly used for
-    /// fields.
-    SnakeCase,
-    /// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly
-    /// used for constants.
-    ScreamingSnakeCase,
-    /// Rename direct children to "kebab-case" style.
-    KebabCase,
-    /// Rename direct children to "SCREAMING-KEBAB-CASE" style.
-    ScreamingKebabCase,
-}
-
-static RENAME_RULES: &[(&str, RenameRule)] = &[
-    ("lowercase", LowerCase),
-    ("UPPERCASE", UpperCase),
-    ("PascalCase", PascalCase),
-    ("camelCase", CamelCase),
-    ("snake_case", SnakeCase),
-    ("SCREAMING_SNAKE_CASE", ScreamingSnakeCase),
-    ("kebab-case", KebabCase),
-    ("SCREAMING-KEBAB-CASE", ScreamingKebabCase),
-];
-
-impl RenameRule {
-    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
-        for (name, rule) in RENAME_RULES {
-            if rename_all_str == *name {
-                return Ok(*rule);
-            }
-        }
-        Err(ParseError {
-            unknown: rename_all_str,
-        })
-    }
-
-    /// Apply a renaming rule to an enum variant, returning the version expected in the source.
-    pub fn apply_to_variant(&self, variant: &str) -> String {
-        match *self {
-            None | PascalCase => variant.to_owned(),
-            LowerCase => variant.to_ascii_lowercase(),
-            UpperCase => variant.to_ascii_uppercase(),
-            CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..],
-            SnakeCase => {
-                let mut snake = String::new();
-                for (i, ch) in variant.char_indices() {
-                    if i > 0 && ch.is_uppercase() {
-                        snake.push('_');
-                    }
-                    snake.push(ch.to_ascii_lowercase());
-                }
-                snake
-            }
-            ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
-            KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase
-                .apply_to_variant(variant)
-                .replace('_', "-"),
-        }
-    }
-
-    /// Apply a renaming rule to a struct field, returning the version expected in the source.
-    pub fn apply_to_field(&self, field: &str) -> String {
-        match *self {
-            None | LowerCase | SnakeCase => field.to_owned(),
-            UpperCase => field.to_ascii_uppercase(),
-            PascalCase => {
-                let mut pascal = String::new();
-                let mut capitalize = true;
-                for ch in field.chars() {
-                    if ch == '_' {
-                        capitalize = true;
-                    } else if capitalize {
-                        pascal.push(ch.to_ascii_uppercase());
-                        capitalize = false;
-                    } else {
-                        pascal.push(ch);
-                    }
-                }
-                pascal
-            }
-            CamelCase => {
-                let pascal = PascalCase.apply_to_field(field);
-                pascal[..1].to_ascii_lowercase() + &pascal[1..]
-            }
-            ScreamingSnakeCase => field.to_ascii_uppercase(),
-            KebabCase => field.replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"),
-        }
-    }
-}
-
-pub struct ParseError<'a> {
-    unknown: &'a str,
-}
-
-impl<'a> Display for ParseError<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("unknown rename rule `rename_all = ")?;
-        Debug::fmt(self.unknown, f)?;
-        f.write_str("`, expected one of ")?;
-        for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
-            if i > 0 {
-                f.write_str(", ")?;
-            }
-            Debug::fmt(name, f)?;
-        }
-        Ok(())
-    }
-}
-
-#[test]
-fn rename_variants() {
-    for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[
-        (
-            "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
-        ),
-        (
-            "VeryTasty",
-            "verytasty",
-            "VERYTASTY",
-            "veryTasty",
-            "very_tasty",
-            "VERY_TASTY",
-            "very-tasty",
-            "VERY-TASTY",
-        ),
-        ("A", "a", "A", "a", "a", "A", "a", "A"),
-        ("Z42", "z42", "Z42", "z42", "z42", "Z42", "z42", "Z42"),
-    ] {
-        assert_eq!(None.apply_to_variant(original), original);
-        assert_eq!(LowerCase.apply_to_variant(original), lower);
-        assert_eq!(UpperCase.apply_to_variant(original), upper);
-        assert_eq!(PascalCase.apply_to_variant(original), original);
-        assert_eq!(CamelCase.apply_to_variant(original), camel);
-        assert_eq!(SnakeCase.apply_to_variant(original), snake);
-        assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
-        assert_eq!(KebabCase.apply_to_variant(original), kebab);
-        assert_eq!(
-            ScreamingKebabCase.apply_to_variant(original),
-            screaming_kebab
-        );
-    }
-}
-
-#[test]
-fn rename_fields() {
-    for &(original, upper, pascal, camel, screaming, kebab, screaming_kebab) in &[
-        (
-            "outcome", "OUTCOME", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
-        ),
-        (
-            "very_tasty",
-            "VERY_TASTY",
-            "VeryTasty",
-            "veryTasty",
-            "VERY_TASTY",
-            "very-tasty",
-            "VERY-TASTY",
-        ),
-        ("a", "A", "A", "a", "A", "a", "A"),
-        ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
-    ] {
-        assert_eq!(None.apply_to_field(original), original);
-        assert_eq!(UpperCase.apply_to_field(original), upper);
-        assert_eq!(PascalCase.apply_to_field(original), pascal);
-        assert_eq!(CamelCase.apply_to_field(original), camel);
-        assert_eq!(SnakeCase.apply_to_field(original), original);
-        assert_eq!(ScreamingSnakeCase.apply_to_field(original), screaming);
-        assert_eq!(KebabCase.apply_to_field(original), kebab);
-        assert_eq!(ScreamingKebabCase.apply_to_field(original), screaming_kebab);
-    }
-}
diff --git a/vendor/serde_derive/src/internals/check.rs b/vendor/serde_derive/src/internals/check.rs
deleted file mode 100644
index 0e2484a7..00000000
--- a/vendor/serde_derive/src/internals/check.rs
+++ /dev/null
@@ -1,420 +0,0 @@
-use internals::ast::{Container, Data, Field, Style};
-use internals::attr::{Identifier, TagType};
-use internals::{ungroup, Ctxt, Derive};
-use syn::{Member, Type};
-
-/// Cross-cutting checks that require looking at more than a single attrs
-/// object. Simpler checks should happen when parsing and building the attrs.
-pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
-    check_getter(cx, cont);
-    check_flatten(cx, cont);
-    check_identifier(cx, cont);
-    check_variant_skip_attrs(cx, cont);
-    check_internal_tag_field_name_conflict(cx, cont);
-    check_adjacent_tag_conflict(cx, cont);
-    check_transparent(cx, cont, derive);
-    check_from_and_try_from(cx, cont);
-}
-
-/// Getters are only allowed inside structs (not enums) with the `remote`
-/// attribute.
-fn check_getter(cx: &Ctxt, cont: &Container) {
-    match cont.data {
-        Data::Enum(_) => {
-            if cont.data.has_getter() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(getter = \"...\")] is not allowed in an enum",
-                );
-            }
-        }
-        Data::Struct(_, _) => {
-            if cont.data.has_getter() && cont.attrs.remote().is_none() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(getter = \"...\")] can only be used in structs that have #[serde(remote = \"...\")]",
-                );
-            }
-        }
-    }
-}
-
-/// Flattening has some restrictions we can test.
-fn check_flatten(cx: &Ctxt, cont: &Container) {
-    match &cont.data {
-        Data::Enum(variants) => {
-            for variant in variants {
-                for field in &variant.fields {
-                    check_flatten_field(cx, variant.style, field);
-                }
-            }
-        }
-        Data::Struct(style, fields) => {
-            for field in fields {
-                check_flatten_field(cx, *style, field);
-            }
-        }
-    }
-}
-
-fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
-    if !field.attrs.flatten() {
-        return;
-    }
-    match style {
-        Style::Tuple => {
-            cx.error_spanned_by(
-                field.original,
-                "#[serde(flatten)] cannot be used on tuple structs",
-            );
-        }
-        Style::Newtype => {
-            cx.error_spanned_by(
-                field.original,
-                "#[serde(flatten)] cannot be used on newtype structs",
-            );
-        }
-        _ => {}
-    }
-}
-
-/// The `other` attribute must be used at most once and it must be the last
-/// variant of an enum.
-///
-/// Inside a `variant_identifier` all variants must be unit variants. Inside a
-/// `field_identifier` all but possibly one variant must be unit variants. The
-/// last variant may be a newtype variant which is an implicit "other" case.
-fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return;
-        }
-    };
-
-    for (i, variant) in variants.iter().enumerate() {
-        match (
-            variant.style,
-            cont.attrs.identifier(),
-            variant.attrs.other(),
-            cont.attrs.tag(),
-        ) {
-            // The `other` attribute may not be used in a variant_identifier.
-            (_, Identifier::Variant, true, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] may not be used on a variant identifier",
-                );
-            }
-
-            // Variant with `other` attribute cannot appear in untagged enum
-            (_, Identifier::No, true, &TagType::None) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] cannot appear on untagged enum",
-                );
-            }
-
-            // Variant with `other` attribute must be the last one.
-            (Style::Unit, Identifier::Field, true, _) | (Style::Unit, Identifier::No, true, _) => {
-                if i < variants.len() - 1 {
-                    cx.error_spanned_by(
-                        variant.original,
-                        "#[serde(other)] must be on the last variant",
-                    );
-                }
-            }
-
-            // Variant with `other` attribute must be a unit variant.
-            (_, Identifier::Field, true, _) | (_, Identifier::No, true, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] must be on a unit variant",
-                );
-            }
-
-            // Any sort of variant is allowed if this is not an identifier.
-            (_, Identifier::No, false, _) => {}
-
-            // Unit variant without `other` attribute is always fine.
-            (Style::Unit, _, false, _) => {}
-
-            // The last field is allowed to be a newtype catch-all.
-            (Style::Newtype, Identifier::Field, false, _) => {
-                if i < variants.len() - 1 {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!("`{}` must be the last variant", variant.ident),
-                    );
-                }
-            }
-
-            (_, Identifier::Field, false, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(field_identifier)] may only contain unit variants",
-                );
-            }
-
-            (_, Identifier::Variant, false, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(variant_identifier)] may only contain unit variants",
-                );
-            }
-        }
-    }
-}
-
-/// Skip-(de)serializing attributes are not allowed on variants marked
-/// (de)serialize_with.
-fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return;
-        }
-    };
-
-    for variant in variants.iter() {
-        if variant.attrs.serialize_with().is_some() {
-            if variant.attrs.skip_serializing() {
-                cx.error_spanned_by(
-                    variant.original,
-                    format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]",
-                        variant.ident
-                    ),
-                );
-            }
-
-            for field in &variant.fields {
-                let member = member_message(&field.member);
-
-                if field.attrs.skip_serializing() {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-
-                if field.attrs.skip_serializing_if().is_some() {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing_if)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-            }
-        }
-
-        if variant.attrs.deserialize_with().is_some() {
-            if variant.attrs.skip_deserializing() {
-                cx.error_spanned_by(
-                    variant.original,
-                    format!(
-                        "variant `{}` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]",
-                        variant.ident
-                    ),
-                );
-            }
-
-            for field in &variant.fields {
-                if field.attrs.skip_deserializing() {
-                    let member = member_message(&field.member);
-
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(deserialize_with)] and a field {} marked with #[serde(skip_deserializing)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-            }
-        }
-    }
-}
-
-/// The tag of an internally-tagged struct variant must not be
-/// the same as either one of its fields, as this would result in
-/// duplicate keys in the serialized output and/or ambiguity in
-/// the to-be-deserialized input.
-fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => return,
-    };
-
-    let tag = match cont.attrs.tag() {
-        TagType::Internal { tag } => tag.as_str(),
-        TagType::External | TagType::Adjacent { .. } | TagType::None => return,
-    };
-
-    let diagnose_conflict = || {
-        cx.error_spanned_by(
-            cont.original,
-            format!("variant field name `{}` conflicts with internal tag", tag),
-        );
-    };
-
-    for variant in variants {
-        match variant.style {
-            Style::Struct => {
-                for field in &variant.fields {
-                    let check_ser = !field.attrs.skip_serializing();
-                    let check_de = !field.attrs.skip_deserializing();
-                    let name = field.attrs.name();
-                    let ser_name = name.serialize_name();
-
-                    if check_ser && ser_name == tag {
-                        diagnose_conflict();
-                        return;
-                    }
-
-                    for de_name in field.attrs.aliases() {
-                        if check_de && de_name == tag {
-                            diagnose_conflict();
-                            return;
-                        }
-                    }
-                }
-            }
-            Style::Unit | Style::Newtype | Style::Tuple => {}
-        }
-    }
-}
-
-/// In the case of adjacently-tagged enums, the type and the
-/// contents tag must differ, for the same reason.
-fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
-    let (type_tag, content_tag) = match cont.attrs.tag() {
-        TagType::Adjacent { tag, content } => (tag, content),
-        TagType::Internal { .. } | TagType::External | TagType::None => return,
-    };
-
-    if type_tag == content_tag {
-        cx.error_spanned_by(
-            cont.original,
-            format!(
-                "enum tags `{}` for type and content conflict with each other",
-                type_tag
-            ),
-        );
-    }
-}
-
-/// Enums and unit structs cannot be transparent.
-fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
-    if !cont.attrs.transparent() {
-        return;
-    }
-
-    if cont.attrs.type_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(from = \"...\")]",
-        );
-    }
-
-    if cont.attrs.type_try_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(try_from = \"...\")]",
-        );
-    }
-
-    if cont.attrs.type_into().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(into = \"...\")]",
-        );
-    }
-
-    let fields = match &mut cont.data {
-        Data::Enum(_) => {
-            cx.error_spanned_by(
-                cont.original,
-                "#[serde(transparent)] is not allowed on an enum",
-            );
-            return;
-        }
-        Data::Struct(Style::Unit, _) => {
-            cx.error_spanned_by(
-                cont.original,
-                "#[serde(transparent)] is not allowed on a unit struct",
-            );
-            return;
-        }
-        Data::Struct(_, fields) => fields,
-    };
-
-    let mut transparent_field = None;
-
-    for field in fields {
-        if allow_transparent(field, derive) {
-            if transparent_field.is_some() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires struct to have at most one transparent field",
-                );
-                return;
-            }
-            transparent_field = Some(field);
-        }
-    }
-
-    match transparent_field {
-        Some(transparent_field) => transparent_field.attrs.mark_transparent(),
-        None => match derive {
-            Derive::Serialize => {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires at least one field that is not skipped",
-                );
-            }
-            Derive::Deserialize => {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires at least one field that is neither skipped nor has a default",
-                );
-            }
-        },
-    }
-}
-
-fn member_message(member: &Member) -> String {
-    match member {
-        Member::Named(ident) => format!("`{}`", ident),
-        Member::Unnamed(i) => format!("#{}", i.index),
-    }
-}
-
-fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ty) = ungroup(field.ty) {
-        if let Some(seg) = ty.path.segments.last() {
-            if seg.ident == "PhantomData" {
-                return false;
-            }
-        }
-    }
-
-    match derive {
-        Derive::Serialize => !field.attrs.skip_serializing(),
-        Derive::Deserialize => !field.attrs.skip_deserializing() && field.attrs.default().is_none(),
-    }
-}
-
-fn check_from_and_try_from(cx: &Ctxt, cont: &mut Container) {
-    if cont.attrs.type_from().is_some() && cont.attrs.type_try_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(from = \"...\")] and #[serde(try_from = \"...\")] conflict with each other",
-        );
-    }
-}
diff --git a/vendor/serde_derive/src/internals/ctxt.rs b/vendor/serde_derive/src/internals/ctxt.rs
deleted file mode 100644
index d692c2a4..00000000
--- a/vendor/serde_derive/src/internals/ctxt.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use quote::ToTokens;
-use std::cell::RefCell;
-use std::fmt::Display;
-use std::thread;
-use syn;
-
-/// A type to collect errors together and format them.
-///
-/// Dropping this object will cause a panic. It must be consumed using `check`.
-///
-/// References can be shared since this type uses run-time exclusive mut checking.
-#[derive(Default)]
-pub struct Ctxt {
-    // The contents will be set to `None` during checking. This is so that checking can be
-    // enforced.
-    errors: RefCell<Option<Vec<syn::Error>>>,
-}
-
-impl Ctxt {
-    /// Create a new context object.
-    ///
-    /// This object contains no errors, but will still trigger a panic if it is not `check`ed.
-    pub fn new() -> Self {
-        Ctxt {
-            errors: RefCell::new(Some(Vec::new())),
-        }
-    }
-
-    /// Add an error to the context object with a tokenenizable object.
-    ///
-    /// The object is used for spanning in error messages.
-    pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
-        self.errors
-            .borrow_mut()
-            .as_mut()
-            .unwrap()
-            // Curb monomorphization from generating too many identical methods.
-            .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
-    }
-
-    /// Add one of Syn's parse errors.
-    pub fn syn_error(&self, err: syn::Error) {
-        self.errors.borrow_mut().as_mut().unwrap().push(err);
-    }
-
-    /// Consume this object, producing a formatted error string if there are errors.
-    pub fn check(self) -> Result<(), Vec<syn::Error>> {
-        let errors = self.errors.borrow_mut().take().unwrap();
-        match errors.len() {
-            0 => Ok(()),
-            _ => Err(errors),
-        }
-    }
-}
-
-impl Drop for Ctxt {
-    fn drop(&mut self) {
-        if !thread::panicking() && self.errors.borrow().is_some() {
-            panic!("forgot to check for errors");
-        }
-    }
-}
diff --git a/vendor/serde_derive/src/internals/mod.rs b/vendor/serde_derive/src/internals/mod.rs
deleted file mode 100644
index 5e9f416c..00000000
--- a/vendor/serde_derive/src/internals/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-pub mod ast;
-pub mod attr;
-
-mod ctxt;
-pub use self::ctxt::Ctxt;
-
-mod receiver;
-pub use self::receiver::replace_receiver;
-
-mod case;
-mod check;
-mod respan;
-mod symbol;
-
-use syn::Type;
-
-#[derive(Copy, Clone)]
-pub enum Derive {
-    Serialize,
-    Deserialize,
-}
-
-pub fn ungroup(mut ty: &Type) -> &Type {
-    while let Type::Group(group) = ty {
-        ty = &group.elem;
-    }
-    ty
-}
diff --git a/vendor/serde_derive/src/internals/receiver.rs b/vendor/serde_derive/src/internals/receiver.rs
deleted file mode 100644
index 2b722d8f..00000000
--- a/vendor/serde_derive/src/internals/receiver.rs
+++ /dev/null
@@ -1,287 +0,0 @@
-use internals::respan::respan;
-use proc_macro2::Span;
-use quote::ToTokens;
-use std::mem;
-use syn::punctuated::Punctuated;
-use syn::{
-    parse_quote, Data, DeriveInput, Expr, ExprPath, GenericArgument, GenericParam, Generics, Macro,
-    Path, PathArguments, QSelf, ReturnType, Type, TypeParamBound, TypePath, WherePredicate,
-};
-
-pub fn replace_receiver(input: &mut DeriveInput) {
-    let self_ty = {
-        let ident = &input.ident;
-        let ty_generics = input.generics.split_for_impl().1;
-        parse_quote!(#ident #ty_generics)
-    };
-    let mut visitor = ReplaceReceiver(&self_ty);
-    visitor.visit_generics_mut(&mut input.generics);
-    visitor.visit_data_mut(&mut input.data);
-}
-
-struct ReplaceReceiver<'a>(&'a TypePath);
-
-impl ReplaceReceiver<'_> {
-    fn self_ty(&self, span: Span) -> TypePath {
-        let tokens = self.0.to_token_stream();
-        let respanned = respan(tokens, span);
-        syn::parse2(respanned).unwrap()
-    }
-
-    fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
-        if path.leading_colon.is_some() || path.segments[0].ident != "Self" {
-            return;
-        }
-
-        if path.segments.len() == 1 {
-            self.self_to_expr_path(path);
-            return;
-        }
-
-        let span = path.segments[0].ident.span();
-        *qself = Some(QSelf {
-            lt_token: Token![<](span),
-            ty: Box::new(Type::Path(self.self_ty(span))),
-            position: 0,
-            as_token: None,
-            gt_token: Token![>](span),
-        });
-
-        path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap());
-
-        let segments = mem::replace(&mut path.segments, Punctuated::new());
-        path.segments = segments.into_pairs().skip(1).collect();
-    }
-
-    fn self_to_expr_path(&self, path: &mut Path) {
-        let self_ty = self.self_ty(path.segments[0].ident.span());
-        let variant = mem::replace(path, self_ty.path);
-        for segment in &mut path.segments {
-            if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments {
-                if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() {
-                    bracketed.colon2_token = Some(<Token![::]>::default());
-                }
-            }
-        }
-        if variant.segments.len() > 1 {
-            path.segments.push_punct(<Token![::]>::default());
-            path.segments.extend(variant.segments.into_pairs().skip(1));
-        }
-    }
-}
-
-impl ReplaceReceiver<'_> {
-    // `Self` -> `Receiver`
-    fn visit_type_mut(&mut self, ty: &mut Type) {
-        let span = if let Type::Path(node) = ty {
-            if node.qself.is_none() && node.path.is_ident("Self") {
-                node.path.segments[0].ident.span()
-            } else {
-                self.visit_type_path_mut(node);
-                return;
-            }
-        } else {
-            self.visit_type_mut_impl(ty);
-            return;
-        };
-        *ty = self.self_ty(span).into();
-    }
-
-    // `Self::Assoc` -> `<Receiver>::Assoc`
-    fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
-        if ty.qself.is_none() {
-            self.self_to_qself(&mut ty.qself, &mut ty.path);
-        }
-        self.visit_type_path_mut_impl(ty);
-    }
-
-    // `Self::method` -> `<Receiver>::method`
-    fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
-        if expr.qself.is_none() {
-            self.self_to_qself(&mut expr.qself, &mut expr.path);
-        }
-        self.visit_expr_path_mut_impl(expr);
-    }
-
-    // Everything below is simply traversing the syntax tree.
-
-    fn visit_type_mut_impl(&mut self, ty: &mut Type) {
-        match ty {
-            Type::Array(ty) => {
-                self.visit_type_mut(&mut ty.elem);
-                self.visit_expr_mut(&mut ty.len);
-            }
-            Type::BareFn(ty) => {
-                for arg in &mut ty.inputs {
-                    self.visit_type_mut(&mut arg.ty);
-                }
-                self.visit_return_type_mut(&mut ty.output);
-            }
-            Type::Group(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::ImplTrait(ty) => {
-                for bound in &mut ty.bounds {
-                    self.visit_type_param_bound_mut(bound);
-                }
-            }
-            Type::Macro(ty) => self.visit_macro_mut(&mut ty.mac),
-            Type::Paren(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Path(ty) => {
-                if let Some(qself) = &mut ty.qself {
-                    self.visit_type_mut(&mut qself.ty);
-                }
-                self.visit_path_mut(&mut ty.path);
-            }
-            Type::Ptr(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Reference(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Slice(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::TraitObject(ty) => {
-                for bound in &mut ty.bounds {
-                    self.visit_type_param_bound_mut(bound);
-                }
-            }
-            Type::Tuple(ty) => {
-                for elem in &mut ty.elems {
-                    self.visit_type_mut(elem);
-                }
-            }
-
-            Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
-
-            #[cfg(test)]
-            Type::__TestExhaustive(_) => unimplemented!(),
-            #[cfg(not(test))]
-            _ => {}
-        }
-    }
-
-    fn visit_type_path_mut_impl(&mut self, ty: &mut TypePath) {
-        if let Some(qself) = &mut ty.qself {
-            self.visit_type_mut(&mut qself.ty);
-        }
-        self.visit_path_mut(&mut ty.path);
-    }
-
-    fn visit_expr_path_mut_impl(&mut self, expr: &mut ExprPath) {
-        if let Some(qself) = &mut expr.qself {
-            self.visit_type_mut(&mut qself.ty);
-        }
-        self.visit_path_mut(&mut expr.path);
-    }
-
-    fn visit_path_mut(&mut self, path: &mut Path) {
-        for segment in &mut path.segments {
-            self.visit_path_arguments_mut(&mut segment.arguments);
-        }
-    }
-
-    fn visit_path_arguments_mut(&mut self, arguments: &mut PathArguments) {
-        match arguments {
-            PathArguments::None => {}
-            PathArguments::AngleBracketed(arguments) => {
-                for arg in &mut arguments.args {
-                    match arg {
-                        GenericArgument::Type(arg) => self.visit_type_mut(arg),
-                        GenericArgument::Binding(arg) => self.visit_type_mut(&mut arg.ty),
-                        GenericArgument::Lifetime(_)
-                        | GenericArgument::Constraint(_)
-                        | GenericArgument::Const(_) => {}
-                    }
-                }
-            }
-            PathArguments::Parenthesized(arguments) => {
-                for argument in &mut arguments.inputs {
-                    self.visit_type_mut(argument);
-                }
-                self.visit_return_type_mut(&mut arguments.output);
-            }
-        }
-    }
-
-    fn visit_return_type_mut(&mut self, return_type: &mut ReturnType) {
-        match return_type {
-            ReturnType::Default => {}
-            ReturnType::Type(_, output) => self.visit_type_mut(output),
-        }
-    }
-
-    fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
-        match bound {
-            TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
-            TypeParamBound::Lifetime(_) => {}
-        }
-    }
-
-    fn visit_generics_mut(&mut self, generics: &mut Generics) {
-        for param in &mut generics.params {
-            match param {
-                GenericParam::Type(param) => {
-                    for bound in &mut param.bounds {
-                        self.visit_type_param_bound_mut(bound);
-                    }
-                }
-                GenericParam::Lifetime(_) | GenericParam::Const(_) => {}
-            }
-        }
-        if let Some(where_clause) = &mut generics.where_clause {
-            for predicate in &mut where_clause.predicates {
-                match predicate {
-                    WherePredicate::Type(predicate) => {
-                        self.visit_type_mut(&mut predicate.bounded_ty);
-                        for bound in &mut predicate.bounds {
-                            self.visit_type_param_bound_mut(bound);
-                        }
-                    }
-                    WherePredicate::Lifetime(_) | WherePredicate::Eq(_) => {}
-                }
-            }
-        }
-    }
-
-    fn visit_data_mut(&mut self, data: &mut Data) {
-        match data {
-            Data::Struct(data) => {
-                for field in &mut data.fields {
-                    self.visit_type_mut(&mut field.ty);
-                }
-            }
-            Data::Enum(data) => {
-                for variant in &mut data.variants {
-                    for field in &mut variant.fields {
-                        self.visit_type_mut(&mut field.ty);
-                    }
-                }
-            }
-            Data::Union(_) => {}
-        }
-    }
-
-    fn visit_expr_mut(&mut self, expr: &mut Expr) {
-        match expr {
-            Expr::Binary(expr) => {
-                self.visit_expr_mut(&mut expr.left);
-                self.visit_expr_mut(&mut expr.right);
-            }
-            Expr::Call(expr) => {
-                self.visit_expr_mut(&mut expr.func);
-                for arg in &mut expr.args {
-                    self.visit_expr_mut(arg);
-                }
-            }
-            Expr::Cast(expr) => {
-                self.visit_expr_mut(&mut expr.expr);
-                self.visit_type_mut(&mut expr.ty);
-            }
-            Expr::Field(expr) => self.visit_expr_mut(&mut expr.base),
-            Expr::Index(expr) => {
-                self.visit_expr_mut(&mut expr.expr);
-                self.visit_expr_mut(&mut expr.index);
-            }
-            Expr::Paren(expr) => self.visit_expr_mut(&mut expr.expr),
-            Expr::Path(expr) => self.visit_expr_path_mut(expr),
-            Expr::Unary(expr) => self.visit_expr_mut(&mut expr.expr),
-            _ => {}
-        }
-    }
-
-    fn visit_macro_mut(&mut self, _mac: &mut Macro) {}
-}
diff --git a/vendor/serde_derive/src/internals/respan.rs b/vendor/serde_derive/src/internals/respan.rs
deleted file mode 100644
index dcec7017..00000000
--- a/vendor/serde_derive/src/internals/respan.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use proc_macro2::{Group, Span, TokenStream, TokenTree};
-
-pub(crate) fn respan(stream: TokenStream, span: Span) -> TokenStream {
-    stream
-        .into_iter()
-        .map(|token| respan_token(token, span))
-        .collect()
-}
-
-fn respan_token(mut token: TokenTree, span: Span) -> TokenTree {
-    if let TokenTree::Group(g) = &mut token {
-        *g = Group::new(g.delimiter(), respan(g.stream(), span));
-    }
-    token.set_span(span);
-    token
-}
diff --git a/vendor/serde_derive/src/internals/symbol.rs b/vendor/serde_derive/src/internals/symbol.rs
deleted file mode 100644
index 1fedd275..00000000
--- a/vendor/serde_derive/src/internals/symbol.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use std::fmt::{self, Display};
-use syn::{Ident, Path};
-
-#[derive(Copy, Clone)]
-pub struct Symbol(&'static str);
-
-pub const ALIAS: Symbol = Symbol("alias");
-pub const BORROW: Symbol = Symbol("borrow");
-pub const BOUND: Symbol = Symbol("bound");
-pub const CONTENT: Symbol = Symbol("content");
-pub const CRATE: Symbol = Symbol("crate");
-pub const DEFAULT: Symbol = Symbol("default");
-pub const DENY_UNKNOWN_FIELDS: Symbol = Symbol("deny_unknown_fields");
-pub const DESERIALIZE: Symbol = Symbol("deserialize");
-pub const DESERIALIZE_WITH: Symbol = Symbol("deserialize_with");
-pub const FIELD_IDENTIFIER: Symbol = Symbol("field_identifier");
-pub const FLATTEN: Symbol = Symbol("flatten");
-pub const FROM: Symbol = Symbol("from");
-pub const GETTER: Symbol = Symbol("getter");
-pub const INTO: Symbol = Symbol("into");
-pub const OTHER: Symbol = Symbol("other");
-pub const REMOTE: Symbol = Symbol("remote");
-pub const RENAME: Symbol = Symbol("rename");
-pub const RENAME_ALL: Symbol = Symbol("rename_all");
-pub const SERDE: Symbol = Symbol("serde");
-pub const SERIALIZE: Symbol = Symbol("serialize");
-pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with");
-pub const SKIP: Symbol = Symbol("skip");
-pub const SKIP_DESERIALIZING: Symbol = Symbol("skip_deserializing");
-pub const SKIP_SERIALIZING: Symbol = Symbol("skip_serializing");
-pub const SKIP_SERIALIZING_IF: Symbol = Symbol("skip_serializing_if");
-pub const TAG: Symbol = Symbol("tag");
-pub const TRANSPARENT: Symbol = Symbol("transparent");
-pub const TRY_FROM: Symbol = Symbol("try_from");
-pub const UNTAGGED: Symbol = Symbol("untagged");
-pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
-pub const WITH: Symbol = Symbol("with");
-pub const EXPECTING: Symbol = Symbol("expecting");
-
-impl PartialEq<Symbol> for Ident {
-    fn eq(&self, word: &Symbol) -> bool {
-        self == word.0
-    }
-}
-
-impl<'a> PartialEq<Symbol> for &'a Ident {
-    fn eq(&self, word: &Symbol) -> bool {
-        *self == word.0
-    }
-}
-
-impl PartialEq<Symbol> for Path {
-    fn eq(&self, word: &Symbol) -> bool {
-        self.is_ident(word.0)
-    }
-}
-
-impl<'a> PartialEq<Symbol> for &'a Path {
-    fn eq(&self, word: &Symbol) -> bool {
-        self.is_ident(word.0)
-    }
-}
-
-impl Display for Symbol {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(self.0)
-    }
-}
diff --git a/vendor/serde_derive/src/lib.rs b/vendor/serde_derive/src/lib.rs
deleted file mode 100644
index e7885c7e..00000000
--- a/vendor/serde_derive/src/lib.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-//! This crate provides Serde's two derive macros.
-//!
-//! ```edition2018
-//! # use serde_derive::{Serialize, Deserialize};
-//! #
-//! #[derive(Serialize, Deserialize)]
-//! # struct S;
-//! #
-//! # fn main() {}
-//! ```
-//!
-//! Please refer to [https://serde.rs/derive.html] for how to set this up.
-//!
-//! [https://serde.rs/derive.html]: https://serde.rs/derive.html
-
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.132")]
-#![allow(unknown_lints, bare_trait_objects)]
-// Ignored clippy lints
-#![allow(
-    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
-    clippy::branches_sharing_code,
-    clippy::cognitive_complexity,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
-    clippy::collapsible_match,
-    clippy::enum_variant_names,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
-    clippy::manual_map,
-    clippy::match_like_matches_macro,
-    clippy::needless_pass_by_value,
-    clippy::too_many_arguments,
-    clippy::trivially_copy_pass_by_ref,
-    clippy::used_underscore_binding,
-    clippy::wildcard_in_or_patterns,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-    clippy::unnested_or_patterns,
-)]
-// Ignored clippy_pedantic lints
-#![allow(
-    clippy::cast_possible_truncation,
-    clippy::checked_conversions,
-    clippy::doc_markdown,
-    clippy::enum_glob_use,
-    clippy::indexing_slicing,
-    clippy::items_after_statements,
-    clippy::let_underscore_drop,
-    clippy::manual_assert,
-    clippy::map_err_ignore,
-    clippy::match_same_arms,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
-    clippy::match_wildcard_for_single_variants,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::option_if_let_else,
-    clippy::similar_names,
-    clippy::single_match_else,
-    clippy::struct_excessive_bools,
-    clippy::too_many_lines,
-    clippy::unseparated_literal_suffix,
-    clippy::unused_self,
-    clippy::use_self,
-    clippy::wildcard_imports
-)]
-
-#[macro_use]
-extern crate quote;
-#[macro_use]
-extern crate syn;
-
-extern crate proc_macro;
-extern crate proc_macro2;
-
-mod internals;
-
-use proc_macro::TokenStream;
-use syn::DeriveInput;
-
-#[macro_use]
-mod bound;
-#[macro_use]
-mod fragment;
-
-mod de;
-mod dummy;
-mod pretend;
-mod ser;
-mod try;
-
-#[proc_macro_derive(Serialize, attributes(serde))]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
-        .into()
-}
-
-#[proc_macro_derive(Deserialize, attributes(serde))]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&mut input)
-        .unwrap_or_else(to_compile_errors)
-        .into()
-}
-
-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
-    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
-    quote!(#(#compile_errors)*)
-}
diff --git a/vendor/serde_derive/src/pretend.rs b/vendor/serde_derive/src/pretend.rs
deleted file mode 100644
index 3af6a66f..00000000
--- a/vendor/serde_derive/src/pretend.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::format_ident;
-
-use internals::ast::{Container, Data, Field, Style, Variant};
-
-// Suppress dead_code warnings that would otherwise appear when using a remote
-// derive. Other than this pretend code, a struct annotated with remote derive
-// never has its fields referenced and an enum annotated with remote derive
-// never has its variants constructed.
-//
-//     warning: field is never used: `i`
-//      --> src/main.rs:4:20
-//       |
-//     4 | struct StructDef { i: i32 }
-//       |                    ^^^^^^
-//
-//     warning: variant is never constructed: `V`
-//      --> src/main.rs:8:16
-//       |
-//     8 | enum EnumDef { V }
-//       |                ^
-//
-pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
-    let pretend_fields = pretend_fields_used(cont, is_packed);
-    let pretend_variants = pretend_variants_used(cont);
-
-    quote! {
-        #pretend_fields
-        #pretend_variants
-    }
-}
-
-// For structs with named fields, expands to:
-//
-//     match None::<&T> {
-//         Some(T { a: __v0, b: __v1 }) => {}
-//         _ => {}
-//     }
-//
-// For packed structs on sufficiently new rustc, expands to:
-//
-//     match None::<&T> {
-//         Some(__v @ T { a: _, b: _ }) => {
-//             let _ = addr_of!(__v.a);
-//             let _ = addr_of!(__v.b);
-//         }
-//         _ => {}
-//     }
-//
-// For packed structs on older rustc, we assume Sized and !Drop, and expand to:
-//
-//     match None::<T> {
-//         Some(T { a: __v0, b: __v1 }) => {}
-//         _ => {}
-//     }
-//
-// For enums, expands to the following but only including struct variants:
-//
-//     match None::<&T> {
-//         Some(T::A { a: __v0 }) => {}
-//         Some(T::B { b: __v0 }) => {}
-//         _ => {}
-//     }
-//
-fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
-    match &cont.data {
-        Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
-        Data::Struct(Style::Struct, fields) => {
-            if is_packed {
-                pretend_fields_used_struct_packed(cont, fields)
-            } else {
-                pretend_fields_used_struct(cont, fields)
-            }
-        }
-        Data::Struct(_, _) => quote!(),
-    }
-}
-
-fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let members = fields.iter().map(|field| &field.member);
-    let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-
-    quote! {
-        match _serde::__private::None::<&#type_ident #ty_generics> {
-            _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
-            _ => {}
-        }
-    }
-}
-
-fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
-
-    #[cfg(ptr_addr_of)]
-    {
-        quote! {
-            match _serde::__private::None::<&#type_ident #ty_generics> {
-                _serde::__private::Some(__v @ #type_ident { #(#members: _),* }) => {
-                    #(
-                        let _ = _serde::__private::ptr::addr_of!(__v.#members);
-                    )*
-                }
-                _ => {}
-            }
-        }
-    }
-
-    #[cfg(not(ptr_addr_of))]
-    {
-        let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-
-        quote! {
-            match _serde::__private::None::<#type_ident #ty_generics> {
-                _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
-                _ => {}
-            }
-        }
-    }
-}
-
-fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let patterns = variants
-        .iter()
-        .filter_map(|variant| match variant.style {
-            Style::Struct => {
-                let variant_ident = &variant.ident;
-                let members = variant.fields.iter().map(|field| &field.member);
-                let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
-            }
-            _ => None,
-        })
-        .collect::<Vec<_>>();
-
-    quote! {
-        match _serde::__private::None::<&#type_ident #ty_generics> {
-            #(
-                _serde::__private::Some(#patterns) => {}
-            )*
-            _ => {}
-        }
-    }
-}
-
-// Expands to one of these per enum variant:
-//
-//     match None {
-//         Some((__v0, __v1,)) => {
-//             let _ = E::V { a: __v0, b: __v1 };
-//         }
-//         _ => {}
-//     }
-//
-fn pretend_variants_used(cont: &Container) -> TokenStream {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return quote!();
-        }
-    };
-
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-    let turbofish = ty_generics.as_turbofish();
-
-    let cases = variants.iter().map(|variant| {
-        let variant_ident = &variant.ident;
-        let placeholders = &(0..variant.fields.len())
-            .map(|i| format_ident!("__v{}", i))
-            .collect::<Vec<_>>();
-
-        let pat = match variant.style {
-            Style::Struct => {
-                let members = variant.fields.iter().map(|field| &field.member);
-                quote!({ #(#members: #placeholders),* })
-            }
-            Style::Tuple | Style::Newtype => quote!(( #(#placeholders),* )),
-            Style::Unit => quote!(),
-        };
-
-        quote! {
-            match _serde::__private::None {
-                _serde::__private::Some((#(#placeholders,)*)) => {
-                    let _ = #type_ident::#variant_ident #turbofish #pat;
-                }
-                _ => {}
-            }
-        }
-    });
-
-    quote!(#(#cases)*)
-}
diff --git a/vendor/serde_derive/src/ser.rs b/vendor/serde_derive/src/ser.rs
deleted file mode 100644
index 529a20d7..00000000
--- a/vendor/serde_derive/src/ser.rs
+++ /dev/null
@@ -1,1338 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use syn::spanned::Spanned;
-use syn::{self, Ident, Index, Member};
-
-use bound;
-use dummy;
-use fragment::{Fragment, Match, Stmts};
-use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, replace_receiver, Ctxt, Derive};
-use pretend;
-
-pub fn expand_derive_serialize(
-    input: &mut syn::DeriveInput,
-) -> Result<TokenStream, Vec<syn::Error>> {
-    replace_receiver(input);
-
-    let ctxt = Ctxt::new();
-    let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
-        Some(cont) => cont,
-        None => return Err(ctxt.check().unwrap_err()),
-    };
-    precondition(&ctxt, &cont);
-    ctxt.check()?;
-
-    let ident = &cont.ident;
-    let params = Parameters::new(&cont);
-    let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
-    let body = Stmts(serialize_body(&cont, &params));
-    let serde = cont.attrs.serde_path();
-
-    let impl_block = if let Some(remote) = cont.attrs.remote() {
-        let vis = &input.vis;
-        let used = pretend::pretend_used(&cont, params.is_packed);
-        quote! {
-            impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
-                where
-                    __S: #serde::Serializer,
-                {
-                    #used
-                    #body
-                }
-            }
-        }
-    } else {
-        quote! {
-            #[automatically_derived]
-            impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
-                where
-                    __S: #serde::Serializer,
-                {
-                    #body
-                }
-            }
-        }
-    };
-
-    Ok(dummy::wrap_in_const(
-        cont.attrs.custom_serde_path(),
-        "SERIALIZE",
-        ident,
-        impl_block,
-    ))
-}
-
-fn precondition(cx: &Ctxt, cont: &Container) {
-    match cont.attrs.identifier() {
-        attr::Identifier::No => {}
-        attr::Identifier::Field => {
-            cx.error_spanned_by(cont.original, "field identifiers cannot be serialized");
-        }
-        attr::Identifier::Variant => {
-            cx.error_spanned_by(cont.original, "variant identifiers cannot be serialized");
-        }
-    }
-}
-
-struct Parameters {
-    /// Variable holding the value being serialized. Either `self` for local
-    /// types or `__self` for remote types.
-    self_var: Ident,
-
-    /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types or `some::remote::Ident` for remote types. Does not include
-    /// generic parameters.
-    this: syn::Path,
-
-    /// Generics including any explicit and inferred bounds for the impl.
-    generics: syn::Generics,
-
-    /// Type has a `serde(remote = "...")` attribute.
-    is_remote: bool,
-
-    /// Type has a repr(packed) attribute.
-    is_packed: bool,
-}
-
-impl Parameters {
-    fn new(cont: &Container) -> Self {
-        let is_remote = cont.attrs.remote().is_some();
-        let self_var = if is_remote {
-            Ident::new("__self", Span::call_site())
-        } else {
-            Ident::new("self", Span::call_site())
-        };
-
-        let this = match cont.attrs.remote() {
-            Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
-        };
-
-        let is_packed = cont.attrs.is_packed();
-
-        let generics = build_generics(cont);
-
-        Parameters {
-            self_var,
-            this,
-            generics,
-            is_remote,
-            is_packed,
-        }
-    }
-
-    /// Type name to use in error messages and `&'static str` arguments to
-    /// various Serializer methods.
-    fn type_name(&self) -> String {
-        self.this.segments.last().unwrap().ident.to_string()
-    }
-}
-
-// All the generics in the input, plus a bound `T: Serialize` for each generic
-// field type that will be serialized by us.
-fn build_generics(cont: &Container) -> syn::Generics {
-    let generics = bound::without_defaults(cont.generics);
-
-    let generics =
-        bound::with_where_predicates_from_fields(cont, &generics, attr::Field::ser_bound);
-
-    let generics =
-        bound::with_where_predicates_from_variants(cont, &generics, attr::Variant::ser_bound);
-
-    match cont.attrs.ser_bound() {
-        Some(predicates) => bound::with_where_predicates(&generics, predicates),
-        None => bound::with_bound(
-            cont,
-            &generics,
-            needs_serialize_bound,
-            &parse_quote!(_serde::Serialize),
-        ),
-    }
-}
-
-// Fields with a `skip_serializing` or `serialize_with` attribute, or which
-// belong to a variant with a 'skip_serializing` or `serialize_with` attribute,
-// are not serialized by us so we do not generate a bound. Fields with a `bound`
-// attribute specify their own bound so we do not generate one. All other fields
-// may need a `T: Serialize` bound where T is the type of the field.
-fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_serializing()
-        && field.serialize_with().is_none()
-        && field.ser_bound().is_none()
-        && variant.map_or(true, |variant| {
-            !variant.skip_serializing()
-                && variant.serialize_with().is_none()
-                && variant.ser_bound().is_none()
-        })
-}
-
-fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
-    if cont.attrs.transparent() {
-        serialize_transparent(cont, params)
-    } else if let Some(type_into) = cont.attrs.type_into() {
-        serialize_into(params, type_into)
-    } else {
-        match &cont.data {
-            Data::Enum(variants) => serialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, fields) => serialize_struct(params, fields, &cont.attrs),
-            Data::Struct(Style::Tuple, fields) => {
-                serialize_tuple_struct(params, fields, &cont.attrs)
-            }
-            Data::Struct(Style::Newtype, fields) => {
-                serialize_newtype_struct(params, &fields[0], &cont.attrs)
-            }
-            Data::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
-        }
-    }
-}
-
-fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match &cont.data {
-        Data::Struct(_, fields) => fields,
-        Data::Enum(_) => unreachable!(),
-    };
-
-    let self_var = &params.self_var;
-    let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
-    let member = &transparent_field.member;
-
-    let path = match transparent_field.attrs.serialize_with() {
-        Some(path) => quote!(#path),
-        None => {
-            let span = transparent_field.original.span();
-            quote_spanned!(span=> _serde::Serialize::serialize)
-        }
-    };
-
-    quote_block! {
-        #path(&#self_var.#member, __serializer)
-    }
-}
-
-fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
-    let self_var = &params.self_var;
-    quote_block! {
-        _serde::Serialize::serialize(
-            &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
-            __serializer)
-    }
-}
-
-fn serialize_unit_struct(cattrs: &attr::Container) -> Fragment {
-    let type_name = cattrs.name().serialize_name();
-
-    quote_expr! {
-        _serde::Serializer::serialize_unit_struct(__serializer, #type_name)
-    }
-}
-
-fn serialize_newtype_struct(
-    params: &Parameters,
-    field: &Field,
-    cattrs: &attr::Container,
-) -> Fragment {
-    let type_name = cattrs.name().serialize_name();
-
-    let mut field_expr = get_member(
-        params,
-        field,
-        &Member::Unnamed(Index {
-            index: 0,
-            span: Span::call_site(),
-        }),
-    );
-    if let Some(path) = field.attrs.serialize_with() {
-        field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-    }
-
-    let span = field.original.span();
-    let func = quote_spanned!(span=> _serde::Serializer::serialize_newtype_struct);
-    quote_expr! {
-        #func(__serializer, #type_name, #field_expr)
-    }
-}
-
-fn serialize_tuple_struct(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let serialize_stmts =
-        serialize_tuple_struct_visitor(fields, params, false, &TupleTrait::SerializeTupleStruct);
-
-    let type_name = cattrs.name().serialize_name();
-
-    let mut serialized_fields = fields
-        .iter()
-        .enumerate()
-        .filter(|(_, field)| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some());
-
-    let len = serialized_fields
-        .map(|(i, field)| match field.attrs.skip_serializing_if() {
-            None => quote!(1),
-            Some(path) => {
-                let index = syn::Index {
-                    index: i as u32,
-                    span: Span::call_site(),
-                };
-                let field_expr = get_member(params, field, &Member::Unnamed(index));
-                quote!(if #path(#field_expr) { 0 } else { 1 })
-            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
-
-    quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len));
-        #(#serialize_stmts)*
-        _serde::ser::SerializeTupleStruct::end(__serde_state)
-    }
-}
-
-fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    assert!(fields.len() as u64 <= u64::from(u32::max_value()));
-
-    if cattrs.has_flatten() {
-        serialize_struct_as_map(params, fields, cattrs)
-    } else {
-        serialize_struct_as_struct(params, fields, cattrs)
-    }
-}
-
-fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTrait) -> TokenStream {
-    match cattrs.tag() {
-        attr::TagType::Internal { tag } => {
-            let type_name = cattrs.name().serialize_name();
-            let func = struct_trait.serialize_field(Span::call_site());
-            quote! {
-                try!(#func(&mut __serde_state, #tag, #type_name));
-            }
-        }
-        _ => quote! {},
-    }
-}
-
-fn serialize_struct_as_struct(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let serialize_fields =
-        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeStruct);
-
-    let type_name = cattrs.name().serialize_name();
-
-    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeStruct);
-    let tag_field_exists = !tag_field.is_empty();
-
-    let mut serialized_fields = fields
-        .iter()
-        .filter(|&field| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
-
-    let len = serialized_fields
-        .map(|field| match field.attrs.skip_serializing_if() {
-            None => quote!(1),
-            Some(path) => {
-                let field_expr = get_member(params, field, &field.member);
-                quote!(if #path(#field_expr) { 0 } else { 1 })
-            }
-        })
-        .fold(
-            quote!(#tag_field_exists as usize),
-            |sum, expr| quote!(#sum + #expr),
-        );
-
-    quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len));
-        #tag_field
-        #(#serialize_fields)*
-        _serde::ser::SerializeStruct::end(__serde_state)
-    }
-}
-
-fn serialize_struct_as_map(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let serialize_fields =
-        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);
-
-    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeMap);
-    let tag_field_exists = !tag_field.is_empty();
-
-    let mut serialized_fields = fields
-        .iter()
-        .filter(|&field| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
-
-    let len = if cattrs.has_flatten() {
-        quote!(_serde::__private::None)
-    } else {
-        let len = serialized_fields
-            .map(|field| match field.attrs.skip_serializing_if() {
-                None => quote!(1),
-                Some(path) => {
-                    let field_expr = get_member(params, field, &field.member);
-                    quote!(if #path(#field_expr) { 0 } else { 1 })
-                }
-            })
-            .fold(
-                quote!(#tag_field_exists as usize),
-                |sum, expr| quote!(#sum + #expr),
-            );
-        quote!(_serde::__private::Some(#len))
-    };
-
-    quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
-        #tag_field
-        #(#serialize_fields)*
-        _serde::ser::SerializeMap::end(__serde_state)
-    }
-}
-
-fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
-    assert!(variants.len() as u64 <= u64::from(u32::max_value()));
-
-    let self_var = &params.self_var;
-
-    let arms: Vec<_> = variants
-        .iter()
-        .enumerate()
-        .map(|(variant_index, variant)| {
-            serialize_variant(params, variant, variant_index as u32, cattrs)
-        })
-        .collect();
-
-    quote_expr! {
-        match *#self_var {
-            #(#arms)*
-        }
-    }
-}
-
-fn serialize_variant(
-    params: &Parameters,
-    variant: &Variant,
-    variant_index: u32,
-    cattrs: &attr::Container,
-) -> TokenStream {
-    let this = &params.this;
-    let variant_ident = &variant.ident;
-
-    if variant.attrs.skip_serializing() {
-        let skipped_msg = format!(
-            "the enum variant {}::{} cannot be serialized",
-            params.type_name(),
-            variant_ident
-        );
-        let skipped_err = quote! {
-            _serde::__private::Err(_serde::ser::Error::custom(#skipped_msg))
-        };
-        let fields_pat = match variant.style {
-            Style::Unit => quote!(),
-            Style::Newtype | Style::Tuple => quote!((..)),
-            Style::Struct => quote!({ .. }),
-        };
-        quote! {
-            #this::#variant_ident #fields_pat => #skipped_err,
-        }
-    } else {
-        // variant wasn't skipped
-        let case = match variant.style {
-            Style::Unit => {
-                quote! {
-                    #this::#variant_ident
-                }
-            }
-            Style::Newtype => {
-                quote! {
-                    #this::#variant_ident(ref __field0)
-                }
-            }
-            Style::Tuple => {
-                let field_names = (0..variant.fields.len())
-                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
-                quote! {
-                    #this::#variant_ident(#(ref #field_names),*)
-                }
-            }
-            Style::Struct => {
-                let members = variant.fields.iter().map(|f| &f.member);
-                quote! {
-                    #this::#variant_ident { #(ref #members),* }
-                }
-            }
-        };
-
-        let body = Match(match cattrs.tag() {
-            attr::TagType::External => {
-                serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
-            }
-            attr::TagType::Internal { tag } => {
-                serialize_internally_tagged_variant(params, variant, cattrs, tag)
-            }
-            attr::TagType::Adjacent { tag, content } => {
-                serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content)
-            }
-            attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
-        });
-
-        quote! {
-            #case => #body
-        }
-    }
-}
-
-fn serialize_externally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    variant_index: u32,
-    cattrs: &attr::Container,
-) -> Fragment {
-    let type_name = cattrs.name().serialize_name();
-    let variant_name = variant.attrs.name().serialize_name();
-
-    if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, variant);
-        return quote_expr! {
-            _serde::Serializer::serialize_newtype_variant(
-                __serializer,
-                #type_name,
-                #variant_index,
-                #variant_name,
-                #ser,
-            )
-        };
-    }
-
-    match effective_style(variant) {
-        Style::Unit => {
-            quote_expr! {
-                _serde::Serializer::serialize_unit_variant(
-                    __serializer,
-                    #type_name,
-                    #variant_index,
-                    #variant_name,
-                )
-            }
-        }
-        Style::Newtype => {
-            let field = &variant.fields[0];
-            let mut field_expr = quote!(__field0);
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
-
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::Serializer::serialize_newtype_variant);
-            quote_expr! {
-                #func(
-                    __serializer,
-                    #type_name,
-                    #variant_index,
-                    #variant_name,
-                    #field_expr,
-                )
-            }
-        }
-        Style::Tuple => serialize_tuple_variant(
-            TupleVariant::ExternallyTagged {
-                type_name,
-                variant_index,
-                variant_name,
-            },
-            params,
-            &variant.fields,
-        ),
-        Style::Struct => serialize_struct_variant(
-            StructVariant::ExternallyTagged {
-                variant_index,
-                variant_name,
-            },
-            params,
-            &variant.fields,
-            &type_name,
-        ),
-    }
-}
-
-fn serialize_internally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-    tag: &str,
-) -> Fragment {
-    let type_name = cattrs.name().serialize_name();
-    let variant_name = variant.attrs.name().serialize_name();
-
-    let enum_ident_str = params.type_name();
-    let variant_ident_str = variant.ident.to_string();
-
-    if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, variant);
-        return quote_expr! {
-            _serde::__private::ser::serialize_tagged_newtype(
-                __serializer,
-                #enum_ident_str,
-                #variant_ident_str,
-                #tag,
-                #variant_name,
-                #ser,
-            )
-        };
-    }
-
-    match effective_style(variant) {
-        Style::Unit => {
-            quote_block! {
-                let mut __struct = try!(_serde::Serializer::serialize_struct(
-                    __serializer, #type_name, 1));
-                try!(_serde::ser::SerializeStruct::serialize_field(
-                    &mut __struct, #tag, #variant_name));
-                _serde::ser::SerializeStruct::end(__struct)
-            }
-        }
-        Style::Newtype => {
-            let field = &variant.fields[0];
-            let mut field_expr = quote!(__field0);
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
-
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::__private::ser::serialize_tagged_newtype);
-            quote_expr! {
-                #func(
-                    __serializer,
-                    #enum_ident_str,
-                    #variant_ident_str,
-                    #tag,
-                    #variant_name,
-                    #field_expr,
-                )
-            }
-        }
-        Style::Struct => serialize_struct_variant(
-            StructVariant::InternallyTagged { tag, variant_name },
-            params,
-            &variant.fields,
-            &type_name,
-        ),
-        Style::Tuple => unreachable!("checked in serde_derive_internals"),
-    }
-}
-
-fn serialize_adjacently_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-    tag: &str,
-    content: &str,
-) -> Fragment {
-    let this = &params.this;
-    let type_name = cattrs.name().serialize_name();
-    let variant_name = variant.attrs.name().serialize_name();
-
-    let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, variant);
-        quote_expr! {
-            _serde::Serialize::serialize(#ser, __serializer)
-        }
-    } else {
-        match effective_style(variant) {
-            Style::Unit => {
-                return quote_block! {
-                    let mut __struct = try!(_serde::Serializer::serialize_struct(
-                        __serializer, #type_name, 1));
-                    try!(_serde::ser::SerializeStruct::serialize_field(
-                        &mut __struct, #tag, #variant_name));
-                    _serde::ser::SerializeStruct::end(__struct)
-                };
-            }
-            Style::Newtype => {
-                let field = &variant.fields[0];
-                let mut field_expr = quote!(__field0);
-                if let Some(path) = field.attrs.serialize_with() {
-                    field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-                }
-
-                let span = field.original.span();
-                let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field);
-                return quote_block! {
-                    let mut __struct = try!(_serde::Serializer::serialize_struct(
-                        __serializer, #type_name, 2));
-                    try!(_serde::ser::SerializeStruct::serialize_field(
-                        &mut __struct, #tag, #variant_name));
-                    try!(#func(
-                        &mut __struct, #content, #field_expr));
-                    _serde::ser::SerializeStruct::end(__struct)
-                };
-            }
-            Style::Tuple => {
-                serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
-            }
-            Style::Struct => serialize_struct_variant(
-                StructVariant::Untagged,
-                params,
-                &variant.fields,
-                &variant_name,
-            ),
-        }
-    });
-
-    let fields_ty = variant.fields.iter().map(|f| &f.ty);
-    let fields_ident: &Vec<_> = &match variant.style {
-        Style::Unit => {
-            if variant.attrs.serialize_with().is_some() {
-                vec![]
-            } else {
-                unreachable!()
-            }
-        }
-        Style::Newtype => vec![Member::Named(Ident::new("__field0", Span::call_site()))],
-        Style::Tuple => (0..variant.fields.len())
-            .map(|i| Member::Named(Ident::new(&format!("__field{}", i), Span::call_site())))
-            .collect(),
-        Style::Struct => variant.fields.iter().map(|f| f.member.clone()).collect(),
-    };
-
-    let (_, ty_generics, where_clause) = params.generics.split_for_impl();
-
-    let wrapper_generics = if fields_ident.is_empty() {
-        params.generics.clone()
-    } else {
-        bound::with_lifetime_bound(&params.generics, "'__a")
-    };
-    let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
-
-    quote_block! {
-        struct __AdjacentlyTagged #wrapper_generics #where_clause {
-            data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
-        }
-
-        impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
-            where
-                __S: _serde::Serializer,
-            {
-                // Elements that have skip_serializing will be unused.
-                #[allow(unused_variables)]
-                let (#(#fields_ident,)*) = self.data;
-                #inner
-            }
-        }
-
-        let mut __struct = try!(_serde::Serializer::serialize_struct(
-            __serializer, #type_name, 2));
-        try!(_serde::ser::SerializeStruct::serialize_field(
-            &mut __struct, #tag, #variant_name));
-        try!(_serde::ser::SerializeStruct::serialize_field(
-            &mut __struct, #content, &__AdjacentlyTagged {
-                data: (#(#fields_ident,)*),
-                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
-            }));
-        _serde::ser::SerializeStruct::end(__struct)
-    }
-}
-
-fn serialize_untagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-) -> Fragment {
-    if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, variant);
-        return quote_expr! {
-            _serde::Serialize::serialize(#ser, __serializer)
-        };
-    }
-
-    match effective_style(variant) {
-        Style::Unit => {
-            quote_expr! {
-                _serde::Serializer::serialize_unit(__serializer)
-            }
-        }
-        Style::Newtype => {
-            let field = &variant.fields[0];
-            let mut field_expr = quote!(__field0);
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
-
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::Serialize::serialize);
-            quote_expr! {
-                #func(#field_expr, __serializer)
-            }
-        }
-        Style::Tuple => serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields),
-        Style::Struct => {
-            let type_name = cattrs.name().serialize_name();
-            serialize_struct_variant(StructVariant::Untagged, params, &variant.fields, &type_name)
-        }
-    }
-}
-
-enum TupleVariant {
-    ExternallyTagged {
-        type_name: String,
-        variant_index: u32,
-        variant_name: String,
-    },
-    Untagged,
-}
-
-fn serialize_tuple_variant(
-    context: TupleVariant,
-    params: &Parameters,
-    fields: &[Field],
-) -> Fragment {
-    let tuple_trait = match context {
-        TupleVariant::ExternallyTagged { .. } => TupleTrait::SerializeTupleVariant,
-        TupleVariant::Untagged => TupleTrait::SerializeTuple,
-    };
-
-    let serialize_stmts = serialize_tuple_struct_visitor(fields, params, true, &tuple_trait);
-
-    let mut serialized_fields = fields
-        .iter()
-        .enumerate()
-        .filter(|(_, field)| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some());
-
-    let len = serialized_fields
-        .map(|(i, field)| match field.attrs.skip_serializing_if() {
-            None => quote!(1),
-            Some(path) => {
-                let field_expr = Ident::new(&format!("__field{}", i), Span::call_site());
-                quote!(if #path(#field_expr) { 0 } else { 1 })
-            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
-
-    match context {
-        TupleVariant::ExternallyTagged {
-            type_name,
-            variant_index,
-            variant_name,
-        } => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
-                    __serializer,
-                    #type_name,
-                    #variant_index,
-                    #variant_name,
-                    #len));
-                #(#serialize_stmts)*
-                _serde::ser::SerializeTupleVariant::end(__serde_state)
-            }
-        }
-        TupleVariant::Untagged => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple(
-                    __serializer,
-                    #len));
-                #(#serialize_stmts)*
-                _serde::ser::SerializeTuple::end(__serde_state)
-            }
-        }
-    }
-}
-
-enum StructVariant<'a> {
-    ExternallyTagged {
-        variant_index: u32,
-        variant_name: String,
-    },
-    InternallyTagged {
-        tag: &'a str,
-        variant_name: String,
-    },
-    Untagged,
-}
-
-fn serialize_struct_variant<'a>(
-    context: StructVariant<'a>,
-    params: &Parameters,
-    fields: &[Field],
-    name: &str,
-) -> Fragment {
-    if fields.iter().any(|field| field.attrs.flatten()) {
-        return serialize_struct_variant_with_flatten(context, params, fields, name);
-    }
-
-    let struct_trait = match context {
-        StructVariant::ExternallyTagged { .. } => StructTrait::SerializeStructVariant,
-        StructVariant::InternallyTagged { .. } | StructVariant::Untagged => {
-            StructTrait::SerializeStruct
-        }
-    };
-
-    let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
-
-    let mut serialized_fields = fields
-        .iter()
-        .filter(|&field| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some());
-
-    let len = serialized_fields
-        .map(|field| {
-            let member = &field.member;
-
-            match field.attrs.skip_serializing_if() {
-                Some(path) => quote!(if #path(#member) { 0 } else { 1 }),
-                None => quote!(1),
-            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
-
-    match context {
-        StructVariant::ExternallyTagged {
-            variant_index,
-            variant_name,
-        } => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
-                    __serializer,
-                    #name,
-                    #variant_index,
-                    #variant_name,
-                    #len,
-                ));
-                #(#serialize_fields)*
-                _serde::ser::SerializeStructVariant::end(__serde_state)
-            }
-        }
-        StructVariant::InternallyTagged { tag, variant_name } => {
-            quote_block! {
-                let mut __serde_state = try!(_serde::Serializer::serialize_struct(
-                    __serializer,
-                    #name,
-                    #len + 1,
-                ));
-                try!(_serde::ser::SerializeStruct::serialize_field(
-                    &mut __serde_state,
-                    #tag,
-                    #variant_name,
-                ));
-                #(#serialize_fields)*
-                _serde::ser::SerializeStruct::end(__serde_state)
-            }
-        }
-        StructVariant::Untagged => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(
-                    __serializer,
-                    #name,
-                    #len,
-                ));
-                #(#serialize_fields)*
-                _serde::ser::SerializeStruct::end(__serde_state)
-            }
-        }
-    }
-}
-
-fn serialize_struct_variant_with_flatten<'a>(
-    context: StructVariant<'a>,
-    params: &Parameters,
-    fields: &[Field],
-    name: &str,
-) -> Fragment {
-    let struct_trait = StructTrait::SerializeMap;
-    let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
-
-    let mut serialized_fields = fields
-        .iter()
-        .filter(|&field| !field.attrs.skip_serializing())
-        .peekable();
-
-    let let_mut = mut_if(serialized_fields.peek().is_some());
-
-    match context {
-        StructVariant::ExternallyTagged {
-            variant_index,
-            variant_name,
-        } => {
-            let this = &params.this;
-            let fields_ty = fields.iter().map(|f| &f.ty);
-            let members = &fields.iter().map(|f| &f.member).collect::<Vec<_>>();
-
-            let (_, ty_generics, where_clause) = params.generics.split_for_impl();
-            let wrapper_generics = bound::with_lifetime_bound(&params.generics, "'__a");
-            let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
-
-            quote_block! {
-                struct __EnumFlatten #wrapper_generics #where_clause {
-                    data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
-                }
-
-                impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
-                    fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
-                    where
-                        __S: _serde::Serializer,
-                    {
-                        let (#(#members,)*) = self.data;
-                        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
-                            __serializer,
-                            _serde::__private::None));
-                        #(#serialize_fields)*
-                        _serde::ser::SerializeMap::end(__serde_state)
-                    }
-                }
-
-                _serde::Serializer::serialize_newtype_variant(
-                    __serializer,
-                    #name,
-                    #variant_index,
-                    #variant_name,
-                    &__EnumFlatten {
-                        data: (#(#members,)*),
-                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
-                    })
-            }
-        }
-        StructVariant::InternallyTagged { tag, variant_name } => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
-                    __serializer,
-                    _serde::__private::None));
-                try!(_serde::ser::SerializeMap::serialize_entry(
-                    &mut __serde_state,
-                    #tag,
-                    #variant_name,
-                ));
-                #(#serialize_fields)*
-                _serde::ser::SerializeMap::end(__serde_state)
-            }
-        }
-        StructVariant::Untagged => {
-            quote_block! {
-                let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
-                    __serializer,
-                    _serde::__private::None));
-                #(#serialize_fields)*
-                _serde::ser::SerializeMap::end(__serde_state)
-            }
-        }
-    }
-}
-
-fn serialize_tuple_struct_visitor(
-    fields: &[Field],
-    params: &Parameters,
-    is_enum: bool,
-    tuple_trait: &TupleTrait,
-) -> Vec<TokenStream> {
-    fields
-        .iter()
-        .enumerate()
-        .filter(|(_, field)| !field.attrs.skip_serializing())
-        .map(|(i, field)| {
-            let mut field_expr = if is_enum {
-                let id = Ident::new(&format!("__field{}", i), Span::call_site());
-                quote!(#id)
-            } else {
-                get_member(
-                    params,
-                    field,
-                    &Member::Unnamed(Index {
-                        index: i as u32,
-                        span: Span::call_site(),
-                    }),
-                )
-            };
-
-            let skip = field
-                .attrs
-                .skip_serializing_if()
-                .map(|path| quote!(#path(#field_expr)));
-
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
-
-            let span = field.original.span();
-            let func = tuple_trait.serialize_element(span);
-            let ser = quote! {
-                try!(#func(&mut __serde_state, #field_expr));
-            };
-
-            match skip {
-                None => ser,
-                Some(skip) => quote!(if !#skip { #ser }),
-            }
-        })
-        .collect()
-}
-
-fn serialize_struct_visitor(
-    fields: &[Field],
-    params: &Parameters,
-    is_enum: bool,
-    struct_trait: &StructTrait,
-) -> Vec<TokenStream> {
-    fields
-        .iter()
-        .filter(|&field| !field.attrs.skip_serializing())
-        .map(|field| {
-            let member = &field.member;
-
-            let mut field_expr = if is_enum {
-                quote!(#member)
-            } else {
-                get_member(params, field, member)
-            };
-
-            let key_expr = field.attrs.name().serialize_name();
-
-            let skip = field
-                .attrs
-                .skip_serializing_if()
-                .map(|path| quote!(#path(#field_expr)));
-
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
-
-            let span = field.original.span();
-            let ser = if field.attrs.flatten() {
-                let func = quote_spanned!(span=> _serde::Serialize::serialize);
-                quote! {
-                    try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
-                }
-            } else {
-                let func = struct_trait.serialize_field(span);
-                quote! {
-                    try!(#func(&mut __serde_state, #key_expr, #field_expr));
-                }
-            };
-
-            match skip {
-                None => ser,
-                Some(skip) => {
-                    if let Some(skip_func) = struct_trait.skip_field(span) {
-                        quote! {
-                            if !#skip {
-                                #ser
-                            } else {
-                                try!(#skip_func(&mut __serde_state, #key_expr));
-                            }
-                        }
-                    } else {
-                        quote! {
-                            if !#skip {
-                                #ser
-                            }
-                        }
-                    }
-                }
-            }
-        })
-        .collect()
-}
-
-fn wrap_serialize_field_with(
-    params: &Parameters,
-    field_ty: &syn::Type,
-    serialize_with: &syn::ExprPath,
-    field_expr: &TokenStream,
-) -> TokenStream {
-    wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
-}
-
-fn wrap_serialize_variant_with(
-    params: &Parameters,
-    serialize_with: &syn::ExprPath,
-    variant: &Variant,
-) -> TokenStream {
-    let field_tys: Vec<_> = variant.fields.iter().map(|field| field.ty).collect();
-    let field_exprs: Vec<_> = variant
-        .fields
-        .iter()
-        .map(|field| {
-            let id = match &field.member {
-                Member::Named(ident) => ident.clone(),
-                Member::Unnamed(member) => {
-                    Ident::new(&format!("__field{}", member.index), Span::call_site())
-                }
-            };
-            quote!(#id)
-        })
-        .collect();
-    wrap_serialize_with(
-        params,
-        serialize_with,
-        field_tys.as_slice(),
-        field_exprs.as_slice(),
-    )
-}
-
-fn wrap_serialize_with(
-    params: &Parameters,
-    serialize_with: &syn::ExprPath,
-    field_tys: &[&syn::Type],
-    field_exprs: &[TokenStream],
-) -> TokenStream {
-    let this = &params.this;
-    let (_, ty_generics, where_clause) = params.generics.split_for_impl();
-
-    let wrapper_generics = if field_exprs.is_empty() {
-        params.generics.clone()
-    } else {
-        bound::with_lifetime_bound(&params.generics, "'__a")
-    };
-    let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
-
-    let field_access = (0..field_exprs.len()).map(|n| {
-        Member::Unnamed(Index {
-            index: n as u32,
-            span: Span::call_site(),
-        })
-    });
-
-    quote!({
-        struct __SerializeWith #wrapper_impl_generics #where_clause {
-            values: (#(&'__a #field_tys, )*),
-            phantom: _serde::__private::PhantomData<#this #ty_generics>,
-        }
-
-        impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __s: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
-            where
-                __S: _serde::Serializer,
-            {
-                #serialize_with(#(self.values.#field_access, )* __s)
-            }
-        }
-
-        &__SerializeWith {
-            values: (#(#field_exprs, )*),
-            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
-        }
-    })
-}
-
-// Serialization of an empty struct results in code like:
-//
-//     let mut __serde_state = try!(serializer.serialize_struct("S", 0));
-//     _serde::ser::SerializeStruct::end(__serde_state)
-//
-// where we want to omit the `mut` to avoid a warning.
-fn mut_if(is_mut: bool) -> Option<TokenStream> {
-    if is_mut {
-        Some(quote!(mut))
-    } else {
-        None
-    }
-}
-
-fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStream {
-    let self_var = &params.self_var;
-    match (params.is_remote, field.attrs.getter()) {
-        (false, None) => {
-            if params.is_packed {
-                quote!(&{#self_var.#member})
-            } else {
-                quote!(&#self_var.#member)
-            }
-        }
-        (true, None) => {
-            let inner = if params.is_packed {
-                quote!(&{#self_var.#member})
-            } else {
-                quote!(&#self_var.#member)
-            };
-            let ty = field.ty;
-            quote!(_serde::__private::ser::constrain::<#ty>(#inner))
-        }
-        (true, Some(getter)) => {
-            let ty = field.ty;
-            quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
-        }
-        (false, Some(_)) => {
-            unreachable!("getter is only allowed for remote impls");
-        }
-    }
-}
-
-fn effective_style(variant: &Variant) -> Style {
-    match variant.style {
-        Style::Newtype if variant.fields[0].attrs.skip_serializing() => Style::Unit,
-        other => other,
-    }
-}
-
-enum StructTrait {
-    SerializeMap,
-    SerializeStruct,
-    SerializeStructVariant,
-}
-
-impl StructTrait {
-    fn serialize_field(&self, span: Span) -> TokenStream {
-        match *self {
-            StructTrait::SerializeMap => {
-                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry)
-            }
-            StructTrait::SerializeStruct => {
-                quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field)
-            }
-            StructTrait::SerializeStructVariant => {
-                quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field)
-            }
-        }
-    }
-
-    fn skip_field(&self, span: Span) -> Option<TokenStream> {
-        match *self {
-            StructTrait::SerializeMap => None,
-            StructTrait::SerializeStruct => {
-                Some(quote_spanned!(span=> _serde::ser::SerializeStruct::skip_field))
-            }
-            StructTrait::SerializeStructVariant => {
-                Some(quote_spanned!(span=> _serde::ser::SerializeStructVariant::skip_field))
-            }
-        }
-    }
-}
-
-enum TupleTrait {
-    SerializeTuple,
-    SerializeTupleStruct,
-    SerializeTupleVariant,
-}
-
-impl TupleTrait {
-    fn serialize_element(&self, span: Span) -> TokenStream {
-        match *self {
-            TupleTrait::SerializeTuple => {
-                quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element)
-            }
-            TupleTrait::SerializeTupleStruct => {
-                quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field)
-            }
-            TupleTrait::SerializeTupleVariant => {
-                quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field)
-            }
-        }
-    }
-}
diff --git a/vendor/serde_derive/src/try.rs b/vendor/serde_derive/src/try.rs
deleted file mode 100644
index 48cceeba..00000000
--- a/vendor/serde_derive/src/try.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use proc_macro2::{Punct, Spacing, TokenStream};
-
-// None of our generated code requires the `From::from` error conversion
-// performed by the standard library's `try!` macro. With this simplified macro
-// we see a significant improvement in type checking and borrow checking time of
-// the generated code and a slight improvement in binary size.
-pub fn replacement() -> TokenStream {
-    // Cannot pass `$expr` to `quote!` prior to Rust 1.17.0 so interpolate it.
-    let dollar = Punct::new('$', Spacing::Alone);
-
-    quote! {
-        #[allow(unused_macros)]
-        macro_rules! try {
-            (#dollar __expr:expr) => {
-                match #dollar __expr {
-                    _serde::__private::Ok(__val) => __val,
-                    _serde::__private::Err(__err) => {
-                        return _serde::__private::Err(__err);
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/vendor/static_assertions/.cargo-checksum.json b/vendor/static_assertions/.cargo-checksum.json
deleted file mode 100644
index eb917cb9..00000000
--- a/vendor/static_assertions/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"CHANGELOG.md":"750f74f3b520672a81dd2ede5c097cfe972c0da181dd8fd010e7131a3526d4fd","Cargo.toml":"6531dbe3d557e427f9e3510e50cdf3de751a319eece11c9a937b35cfab8744c4","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"ea084a2373ebc1f0902c09266e7bf25a05ab3814c1805bb017ffa7308f90c061","README.md":"88cc779ada8c6e1362c2d095c179284ec2755797729946ebccfe8264fcff0f8e","src/assert_cfg.rs":"ce9230bcc055d8df21ceefbed4233df5e73ecb832829ba23ac8d7f54ec457522","src/assert_eq_align.rs":"f09c4ec30e476446ab337a4a9ed950edf21c780a42ece7613f0ffc20225331ae","src/assert_eq_size.rs":"c06d2ff44e1f7af8a57b7c2fe5a9c69aa2a90d12cd41614c9d4f3ae551cdb64c","src/assert_fields.rs":"9c5baeac0215be557213eec9e80fc00de10a721d9b2c369fece743fcc6ccdc8e","src/assert_impl.rs":"fe5a2fffcbb78f60991bbc590481e74fd0d5f7ed8fa75718644599e1fae117ce","src/assert_obj_safe.rs":"88584809f3aa2dfce966b0adbeb6128191229465d653e57b68f968be001eff03","src/assert_trait.rs":"87b2d4dbd4334d9ace9880b81f3a1fbf91725c5e152b34a74c86457ca40ece30","src/assert_type.rs":"7cd942341efa7ed0b89b5e4fe1faa62bafb537ec6cf72ee6866115daee931885","src/const_assert.rs":"e0dcfe9016e34455f5efcb23500f716386d42b9fb09c6d08566d03dce8249e51","src/lib.rs":"4cbaaff38a6ac16631e774ab5a349056cbd2335ac570aeb46c5616eaf9700c3b"},"package":"a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"}
\ No newline at end of file
diff --git a/vendor/static_assertions/CHANGELOG.md b/vendor/static_assertions/CHANGELOG.md
deleted file mode 100644
index 80d55075..00000000
--- a/vendor/static_assertions/CHANGELOG.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Changelog [![Crates.io][crate-badge]][crate]
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog] and this project adheres to
-[Semantic Versioning].
-
-## [Unreleased]
-
-## [1.1.0] - 2019-11-03
-### Added
-- `assert_impl_any!` macro
-- `assert_impl_one!` macro
-- `assert_trait_sub_all!` macro
-- `assert_trait_super_all!` macro
-- Frequently asked questions to `README.md`
-
-### Fixed
-- `assert_eq_size_val!`, `const_assert_eq!`, and `const_assert_ne!` to export
-  their local inner macros. Not having this prevented them from working when
-  `use`d or called directly via `static_assertions::macro!(...)`
-
-### Removed
-- Unused `_assert_obj_safe!` from pre-1.0
-
-## [1.0.0] - 2019-10-02
-### Added
-- `assert_eq_align!` macro
-
-### Removed
-- **[breaking]** Labels from macros that needed them 🎉
-  - Made possible by [`const _`] in Rust 1.37
-- **[breaking]** `assert_impl!` macro
-
-### Fixed
-- `assert_fields!` now works for `enum` types with multiple variants
-
-### Changed
-- **[breaking]** `const_assert!` macro to only take one expression
-  - Reasoning: when custom error messages are added in the future (via
-    [`assert!`]), having the macro allow for multiple comma-separated
-    expressions may lead to ambiguity
-- **[breaking]** Trait assertions to use `Type: Trait` syntax
-- **[breaking]** Field assertions to use `Type: field1, field2` syntax
-- **[breaking]** Renamed `assert_{ne,eq}_type!` to `assert_type_{ne,eq}_all!`
-
-## [0.3.4] - 2019-06-12
-### Changed
-- Aliased `assert_impl!` to `assert_impl_all!` and deprecated `assert_impl!`
-
-### Added
-- `assert_impl_all!` as replacement to `assert_impl!`
-- `assert_not_impl_all!` and `assert_not_impl_any!` macro counterparts to
-  `assert_impl_all!`
-
-### Fixed
-- `assert_eq_type!` now works with types involving lifetimes
-
-## [0.3.3] - 2019-06-12
-### Added
-- `const_assert_ne!` macro counterpart to `const_assert_eq!`
-
-### Fixed
-- `assert_eq_type!` would pass when types can coerce via `Deref`, such as with
-  `str` and `String`
-
-## [0.3.2] - 2019-05-15
-### Added
-- A `assert_eq_type!` macro that allows for checking whether inputs are the same
-  concrete type
-- A `assert_ne_type!` macro for checking whether inputs all refer to different
-  types
-
-### Fixed
-- `const_assert!` now only takes `bool` values whereas integer (or other type)
-  values could previously be passed
-
-## [0.3.1] - 2018-11-15
-### Fixed
-- Macros that refer to other internal macros can now be imported when compiling
-  for Rust 2018 ([issue
-  #10](https://github.com/nvzqz/static-assertions-rs/issues/10))
-
-## [0.3.0] - 2018-11-14
-### Changed
-- Bumped minimum supported (automatically tested) Rust version to 1.24.0
-- Moved message parameter for `assert_cfg!()` to last argument position, making
-  it consistent with other macros
-
-### Removed
-- No need to use `macro!(label; ...)` syntax when compiling on nightly Rust and
-  enabling the `nightly` feature flag
-
-## [0.2.5] - 2017-12-12
-### Changed
-- `assert_eq_size_ptr` wraps its code inside of a closure, ensuring that the
-  unsafe code inside never runs
-- Clippy no longer warns about `unneeded_field_pattern` within `assert_fields`
-
-### Added
-- Much better documentation with test examples that are guaranteed to fail at
-  compile-time
-
-### Removed
-- Removed testing features; compile failure tests are now done via doc tests
-
-## [0.2.4] - 2017-12-11
-### Removed
-- Removed the actual call to `mem::transmute` while still utilizing it for size
-  verification ([Simon Sapin], [#5])
-
-### Added
-- `assert_cfg` macro that asserts that the given configuration is set
-- `assert_fields` macro to assert that a struct type or enum variant has a given
-  field
-
-### Fixed
-- Allow more generics flexibility in `assert_impl`
-
-## [0.2.3] - 2017-08-24
-### Fixed
-- Trailing commas are now allowed
-
-### Removed
-- Removed clippy warnings
-
-## [0.2.2] - 2017-08-13
-### Added
-- Added `assert_impl` macro to ensure a type implements a given set of traits
-
-## [0.2.1] - 2017-08-13
-### Added
-- Added `assert_obj_safe` macro for ensuring that a trait is object-safe
-
-## [0.2.0] - 2017-08-12
-### Added
-- Added `assert_eq_size_ptr` macro
-
-### Fixed
-- Allow `assert_eq_size`, `const_assert`, and `const_assert_eq` in non-function
-  contexts via providing a unique label [#1]
-
-### Removed
-- **[Breaking]** Semicolon-separated `assert_eq_size` is no longer allowed
-
-## [0.1.1] - 2017-08-12
-### Added
-- Added `const_assert_eq` macro
-
-## 0.1.0 - 2017-08-12
-
-Initial release
-
-[Simon Sapin]: https://github.com/SimonSapin
-
-[`assert!`]: https://doc.rust-lang.org/stable/std/macro.assert.html
-[`const _`]: https://github.com/rust-lang/rfcs/blob/master/text/2526-const-wildcard.md
-
-[#1]: https://github.com/nvzqz/static-assertions-rs/issues/1
-[#5]: https://github.com/nvzqz/static-assertions-rs/pull/5
-
-[crate]:       https://crates.io/crates/static_assertions
-[crate-badge]: https://img.shields.io/crates/v/static_assertions.svg
-
-[Keep a Changelog]:    http://keepachangelog.com/en/1.0.0/
-[Semantic Versioning]: http://semver.org/spec/v2.0.0.html
-
-[Unreleased]: https://github.com/nvzqz/static-assertions-rs/compare/v1.1.0...HEAD
-[1.1.0]: https://github.com/nvzqz/static-assertions-rs/compare/v1.0.0...v1.1.0
-[1.0.0]: https://github.com/nvzqz/static-assertions-rs/compare/v0.3.4...v1.0.0
-[0.3.4]: https://github.com/nvzqz/static-assertions-rs/compare/v0.3.3...v0.3.4
-[0.3.3]: https://github.com/nvzqz/static-assertions-rs/compare/v0.3.2...v0.3.3
-[0.3.2]: https://github.com/nvzqz/static-assertions-rs/compare/v0.3.1...v0.3.2
-[0.3.1]: https://github.com/nvzqz/static-assertions-rs/compare/v0.3.0...v0.3.1
-[0.3.0]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.5...v0.3.0
-[0.2.5]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.4...v0.2.5
-[0.2.4]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.3...v0.2.4
-[0.2.3]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.2...v0.2.3
-[0.2.2]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.1...v0.2.2
-[0.2.1]: https://github.com/nvzqz/static-assertions-rs/compare/v0.2.0...v0.2.1
-[0.2.0]: https://github.com/nvzqz/static-assertions-rs/compare/v0.1.1...v0.2.0
-[0.1.1]: https://github.com/nvzqz/static-assertions-rs/compare/v0.1.0...v0.1.1
diff --git a/vendor/static_assertions/Cargo.toml b/vendor/static_assertions/Cargo.toml
deleted file mode 100644
index 8651ce1e..00000000
--- a/vendor/static_assertions/Cargo.toml
+++ /dev/null
@@ -1,39 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "static_assertions"
-version = "1.1.0"
-authors = ["Nikolai Vazquez"]
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "CHANGELOG.md", "LICENSE*"]
-description = "Compile-time assertions to ensure that invariants are met."
-homepage = "https://github.com/nvzqz/static-assertions-rs"
-documentation = "https://docs.rs/static_assertions/"
-readme = "README.md"
-keywords = ["assert", "static", "testing"]
-categories = ["no-std", "rust-patterns", "development-tools::testing"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/nvzqz/static-assertions-rs"
-
-[features]
-nightly = []
-[badges.is-it-maintained-issue-resolution]
-repository = "nvzqz/static-assertions-rs"
-
-[badges.is-it-maintained-open-issues]
-repository = "nvzqz/static-assertions-rs"
-
-[badges.maintenance]
-status = "passively-maintained"
-
-[badges.travis-ci]
-repository = "nvzqz/static-assertions-rs"
diff --git a/vendor/static_assertions/LICENSE-APACHE b/vendor/static_assertions/LICENSE-APACHE
deleted file mode 100644
index d6456956..00000000
--- a/vendor/static_assertions/LICENSE-APACHE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/vendor/static_assertions/LICENSE-MIT b/vendor/static_assertions/LICENSE-MIT
deleted file mode 100644
index ccc94459..00000000
--- a/vendor/static_assertions/LICENSE-MIT
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Nikolai Vazquez
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/static_assertions/README.md b/vendor/static_assertions/README.md
deleted file mode 100644
index bca222ed..00000000
--- a/vendor/static_assertions/README.md
+++ /dev/null
@@ -1,188 +0,0 @@
-[![Banner](https://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Banner.png)](https://github.com/nvzqz/static-assertions-rs)
-
-<div align="center">
-    <a href="https://crates.io/crates/static_assertions">
-        <img src="https://img.shields.io/crates/v/static_assertions.svg" alt="Crates.io">
-        <img src="https://img.shields.io/crates/d/static_assertions.svg" alt="Downloads">
-    </a>
-    <a href="https://travis-ci.org/nvzqz/static-assertions-rs">
-        <img src="https://travis-ci.org/nvzqz/static-assertions-rs.svg?branch=master" alt="Build Status">
-    </a>
-    <img src="https://img.shields.io/badge/rustc-^1.37.0-blue.svg" alt="rustc ^1.37.0">
-    <br>
-    <a href="https://www.patreon.com/nvzqz">
-        <img src="https://c5.patreon.com/external/logo/become_a_patron_button.png" alt="Become a Patron!" height="35">
-    </a>
-    <a href="https://www.paypal.me/nvzqz">
-        <img src="https://buymecoffee.intm.org/img/button-paypal-white.png" alt="Buy me a coffee" height="35">
-    </a>
-</div>
-
-Compile-time assertions for Rust, brought to you by
-[Nikolai Vazquez](https://twitter.com/NikolaiVazquez).
-
-This library lets you ensure correct assumptions about constants, types, and
-more. See the [docs] and [FAQ](#faq) for more info!
-
-## Installation
-
-This crate is available
-[on crates.io](https://crates.io/crates/static_assertions) and can be used by
-adding the following to your project's
-[`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html):
-
-```toml
-[dependencies]
-static_assertions = "1.1.0"
-```
-
-and this to your crate root (`main.rs` or `lib.rs`):
-
-```rust
-#[macro_use]
-extern crate static_assertions;
-```
-
-## Usage
-
-This crate exposes the following macros:
-- [`assert_cfg!`]
-- [`assert_eq_align!`]
-- [`assert_eq_size!`]
-- [`assert_eq_size_ptr!`]
-- [`assert_eq_size_val!`]
-- [`assert_fields!`]
-- [`assert_impl_all!`]
-- [`assert_impl_any!`]
-- [`assert_impl_one!`]
-- [`assert_not_impl_all!`]
-- [`assert_not_impl_any!`]
-- [`assert_obj_safe!`]
-- [`assert_trait_sub_all!`]
-- [`assert_trait_super_all!`]
-- [`assert_type_eq_all!`]
-- [`assert_type_ne_all!`]
-- [`const_assert!`]
-- [`const_assert_eq!`]
-- [`const_assert_ne!`]
-
-## FAQ
-
-- **Q:** When would I want to use this?
-
-  **A:** This library is useful for when wanting to ensure properties of
-  constants, types, and traits.
-
-  Basic examples:
-
-  - With the release of 1.39, `str::len` can be called in a `const`
-    context. Using [`const_assert!`], one can check that a string generated from
-    elsewhere is of a given size:
-
-    ```rust
-    const DATA: &str = include_str!("path/to/string.txt");
-
-    const_assert!(DATA.len() < 512);
-    ```
-
-  - Have a type that absolutely must implement certain traits? With
-    [`assert_impl_all!`], one can ensure this:
-
-    ```rust
-    struct Foo {
-        value: // ...
-    }
-
-    assert_impl_all!(Foo: Send, Sync);
-    ```
-
-- **Q:** How can I contribute?
-
-  **A:** A couple of ways! You can:
-
-  - Attempt coming up with some form of static analysis that you'd like to see
-    implemented. Create a [new issue] and describe how you'd imagine your
-    assertion to work, with example code to demonstrate.
-
-  - Implement your own static assertion and create a [pull request].
-
-  - Give feedback. What are some pain points? Where is it unpleasant?
-
-  - Write docs. If you're familiar with how this library works, sharing your
-    knowledge with the rest its users would be great!
-
-- **Q:** Will this affect my compiled binary?
-
-  **A:** Nope! There is zero runtime cost to using this because all checks are
-  at compile-time, and so no code is emitted to run.
-
-- **Q:** Will this affect my compile times?
-
-  **A:** Likely not by anything perceivable. If this is a concern, this library
-  can be put in `dev-dependencies`:
-
-  ```toml
-  [dev-dependencies]
-  static_assertions = "1.1.0"
-  ```
-
-  and then assertions can be conditionally run behind `#[cfg(test)]`:
-
-  ```rust
-  #[cfg(test)]
-  const_assert_eq!(MEANING_OF_LIFE, 42);
-  ```
-
-  However, the assertions will only be checked when running `cargo test`. This
-  somewhat defeats the purpose of catching false static conditions up-front with
-  a compilation failure.
-
-- **Q:** What is `const _`?
-
-  **A:** It's a way of creating an unnamed constant. This is used so that macros
-  can be called from a global scope without requiring a scope-unique label. This
-  library makes use of the side effects of evaluating the `const` expression.
-  See the feature's
-  [tracking issue](https://github.com/rust-lang/rust/issues/54912)
-  and
-  [issue #1](https://github.com/nvzqz/static-assertions-rs/issues/1)
-  for more info.
-
-## Changes
-
-See [`CHANGELOG.md`](https://github.com/nvzqz/static-assertions-rs/blob/master/CHANGELOG.md)
-for a complete list of what has changed from one version to another.
-
-## License
-
-This project is released under either:
-
-- [MIT License](https://github.com/nvzqz/static-assertions-rs/blob/master/LICENSE-MIT)
-
-- [Apache License (Version 2.0)](https://github.com/nvzqz/static-assertions-rs/blob/master/LICENSE-APACHE)
-
-at your choosing.
-
-[new issue]:    https://github.com/nvzqz/static-assertions-rs/issues/new
-[pull request]: https://github.com/nvzqz/static-assertions-rs/pulls
-[docs]:         https://docs.rs/static_assertions
-
-[`assert_cfg!`]:             https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_cfg.html
-[`assert_eq_align!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_eq_align.html
-[`assert_eq_size!`]:         https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_eq_size.html
-[`assert_eq_size_ptr!`]:     https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_eq_size_ptr.html
-[`assert_eq_size_val!`]:     https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_eq_size_val.html
-[`assert_fields!`]:          https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_fields.html
-[`assert_impl_all!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_impl_all.html
-[`assert_impl_any!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_impl_any.html
-[`assert_impl_one!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_impl_one.html
-[`assert_not_impl_all!`]:    https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_not_impl_all.html
-[`assert_not_impl_any!`]:    https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_not_impl_any.html
-[`assert_obj_safe!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_obj_safe.html
-[`assert_trait_sub_all!`]:   https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_trait_sub_all.html
-[`assert_trait_super_all!`]: https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_trait_super_all.html
-[`assert_type_eq_all!`]:     https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_type_eq_all.html
-[`assert_type_ne_all!`]:     https://docs.rs/static_assertions/1.1.0/static_assertions/macro.assert_type_ne_all.html
-[`const_assert!`]:           https://docs.rs/static_assertions/1.1.0/static_assertions/macro.const_assert.html
-[`const_assert_eq!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.const_assert_eq.html
-[`const_assert_ne!`]:        https://docs.rs/static_assertions/1.1.0/static_assertions/macro.const_assert_ne.html
diff --git a/vendor/static_assertions/src/assert_cfg.rs b/vendor/static_assertions/src/assert_cfg.rs
deleted file mode 100644
index 24282c1f..00000000
--- a/vendor/static_assertions/src/assert_cfg.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-/// Asserts that a given configuration is set.
-///
-/// # Examples
-///
-/// A project will simply fail to compile if the given configuration is not set.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// // We're not masochists
-/// # #[cfg(not(target_pointer_width = "16"))] // Just in case
-/// assert_cfg!(not(target_pointer_width = "16"));
-/// ```
-///
-/// If a project does not support a set of configurations, you may want to
-/// report why. There is the option of providing a compile error message string:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// # #[cfg(any(unix, windows))]
-/// assert_cfg!(any(unix, windows), "There is only support for Unix or Windows");
-///
-/// // User needs to specify a database back-end
-/// # #[cfg(target_pointer_width = "0")] // Impossible
-/// assert_cfg!(all(not(all(feature = "mysql", feature = "mongodb")),
-///                 any(    feature = "mysql", feature = "mongodb")),
-///             "Must exclusively use MySQL or MongoDB as database back-end");
-/// ```
-///
-/// Some configurations are impossible. For example, we can't be compiling for
-/// both macOS _and_ Windows simultaneously:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_cfg!(all(target_os = "macos",
-///                 target_os = "windows"),
-///             "No, that's not how it works! ಠ_ಠ");
-/// ```
-#[macro_export]
-macro_rules! assert_cfg {
-    () => {};
-    ($($cfg:meta)+, $msg:expr $(,)?) => {
-        #[cfg(not($($cfg)+))]
-        compile_error!($msg);
-    };
-    ($($cfg:tt)*) => {
-        #[cfg(not($($cfg)*))]
-        compile_error!(concat!("Cfg does not pass: ", stringify!($($cfg)*)));
-    };
-}
diff --git a/vendor/static_assertions/src/assert_eq_align.rs b/vendor/static_assertions/src/assert_eq_align.rs
deleted file mode 100644
index 69412dae..00000000
--- a/vendor/static_assertions/src/assert_eq_align.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-/// Asserts that types are equal in alignment.
-///
-/// This is useful when ensuring that pointer arithmetic is done correctly, or
-/// when [FFI] requires a type to have the same alignment as some foreign type.
-///
-/// # Examples
-///
-/// A `usize` has the same alignment as any pointer type:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_eq_align!(usize, *const u8, *mut u8);
-/// ```
-///
-/// The following passes because `[i32; 4]` has the same alignment as `i32`:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_eq_align!([i32; 4], i32);
-/// ```
-///
-/// The following example fails to compile because `i32x4` explicitly has 4
-/// times the alignment as `[i32; 4]`:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// # #[allow(non_camel_case_types)]
-/// #[repr(align(16))]
-/// struct i32x4([i32; 4]);
-///
-/// assert_eq_align!(i32x4, [i32; 4]);
-/// ```
-///
-/// [FFI]: https://en.wikipedia.org/wiki/Foreign_function_interface
-#[macro_export]
-macro_rules! assert_eq_align {
-    ($x:ty, $($xs:ty),+ $(,)?) => {
-        const _: fn() = || {
-            // Assigned instance must match the annotated type or else it will
-            // fail to compile
-            use $crate::_core::mem::align_of;
-            $(let _: [(); align_of::<$x>()] = [(); align_of::<$xs>()];)+
-        };
-    };
-}
diff --git a/vendor/static_assertions/src/assert_eq_size.rs b/vendor/static_assertions/src/assert_eq_size.rs
deleted file mode 100644
index 9c3c4901..00000000
--- a/vendor/static_assertions/src/assert_eq_size.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-/// Asserts that types are equal in size.
-///
-/// When performing operations such as pointer casts or dealing with [`usize`]
-/// versus [`u64`] versus [`u32`], the size of your types matter. That is where
-/// this macro comes into play.
-///
-/// # Alternatives
-///
-/// There also exists [`assert_eq_size_val`](macro.assert_eq_size_val.html) and
-/// [`assert_eq_size_ptr`](macro.assert_eq_size_ptr.html). Instead of specifying
-/// types to compare, values' sizes can be directly compared against each other.
-///
-/// # Examples
-///
-/// These three types, despite being very different, all have the same size:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_eq_size!([u8; 4], (u16, u16), u32);
-/// ```
-///
-/// The following example fails to compile because `u32` has 4 times the size of
-/// `u8`:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_eq_size!(u32, u8);
-/// ```
-///
-/// [`usize`]: https://doc.rust-lang.org/std/primitive.usize.html
-/// [`u64`]: https://doc.rust-lang.org/std/primitive.u64.html
-/// [`u32`]: https://doc.rust-lang.org/std/primitive.u32.html
-#[macro_export]
-macro_rules! assert_eq_size {
-    ($x:ty, $($xs:ty),+ $(,)?) => {
-        const _: fn() = || {
-            $(let _ = $crate::_core::mem::transmute::<$x, $xs>;)+
-        };
-    };
-}
-
-/// Asserts that values pointed to are equal in size.
-///
-/// # Examples
-///
-/// This especially is useful for when coercing pointers between different types
-/// and ensuring the underlying values are the same size.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// fn operation(x: &(u32, u32), y: &[u16; 4]) {
-///     assert_eq_size_ptr!(x, y);
-///     // ...
-/// }
-/// ```
-///
-/// The following example fails to compile because byte arrays of different
-/// lengths have different sizes:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions;
-/// # fn main() {
-/// static BYTES: &[u8; 4] = &[
-///     /* ... */
-///     # 0; 4
-/// ];
-///
-/// static TABLE: &[u8; 16] = &[
-///     /* ... */
-///     # 0; 16
-/// ];
-///
-/// assert_eq_size_ptr!(BYTES, TABLE);
-/// ```
-#[macro_export]
-macro_rules! assert_eq_size_ptr {
-    ($x:expr, $($xs:expr),+ $(,)?) => {
-        #[allow(unknown_lints, unsafe_code, forget_copy, useless_transmute)]
-        let _ = || unsafe {
-            use $crate::_core::{mem, ptr};
-            let mut copy = ptr::read($x);
-            $(ptr::write(&mut copy, mem::transmute(ptr::read($xs)));)+
-            mem::forget(copy);
-        };
-    }
-}
-
-/// Asserts that values are equal in size.
-///
-/// This macro doesn't consume its arguments and thus works for
-/// non-[`Clone`]able values.
-///
-/// # Examples
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions;
-/// # fn main() {
-/// struct Byte(u8);
-///
-/// let x = 10u8;
-/// let y = Byte(42); // Works for non-cloneable types
-///
-/// assert_eq_size_val!(x, y);
-/// assert_eq_size_val!(x, y, 0u8);
-/// # }
-/// ```
-///
-/// Even though both values are 0, they are of types with different sizes:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions;
-/// # fn main() {
-/// assert_eq_size_val!(0u8, 0u32);
-/// # }
-/// ```
-///
-/// [`Clone`]: https://doc.rust-lang.org/std/clone/trait.Clone.html
-#[macro_export(local_inner_macros)]
-macro_rules! assert_eq_size_val {
-    ($x:expr, $($xs:expr),+ $(,)?) => {
-        assert_eq_size_ptr!(&$x, $(&$xs),+);
-    }
-}
diff --git a/vendor/static_assertions/src/assert_fields.rs b/vendor/static_assertions/src/assert_fields.rs
deleted file mode 100644
index 00f62427..00000000
--- a/vendor/static_assertions/src/assert_fields.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-/// Asserts that the type has the given fields.
-///
-/// # Examples
-///
-/// One common use case is when types have fields defined multiple times as a
-/// result of `#[cfg]`. This can be an issue when exposing a public API.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions;
-/// pub struct Ty {
-///     #[cfg(windows)]
-///     pub val1: u8,
-///     #[cfg(not(windows))]
-///     pub val1: usize,
-///
-///     #[cfg(unix)]
-///     pub val2: u32,
-///     #[cfg(not(unix))]
-///     pub val2: usize,
-/// }
-///
-/// // Always have `val2` regardless of OS
-/// assert_fields!(Ty: val2);
-/// ```
-///
-/// This macro even works with `enum` variants:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// enum Data {
-///     Val {
-///         id: i32,
-///         name: String,
-///         bytes: [u8; 128],
-///     },
-///     Ptr(*const u8),
-/// }
-///
-/// assert_fields!(Data::Val: id, bytes);
-/// ```
-///
-/// The following example fails to compile because [`Range`] does not have a field named `middle`:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// use std::ops::Range;
-///
-/// assert_fields!(Range<u32>: middle);
-/// ```
-///
-/// [`Range`]: https://doc.rust-lang.org/std/ops/struct.Range.html
-#[macro_export]
-macro_rules! assert_fields {
-    ($t:ident::$v:ident: $($f:ident),+) => {
-        #[allow(unknown_lints, unneeded_field_pattern)]
-        const _: fn() = || {
-            #[allow(dead_code, unreachable_patterns)]
-            fn assert(value: $t) {
-                match value {
-                    $($t::$v { $f: _, .. } => {},)+
-                    _ => {}
-                }
-            }
-        };
-    };
-    ($t:path: $($f:ident),+) => {
-        #[allow(unknown_lints, unneeded_field_pattern)]
-        const _: fn() = || {
-            $(let $t { $f: _, .. };)+
-        };
-    };
-}
diff --git a/vendor/static_assertions/src/assert_impl.rs b/vendor/static_assertions/src/assert_impl.rs
deleted file mode 100644
index 480b6b6c..00000000
--- a/vendor/static_assertions/src/assert_impl.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-/// Asserts that the type implements exactly one in a set of traits.
-///
-/// Related:
-/// - [`assert_impl_any!`]
-/// - [`assert_impl_all!`]
-/// - [`assert_not_impl_all!`]
-/// - [`assert_not_impl_any!`]
-///
-/// # Examples
-///
-/// Given some type `Foo`, it is expected to implement either `Snap`, `Crackle`,
-/// or `Pop`:
-///
-/// ```compile_fail
-/// # use static_assertions::assert_impl_one; fn main() {}
-/// struct Foo;
-///
-/// trait Snap {}
-/// trait Crackle {}
-/// trait Pop {}
-///
-/// assert_impl_one!(Foo: Snap, Crackle, Pop);
-/// ```
-///
-/// If _only_ `Crackle` is implemented, the assertion passes:
-///
-/// ```
-/// # use static_assertions::assert_impl_one; fn main() {}
-/// # struct Foo;
-/// # trait Snap {}
-/// # trait Crackle {}
-/// # trait Pop {}
-/// impl Crackle for Foo {}
-///
-/// assert_impl_one!(Foo: Snap, Crackle, Pop);
-/// ```
-///
-/// If `Snap` or `Pop` is _also_ implemented, the assertion fails:
-///
-/// ```compile_fail
-/// # use static_assertions::assert_impl_one; fn main() {}
-/// # struct Foo;
-/// # trait Snap {}
-/// # trait Crackle {}
-/// # trait Pop {}
-/// # impl Crackle for Foo {}
-/// impl Pop for Foo {}
-///
-/// assert_impl_one!(Foo: Snap, Crackle, Pop);
-/// ```
-///
-/// [`assert_impl_any!`]:     macro.assert_impl_any.html
-/// [`assert_impl_all!`]:     macro.assert_impl_all.html
-/// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html
-/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html
-#[macro_export]
-macro_rules! assert_impl_one {
-    ($x:ty: $($t:path),+ $(,)?) => {
-        const _: fn() = || {
-            // Generic trait that must be implemented for `$x` exactly once.
-            trait AmbiguousIfMoreThanOne<A> {
-                // Required for actually being able to reference the trait.
-                fn some_item() {}
-            }
-
-            // Creates multiple scoped `Token` types for each trait `$t`, over
-            // which a specialized `AmbiguousIfMoreThanOne<Token>` is
-            // implemented for every type that implements `$t`.
-            $({
-                #[allow(dead_code)]
-                struct Token;
-
-                impl<T: ?Sized + $t> AmbiguousIfMoreThanOne<Token> for T {}
-            })+
-
-            // If there is only one specialized trait impl, type inference with
-            // `_` can be resolved and this can compile. Fails to compile if
-            // `$x` implements more than one `AmbiguousIfMoreThanOne<Token>` or
-            // does not implement any at all.
-            let _ = <$x as AmbiguousIfMoreThanOne<_>>::some_item;
-        };
-    };
-}
-
-/// Asserts that the type implements _all_ of the given traits.
-///
-/// See [`assert_not_impl_all!`] for achieving the opposite effect.
-///
-/// # Examples
-///
-/// This can be used to ensure types implement auto traits such as [`Send`] and
-/// [`Sync`], as well as traits with [blanket `impl`s][blanket].
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl_all!(u32: Copy, Send);
-/// assert_impl_all!(&str: Into<String>);
-/// ```
-///
-/// The following example fails to compile because raw pointers do not implement
-/// [`Send`] since they cannot be moved between threads safely:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl_all!(*const u8: Send);
-/// ```
-///
-/// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-/// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
-#[macro_export]
-macro_rules! assert_impl_all {
-    ($type:ty: $($trait:path),+ $(,)?) => {
-        const _: fn() = || {
-            // Only callable when `$type` implements all traits in `$($trait)+`.
-            fn assert_impl_all<T: ?Sized $(+ $trait)+>() {}
-            assert_impl_all::<$type>();
-        };
-    };
-}
-
-/// Asserts that the type implements _any_ of the given traits.
-///
-/// See [`assert_not_impl_any!`] for achieving the opposite effect.
-///
-/// # Examples
-///
-/// `u8` cannot be converted from `u16`, but it can be converted into `u16`:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl_any!(u8: From<u16>, Into<u16>);
-/// ```
-///
-/// The unit type cannot be converted from `u8` or `u16`, but it does implement
-/// [`Send`]:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl_any!((): From<u8>, From<u16>, Send);
-/// ```
-///
-/// The following example fails to compile because raw pointers do not implement
-/// [`Send`] or [`Sync`] since they cannot be moved or shared between threads
-/// safely:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl_any!(*const u8: Send, Sync);
-/// ```
-///
-/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-#[macro_export]
-macro_rules! assert_impl_any {
-    ($x:ty: $($t:path),+ $(,)?) => {
-        const _: fn() = || {
-            use $crate::_core::marker::PhantomData;
-            use $crate::_core::ops::Deref;
-
-            // Fallback to use as the first iterative assignment to `previous`.
-            let previous = AssertImplAnyFallback;
-            struct AssertImplAnyFallback;
-
-            // Ensures that blanket traits can't impersonate the method. This
-            // prevents a false positive attack where---if a blanket trait is in
-            // scope that has `_static_assertions_impl_any`---the macro will
-            // compile when it shouldn't.
-            //
-            // See https://github.com/nvzqz/static-assertions-rs/issues/19 for
-            // more info.
-            struct ActualAssertImplAnyToken;
-            trait AssertImplAnyToken {}
-            impl AssertImplAnyToken for ActualAssertImplAnyToken {}
-            fn assert_impl_any_token<T: AssertImplAnyToken>(_: T) {}
-
-            $(let previous = {
-                struct Wrapper<T, N>(PhantomData<T>, N);
-
-                // If the method for this wrapper can't be called then the
-                // compiler will insert a deref and try again. This forwards the
-                // compiler's next attempt to the previous wrapper.
-                impl<T, N> Deref for Wrapper<T, N> {
-                    type Target = N;
-
-                    fn deref(&self) -> &Self::Target {
-                        &self.1
-                    }
-                }
-
-                // This impl is bounded on the `$t` trait, so the method can
-                // only be called if `$x` implements `$t`. This is why a new
-                // `Wrapper` is defined for each `previous`.
-                impl<T: $t, N> Wrapper<T, N> {
-                    fn _static_assertions_impl_any(&self) -> ActualAssertImplAnyToken {
-                        ActualAssertImplAnyToken
-                    }
-                }
-
-                Wrapper::<$x, _>(PhantomData, previous)
-            };)+
-
-            // Attempt to find the method that can actually be called. The found
-            // method must return a type that implements the sealed `Token`
-            // trait, this ensures that blanket trait methods can't cause this
-            // macro to compile.
-            assert_impl_any_token(previous._static_assertions_impl_any());
-        };
-    };
-}
-
-/// Asserts that the type does **not** implement _all_ of the given traits.
-///
-/// This can be used to ensure types do not implement auto traits such as
-/// [`Send`] and [`Sync`], as well as traits with [blanket `impl`s][blanket].
-///
-/// Note that the combination of all provided traits is required to not be
-/// implemented. If you want to check that none of multiple traits are
-/// implemented you should invoke [`assert_not_impl_any!`] instead.
-///
-/// # Examples
-///
-/// Although `u32` implements `From<u16>`, it does not implement `Into<usize>`:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_not_impl_all!(u32: From<u16>, Into<usize>);
-/// ```
-///
-/// The following example fails to compile since `u32` can be converted into
-/// `u64`.
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_not_impl_all!(u32: Into<u64>);
-/// ```
-///
-/// The following compiles because [`Cell`] is not both [`Sync`] _and_ [`Send`]:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// use std::cell::Cell;
-///
-/// assert_not_impl_all!(Cell<u32>: Sync, Send);
-/// ```
-///
-/// But it is [`Send`], so this fails to compile:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// # std::cell::Cell;
-/// assert_not_impl_all!(Cell<u32>: Send);
-/// ```
-///
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-/// [`assert_not_impl_any!`]: macro.assert_not_impl_any.html
-/// [`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.html
-/// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
-#[macro_export]
-macro_rules! assert_not_impl_all {
-    ($x:ty: $($t:path),+ $(,)?) => {
-        const _: fn() = || {
-            // Generic trait with a blanket impl over `()` for all types.
-            trait AmbiguousIfImpl<A> {
-                // Required for actually being able to reference the trait.
-                fn some_item() {}
-            }
-
-            impl<T: ?Sized> AmbiguousIfImpl<()> for T {}
-
-            // Used for the specialized impl when *all* traits in
-            // `$($t)+` are implemented.
-            #[allow(dead_code)]
-            struct Invalid;
-
-            impl<T: ?Sized $(+ $t)+> AmbiguousIfImpl<Invalid> for T {}
-
-            // If there is only one specialized trait impl, type inference with
-            // `_` can be resolved and this can compile. Fails to compile if
-            // `$x` implements `AmbiguousIfImpl<Invalid>`.
-            let _ = <$x as AmbiguousIfImpl<_>>::some_item;
-        };
-    };
-}
-
-/// Asserts that the type does **not** implement _any_ of the given traits.
-///
-/// This can be used to ensure types do not implement auto traits such as
-/// [`Send`] and [`Sync`], as well as traits with [blanket `impl`s][blanket].
-///
-/// This macro causes a compilation failure if any of the provided individual
-/// traits are implemented for the type. If you want to check that a combination
-/// of traits is not implemented you should invoke [`assert_not_impl_all!`]
-/// instead. For single traits both macros behave the same.
-///
-/// # Examples
-///
-/// If `u32` were to implement `Into` conversions for `usize` _and_ for `u8`,
-/// the following would fail to compile:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_not_impl_any!(u32: Into<usize>, Into<u8>);
-/// ```
-///
-/// This is also good for simple one-off cases:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_not_impl_any!(&'static mut u8: Copy);
-/// ```
-///
-/// The following example fails to compile since `u32` can be converted into
-/// `u64` even though it can not be converted into a `u16`:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_not_impl_any!(u32: Into<u64>, Into<u16>);
-/// ```
-///
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-/// [`assert_not_impl_all!`]: macro.assert_not_impl_all.html
-/// [blanket]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
-#[macro_export]
-macro_rules! assert_not_impl_any {
-    ($x:ty: $($t:path),+ $(,)?) => {
-        const _: fn() = || {
-            // Generic trait with a blanket impl over `()` for all types.
-            trait AmbiguousIfImpl<A> {
-                // Required for actually being able to reference the trait.
-                fn some_item() {}
-            }
-
-            impl<T: ?Sized> AmbiguousIfImpl<()> for T {}
-
-            // Creates multiple scoped `Invalid` types for each trait `$t`, over
-            // which a specialized `AmbiguousIfImpl<Invalid>` is implemented for
-            // every type that implements `$t`.
-            $({
-                #[allow(dead_code)]
-                struct Invalid;
-
-                impl<T: ?Sized + $t> AmbiguousIfImpl<Invalid> for T {}
-            })+
-
-            // If there is only one specialized trait impl, type inference with
-            // `_` can be resolved and this can compile. Fails to compile if
-            // `$x` implements any `AmbiguousIfImpl<Invalid>`.
-            let _ = <$x as AmbiguousIfImpl<_>>::some_item;
-        };
-    };
-}
diff --git a/vendor/static_assertions/src/assert_obj_safe.rs b/vendor/static_assertions/src/assert_obj_safe.rs
deleted file mode 100644
index ecbba964..00000000
--- a/vendor/static_assertions/src/assert_obj_safe.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-// FIXME: Link below is required to render in index
-/// Asserts that the traits support dynamic dispatch
-/// ([object-safety](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#object-safety-is-required-for-trait-objects)).
-///
-/// This is useful for when changes are made to a trait that accidentally
-/// prevent it from being used as an [object]. Such a case would be adding a
-/// generic method and forgetting to add `where Self: Sized` after it. If left
-/// unnoticed, that mistake will affect crate users and break both forward and
-/// backward compatibility.
-///
-/// # Examples
-///
-/// When exposing a public API, it's important that traits that could previously
-/// use dynamic dispatch can still do so in future compatible crate versions.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// trait MySafeTrait {
-///     fn foo(&self) -> u32;
-/// }
-///
-/// assert_obj_safe!(std::fmt::Write, MySafeTrait);
-/// ```
-///
-/// Works with traits that are not in the calling module:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// mod inner {
-///     pub trait BasicTrait {
-///         fn bar(&self);
-///     }
-///     assert_obj_safe!(BasicTrait);
-/// }
-///
-/// assert_obj_safe!(inner::BasicTrait);
-/// ```
-///
-/// The following example fails to compile because raw pointers cannot be sent
-///  between threads safely:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_impl!(*const u8, Send);
-/// ```
-///
-/// The following example fails to compile because generics without
-/// `where Self: Sized` are not allowed in [object-safe][object] trait methods:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// trait MyUnsafeTrait {
-///     fn baz<T>(&self) -> T;
-/// }
-///
-/// assert_obj_safe!(MyUnsafeTrait);
-/// ```
-///
-/// When we fix that, the previous code will compile:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// trait MyUnsafeTrait {
-///     fn baz<T>(&self) -> T where Self: Sized;
-/// }
-///
-/// assert_obj_safe!(MyUnsafeTrait);
-/// ```
-///
-/// [object]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html#object-safety-is-required-for-trait-objects
-#[macro_export]
-macro_rules! assert_obj_safe {
-    ($($xs:path),+ $(,)?) => {
-        $(const _: Option<&$xs> = None;)+
-    };
-}
diff --git a/vendor/static_assertions/src/assert_trait.rs b/vendor/static_assertions/src/assert_trait.rs
deleted file mode 100644
index c231492f..00000000
--- a/vendor/static_assertions/src/assert_trait.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-/// Asserts that the trait is a child of all of the other traits.
-///
-/// Related:
-/// - [`assert_trait_super_all!`]
-///
-/// # Examples
-///
-/// All types that implement [`Copy`] must implement [`Clone`]:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_trait_sub_all!(Copy: Clone);
-/// ```
-///
-/// All types that implement [`Ord`] must implement [`PartialEq`], [`Eq`], and
-/// [`PartialOrd`]:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_trait_sub_all!(Ord: PartialEq, Eq, PartialOrd);
-/// ```
-///
-/// The following example fails to compile because [`Eq`] is not required for
-/// [`PartialOrd`]:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_trait_sub_all!(PartialOrd: Eq);
-/// ```
-///
-/// [`assert_trait_super_all!`]: macro.assert_trait_super_all.html
-///
-/// [`Copy`]:       https://doc.rust-lang.org/std/marker/trait.Copy.html
-/// [`Clone`]:      https://doc.rust-lang.org/std/clone/trait.Clone.html
-/// [`Ord`]:        https://doc.rust-lang.org/std/cmp/trait.Ord.html
-/// [`PartialOrd`]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html
-/// [`Eq`]:         https://doc.rust-lang.org/std/cmp/trait.Eq.html
-/// [`PartialEq`]:  https://doc.rust-lang.org/std/cmp/trait.PartialEq.html
-#[macro_export]
-macro_rules! assert_trait_sub_all {
-    ($sub:path: $($super:path),+ $(,)?) => {
-        const _: () = {
-            // One scope per super-trait.
-            $({
-                #[allow(non_camel_case_types)]
-                trait __Impl_Implication: $super {}
-
-                // Can only be implemented for `$sub` types if `$super` is
-                // also implemented.
-                impl<T: $sub> __Impl_Implication for T {}
-            })+
-        };
-    };
-}
-
-/// Asserts that the trait is a parent of all of the other traits.
-///
-/// Related:
-/// - [`assert_trait_sub_all!`]
-///
-/// # Examples
-///
-/// With this, traits `A` and `B` can both be tested to require [`Copy`] on a
-/// single line:
-///
-/// ```
-/// # use static_assertions::assert_trait_super_all;
-/// trait A: Copy {}
-/// trait B: Copy {}
-///
-/// assert_trait_super_all!(Copy: A, B);
-/// ```
-///
-/// Otherwise, each sub-trait would require its own call to
-/// [`assert_trait_sub_all!`]:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// # trait A: Copy {}
-/// # trait B: Copy {}
-/// assert_trait_sub_all!(A: Copy);
-/// assert_trait_sub_all!(B: Copy);
-/// ```
-///
-/// The following example fails to compile because trait `C` does not require
-/// [`Copy`]:
-///
-/// ```compile_fail
-/// # use static_assertions::assert_trait_super_all;
-/// # trait A: Copy {}
-/// # trait B: Copy {}
-/// trait C {}
-///
-/// assert_trait_super_all!(Copy: A, B, C);
-/// ```
-///
-/// [`assert_trait_sub_all!`]: macro.assert_trait_sub_all.html
-///
-/// [`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html
-#[macro_export(local_inner_macros)]
-macro_rules! assert_trait_super_all {
-    ($super:path: $($sub:path),+ $(,)?) => {
-        $(assert_trait_sub_all!($sub: $super);)+
-    };
-}
diff --git a/vendor/static_assertions/src/assert_type.rs b/vendor/static_assertions/src/assert_type.rs
deleted file mode 100644
index dd2dc2a6..00000000
--- a/vendor/static_assertions/src/assert_type.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-/// Asserts that _all_ types in a list are equal to each other.
-///
-/// # Examples
-///
-/// Often times, type aliases are used to express usage semantics via naming. In
-/// some cases, the underlying type may differ based on platform. However, other
-/// types like [`c_float`] will always alias the same type.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// use std::os::raw::c_float;
-///
-/// assert_type_eq_all!(c_float, f32);
-/// ```
-///
-/// This macro can also be used to compare types that involve lifetimes! Just
-/// use `'static` in that case:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions;
-/// # fn main() {
-/// type Buf<'a> = &'a [u8];
-///
-/// assert_type_eq_all!(Buf<'static>, &'static [u8]);
-/// # }
-/// ```
-///
-/// The following example fails to compile because `String` and `str` do not
-/// refer to the same type:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_type_eq_all!(String, str);
-/// ```
-///
-/// This should also work the other way around, regardless of [`Deref`]
-/// implementations.
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_type_eq_all!(str, String);
-/// ```
-///
-/// [`c_float`]: https://doc.rust-lang.org/std/os/raw/type.c_float.html
-/// [`Deref`]: https://doc.rust-lang.org/std/ops/trait.Deref.html
-#[macro_export]
-macro_rules! assert_type_eq_all {
-    ($x:ty, $($xs:ty),+ $(,)*) => {
-        const _: fn() = || { $({
-            trait TypeEq {
-                type This: ?Sized;
-            }
-
-            impl<T: ?Sized> TypeEq for T {
-                type This = Self;
-            }
-
-            fn assert_type_eq_all<T, U>()
-            where
-                T: ?Sized + TypeEq<This = U>,
-                U: ?Sized,
-            {}
-
-            assert_type_eq_all::<$x, $xs>();
-        })+ };
-    };
-}
-
-/// Asserts that _all_ types are **not** equal to each other.
-///
-/// # Examples
-///
-/// Rust has all sorts of slices, but they represent different types of data:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// assert_type_ne_all!([u8], [u16], str);
-/// ```
-///
-/// The following example fails to compile because [`c_uchar`] is a type alias
-/// for [`u8`]:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// use std::os::raw::c_uchar;
-///
-/// assert_type_ne_all!(c_uchar, u8, u32);
-/// ```
-///
-/// [`c_uchar`]: https://doc.rust-lang.org/std/os/raw/type.c_uchar.html
-/// [`u8`]: https://doc.rust-lang.org/std/primitive.u8.html
-#[macro_export]
-macro_rules! assert_type_ne_all {
-    ($x:ty, $($y:ty),+ $(,)?) => {
-        const _: fn() = || {
-            trait MutuallyExclusive {}
-            impl MutuallyExclusive for $x {}
-            $(impl MutuallyExclusive for $y {})+
-        };
-    };
-}
diff --git a/vendor/static_assertions/src/const_assert.rs b/vendor/static_assertions/src/const_assert.rs
deleted file mode 100644
index 16ae4a6b..00000000
--- a/vendor/static_assertions/src/const_assert.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-/// Asserts that constant expressions evaluate to `true`.
-///
-/// Constant expressions can be ensured to have certain properties via this
-/// macro If the expression evaluates to `false`, the file will fail to compile.
-/// This is synonymous to [`static_assert` in C++][static_assert].
-///
-/// # Alternatives
-///
-/// There also exists [`const_assert_eq`](macro.const_assert_eq.html) for
-/// validating whether a sequence of expressions are equal to one another.
-///
-/// # Examples
-///
-/// A common use case is to guarantee properties about a constant value that's
-/// generated via meta-programming.
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const VALUE: i32 = // ...
-/// # 3;
-///
-/// const_assert!(VALUE >= 2);
-/// ```
-///
-/// Inputs are type-checked as booleans:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const_assert!(!0);
-/// ```
-///
-/// Despite this being a macro, we see this produces a type error:
-///
-/// ```txt
-///   | const_assert!(!0);
-///   |               ^^ expected bool, found integral variable
-///   |
-///   = note: expected type `bool`
-///              found type `{integer}`
-/// ```
-///
-/// The following fails to compile because multiplying by 5 does not have an
-/// identity property:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const_assert!(5 * 5 == 5);
-/// ```
-///
-/// [static_assert]: http://en.cppreference.com/w/cpp/language/static_assert
-#[macro_export]
-macro_rules! const_assert {
-    ($x:expr $(,)?) => {
-        #[allow(unknown_lints, eq_op)]
-        const _: [(); 0 - !{ const ASSERT: bool = $x; ASSERT } as usize] = [];
-    };
-}
-
-/// Asserts that constants are equal in value.
-///
-/// # Examples
-///
-/// This works as a shorthand for `const_assert!(a == b)`:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const TWO: usize = 2;
-///
-/// const_assert_eq!(TWO * TWO, TWO + TWO);
-/// ```
-///
-/// Just because 2 × 2 = 2 + 2 doesn't mean it holds true for other numbers:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const_assert_eq!(4 + 4, 4 * 4);
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! const_assert_eq {
-    ($x:expr, $y:expr $(,)?) => {
-        const_assert!($x == $y);
-    };
-}
-
-/// Asserts that constants are **not** equal in value.
-///
-/// # Examples
-///
-/// This works as a shorthand for `const_assert!(a != b)`:
-///
-/// ```
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const NUM: usize = 32;
-///
-/// const_assert_ne!(NUM * NUM, 64);
-/// ```
-///
-/// The following example fails to compile because 2 is magic and 2 × 2 = 2 + 2:
-///
-/// ```compile_fail
-/// # #[macro_use] extern crate static_assertions; fn main() {}
-/// const_assert_ne!(2 + 2, 2 * 2);
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! const_assert_ne {
-    ($x:expr, $y:expr $(,)?) => {
-        const_assert!($x != $y);
-    };
-}
diff --git a/vendor/static_assertions/src/lib.rs b/vendor/static_assertions/src/lib.rs
deleted file mode 100644
index a43cc1f5..00000000
--- a/vendor/static_assertions/src/lib.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! [![Banner](https://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Banner.png)](https://github.com/nvzqz/static-assertions-rs)
-//!
-//! <div align="center">
-//!     <a href="https://crates.io/crates/static_assertions">
-//!         <img src="https://img.shields.io/crates/d/static_assertions.svg" alt="Downloads">
-//!     </a>
-//!     <a href="https://travis-ci.org/nvzqz/static-assertions-rs">
-//!         <img src="https://travis-ci.org/nvzqz/static-assertions-rs.svg?branch=master" alt="Build Status">
-//!     </a>
-//!     <img src="https://img.shields.io/badge/rustc-^1.37.0-blue.svg" alt="rustc ^1.37.0">
-//!     <br><br>
-//! </div>
-//!
-//! Assertions to ensure correct assumptions about constants, types, and more.
-//!
-//! _All_ checks provided by this crate are performed at [compile-time]. This
-//! allows for finding errors quickly and early when it comes to ensuring
-//! certain features or aspects of a codebase. These macros are especially
-//! important when exposing a public API that requires types to be the same size
-//! or implement certain traits.
-//!
-//! # Usage
-//!
-//! This crate is available [on crates.io][crate] and can be used by adding the
-//! following to your project's [`Cargo.toml`]:
-//!
-//! ```toml
-//! [dependencies]
-//! static_assertions = "1.1.0"
-//! ```
-//!
-//! and this to your crate root (`main.rs` or `lib.rs`):
-//!
-//! ```
-//! #[macro_use]
-//! extern crate static_assertions;
-//! # fn main() {}
-//! ```
-//!
-//! When using [Rust 2018 edition][2018], the following shorthand can help if
-//! having `#[macro_use]` is undesirable.
-//!
-//! ```edition2018
-//! extern crate static_assertions as sa;
-//!
-//! sa::const_assert!(true);
-//! ```
-//!
-//! # Examples
-//!
-//! Very thorough examples are provided in the docs for
-//! [each individual macro](#macros). Failure case examples are also documented.
-//!
-//! # Changes
-//!
-//! See [`CHANGELOG.md`](https://github.com/nvzqz/static-assertions-rs/blob/master/CHANGELOG.md)
-//! for an exhaustive list of what has changed from one version to another.
-//!
-//! # Donate
-//!
-//! This project is made freely available (as in free beer), but unfortunately
-//! not all beer is free! So, if you would like to buy me a beer (or coffee or
-//! *more*), then consider supporting my work that's benefited your project
-//! and thousands of others.
-//!
-//! <a href="https://www.patreon.com/nvzqz">
-//!     <img src="https://c5.patreon.com/external/logo/become_a_patron_button.png" alt="Become a Patron!" height="35">
-//! </a>
-//! <a href="https://www.paypal.me/nvzqz">
-//!     <img src="https://buymecoffee.intm.org/img/button-paypal-white.png" alt="Buy me a coffee" height="35">
-//! </a>
-//!
-//! [Rust 1.37]: https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html
-//! [2018]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html#rust-2018
-//! [crate]: https://crates.io/crates/static_assertions
-//! [compile-time]: https://en.wikipedia.org/wiki/Compile_time
-//! [`Cargo.toml`]: https://doc.rust-lang.org/cargo/reference/manifest.html
-
-#![doc(html_root_url = "https://docs.rs/static_assertions/1.1.0")]
-#![doc(html_logo_url = "https://raw.githubusercontent.com/nvzqz/static-assertions-rs/assets/Icon.png")]
-
-#![no_std]
-
-#![deny(unused_macros)]
-
-#[doc(hidden)]
-pub extern crate core as _core;
-
-mod assert_cfg;
-mod assert_eq_align;
-mod assert_eq_size;
-mod assert_fields;
-mod assert_impl;
-mod assert_obj_safe;
-mod assert_trait;
-mod assert_type;
-mod const_assert;
diff --git a/vendor/syn/.cargo-checksum.json b/vendor/syn/.cargo-checksum.json
deleted file mode 100644
index dee3bccb..00000000
--- a/vendor/syn/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"7fb282af447a34bee9f5fa216d1d99e93abcdfb63f5f0fa255c7b2b895156109","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"417bb33dc685fb0036f91229dd0d828b104a4c35010d362f2a6e5d8b4cf1e36d","benches/file.rs":"b5f458687896253823b642778ee091e42b0d423282e5c177a66d74d429cc39e6","benches/rust.rs":"9c41ecf8cff9ea278befa2f0336dea392c4e85041909ea9eff3402f15b2312c1","build.rs":"241f9e3af93b32d2d928ef9251d8ed2e67c6c64acc4aacce81f3aca58778e655","src/attr.rs":"bab811535308771df407b36c9c9d442c413cfc40cce557e7505c85a2875bf41d","src/await.rs":"8aa22e3c201cb2bdb6b4817fa00901f308ab06817607aa7b884c58c957705969","src/bigint.rs":"efc7f64959980653d73fe4f8bc2a3a2904dc05f45b02c6dc15cd316fa3d7c338","src/buffer.rs":"a5d6692938c2ec6ec140f70ec89fa93659fa227b52e8d381e9da7dd440f0249e","src/custom_keyword.rs":"a834c617b4a0aa87c21275ded72a4e04d7fac2d2255cfc037c0690d21488fc31","src/custom_punctuation.rs":"8a666298e774b0d326642f0f73284f6677d0d0a7c9e4a712c9c98d010b4d8a2c","src/data.rs":"6774795445345360208e2ddc932acd33bbf96e9ac8407e1e4d7e45d44f174ebf","src/derive.rs":"d4205fb2b699e784c0889bcde7e80b77ab222ee74ec3c349b5b1fa63a5f3b0b0","src/discouraged.rs":"6c6a9298f8d24f578da119557bc588f3bd928f7b79fca27d6bdfe3e786dd005f","src/error.rs":"30ed3ab35ba852ac2cfc1f5f388845bf0d0576aa485f045c7da3af0fb24b9f84","src/export.rs":"d18438464c7ee1de7092c7c5d48dd9d114bdf184c1ea452c4fa709265cd19469","src/expr.rs":"29ab61a3ef4f50b7ae5b6c7efe16d3a5ad4bc45b3ff18f8a67f20c1953cd6901","src/ext.rs":"1f648cff1d705a1cea64b32b77482b97a82d2fe0aaf63b40cade91e5c02dc969","src/file.rs":"f86697655222ae294215114f4eae8e6b0b5e2a935d6c479ff8f8f889c4efd2e2","src/gen/clone.rs":"8db60fc2bf515f9a65f4e98669427ce02ed0ccc9ffdad25d8fb39b38768ecaf1","src/gen/debug.rs":"facf4fb5c7e017dd890c4a9531f337659d7b55475aa44124abf48e088ad56fc5","src/gen/eq.rs":"576a4f1e4030434b0f0170f4d681d2c46292fda64ad5f3913623e1c6e858c24f","src/gen/fold.rs":"3f59e59ed8ad2ab5dd347bfbe41bbc785c2aabd8ae902087a584a6daed597182","src/gen/hash.rs":"458052bb0d64b2a722eaeef4461af80bce109cd97d19bd44dbd608e4c53a6520","src/gen/visit.rs":"94f2c6bed4ef1cd0e83d91dddaa95730619fa48fdd4a0be2fd8740e730ff744d","src/gen/visit_mut.rs":"abc8cb67ad3300d0667761daf1e057b80b4d3f3980d94e8d6f3ed68bdcda3776","src/gen_helper.rs":"ea6c66388365971db6a2fc86cbb208f7eacde77e245bc8623f27a3642a3d7741","src/generics.rs":"c8272a8010b378c09eac33e9904299797aee3a879832e6a37a580b518f2a641a","src/group.rs":"d9cd30ea5bd4d453293e8e8debbe388a0360c3c766f67c8499fec453a9a43cdc","src/ident.rs":"d67975d3dd89becde96579c0454a1357aa7c62da11bdf94f29ccf63514ffbc9d","src/item.rs":"4a9e16aafef74f22d5c399735a55af741ec907f587f20845c9ac8c815027f65a","src/lib.rs":"6fc78c9af85f369210fcf7b9cdee7b75e4baf072cb885c8ff03ded0692337ece","src/lifetime.rs":"b18862ef1e690037a4f308ea897debad7bc5038584e3b26c6d8809752ea0e3c2","src/lit.rs":"1cf2700ff9b992bfbe660654abb2af4c816765f901451a359ce450c3dd5f2651","src/lookahead.rs":"92ee63b48de02d3f6f1b09121f0fbac41d55cebc5771c8320e27df8482906152","src/mac.rs":"004cb89f9697564f6c9ee837e08ead68463ef946fb4c13c6c105adf2ba364b2b","src/macros.rs":"266590fd63a4a9d8637c6f8d36702acaace4ba59ab74c0883859efd1e260bae5","src/op.rs":"9d499022902743a6a0a19223b356449a979b90e60552d0446497d72750e646a4","src/parse.rs":"8b4aa518660dfd6310a5455b5624de01ad7ba42d11527b217f811b687b26e1fc","src/parse_macro_input.rs":"88929a1a7e5e72aa2d0b3459e52d8975afea856d159047ba4ab02ecbc5878a9c","src/parse_quote.rs":"80db945403d9731c5f3299a5819a5e2bb726c19fd9f256d50240bc32703c96b1","src/pat.rs":"397b02e0a6f6af8e87c2b3d70cc5b65f5428f9154f09b1006a51b31aaea65038","src/path.rs":"6e890d2d1ceb3d70ede5825d1d74eb98f8c716f444c7eb6ef5026dd610baa202","src/print.rs":"da6529c1d9d21aaf6c835f66b4e67eacb7cf91a10eb5e9a2143b49bf99b3b5e1","src/punctuated.rs":"f389f99adafde96e6d9cc5a00fe95acbaf1ea556191dde2cce98bbd8155aed23","src/reserved.rs":"e70e028bd55cfa43e23cab4ba29e4dc53a3d91eff685ef2b6e57efc2b87a3428","src/sealed.rs":"896a495a5340eec898527f18bd4ddca408ea03ea0ee3af30074ff48deace778d","src/span.rs":"748c51c6feb223c26d3b1701f5bb98aee823666c775c98106cfa24fe29d8cec1","src/spanned.rs":"3ca016a943637653ab98e373dfb826a120f3c159867346fa38a844439944eb39","src/stmt.rs":"e68f76530606aab24e3587aa697fcd862c176e1cca0a50ab883c76bb91464f3d","src/thread.rs":"815eca6bd64f4eef7c447f0809e84108f5428ff50225224b373efd8fbb696874","src/token.rs":"5e423a696f80e281c322f37c87577f9fdc28607e9c007e24896a2b12da62d5ad","src/tt.rs":"32402645b6e82ef1e882945721b59b5fb7b0ee337d1972876362ecacef643d0f","src/ty.rs":"e4f5a4bab6ed7bdd4878e3450a9b36e5c4d9c14de342a99c105e3e93095de86a","src/verbatim.rs":"802a97df997432f18cac6e6200ff6ea29fb2474986005e0fcdbc2b65197f87f7","src/whitespace.rs":"e63dd0aa3d34029f17766a8b09c1a6e4479e36c552c8b7023d710a399333aace","tests/.gitignore":"22e782449a3c216db3f7215d5fb8882e316768e40beeec3833aae419ad8941db","tests/common/eq.rs":"202b65faf5681088ba86bd6dcfe97bf66ab3845b3cece2287e43ef3b513dba36","tests/common/mod.rs":"25ef6d7daa09bad3198a0e9e91b2812425f92db7c585c1e34a03a84d7362ccd8","tests/common/parse.rs":"81580f23583723f7a2a337c4d13ebc021057cd825562fb4e474caa7cc641fed9","tests/debug/gen.rs":"e30e2b6c61feb15abe11cee86c4edff9f7e7c9c79080447d44be97869c9a3adb","tests/debug/mod.rs":"868763d0ef1609a3ad5e05e9f1bfa0f813e91e7e9a36653414a188bb2fdaa425","tests/macros/mod.rs":"a93136b172377ffebe8b68fd596a86d6625f64ed6c3d5e7f5d6ad859e25d5623","tests/repo/mod.rs":"fee2c7aa1547ec84913d49432028e8e32001c1d298c57e2b60ecf52ae39e1a82","tests/repo/progress.rs":"c08d0314a7f3ecf760d471f27da3cd2a500aeb9f1c8331bffb2aa648f9fabf3f","tests/test_asyncness.rs":"cff01db49d28ab23b0b258bc6c0a5cc4071be4fe7248eef344a5d79d2fb649b7","tests/test_attribute.rs":"0ffd99384e1a52ae17d9fed5c4053e411e8f9018decef07ffa621d1faa7329d8","tests/test_derive_input.rs":"610444351e3bf99366976bbf1da109c334a70ac9500caef366bcf9b68819829f","tests/test_expr.rs":"e68b5827415471ccfb7efd91bbfba2f025f1cb8f993c417e7b3c0c3bec6a1fa6","tests/test_generics.rs":"9d713f90a79d6145efc89fb6f946029ca03486c632219950889da39940152ba0","tests/test_grouping.rs":"6276c3c73bba649dec5c97904ad2492879f918bc887a2c425d095c654ca0d925","tests/test_ident.rs":"9eb53d1e21edf23e7c9e14dc74dcc2b2538e9221e19dbcc0a44e3acc2e90f3f6","tests/test_item.rs":"2a8ba326963d758b5a3395bfa07375844f8e043885bb752b69be84a2fe6b4e17","tests/test_iterators.rs":"53ed6078d37550bd6765d2411e3660be401aef8a31a407350cc064a7d08c7c33","tests/test_lit.rs":"ef3f39da6ed67ba73b05eab3dda299887a455bac8e97701a90a94b636681588f","tests/test_meta.rs":"bd6910ec0eba05e814dad27dda0ea65e1f8b483e64d943213066ffd114a82b45","tests/test_parse_buffer.rs":"8bbe2d24ca8a3788f72c6908fc96c26d546f11c69687bf8d72727f851d5e2d27","tests/test_parse_stream.rs":"2f449a2c41a3dee6fd14bee24e1666a453cb808eda17332fd91afd127fcdd2a6","tests/test_pat.rs":"d4465f4fc3fd5d6e534ba8efabe1e0ed6da89de4ac7c96effa6bfb880c4287cf","tests/test_path.rs":"13ae78e958f0d7334d11f32519f593968e5503d46e29ec345feede025f16113d","tests/test_precedence.rs":"6040a565757541f73cac22900d70469dfcd960c5f72e43966ce1383fb46f4c62","tests/test_receiver.rs":"084eca59984b9a18651da52f2c4407355da3de1335916a12477652999e2d01cc","tests/test_round_trip.rs":"b05d8f1fdaa35dd4c1baa76c25ba6e46664643b45ee2ab40b9cf206935e95471","tests/test_shebang.rs":"f5772cadad5b56e3112cb16308b779f92bce1c3a48091fc9933deb2276a69331","tests/test_should_parse.rs":"1d3535698a446e2755bfc360676bdb161841a1f454cdef6e7556c6d06a95c89d","tests/test_size.rs":"5fae772bab66809d6708232f35cfb4a287882486763b0f763feec2ad79fbb68b","tests/test_stmt.rs":"ff6f6f447f46a52fb544353b7dcd2cd9e60781b297dcc86551bee613beaf2280","tests/test_token_trees.rs":"43e56a701817e3c3bfd0cae54a457dd7a38ccb3ca19da41e2b995fdf20e6ed18","tests/test_ty.rs":"c59dfc8952f35befa52cf97af99098b9a042499601c78fa2ea3e169359a3ee5f","tests/test_visibility.rs":"7456fcb3a6634db509748aededff9c2d8b242d511a3e5ee3022e40b232892704","tests/zzz_stable.rs":"2a862e59cb446235ed99aec0e6ada8e16d3ecc30229b29d825b7c0bbc2602989"},"package":"b7f58f7e8eaa0009c5fec437aabf511bd9933e4b2d7407bd05273c01a8906ea7"}
\ No newline at end of file
diff --git a/vendor/syn/Cargo.toml b/vendor/syn/Cargo.toml
deleted file mode 100644
index 134a3439..00000000
--- a/vendor/syn/Cargo.toml
+++ /dev/null
@@ -1,97 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "syn"
-version = "1.0.75"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-include = ["/benches/**", "/build.rs", "/Cargo.toml", "/LICENSE-APACHE", "/LICENSE-MIT", "/README.md", "/src/**", "/tests/**"]
-description = "Parser for Rust source code"
-documentation = "https://docs.rs/syn"
-readme = "README.md"
-categories = ["development-tools::procedural-macro-helpers"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/dtolnay/syn"
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "doc_cfg"]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[package.metadata.playground]
-features = ["full", "visit", "visit-mut", "fold", "extra-traits"]
-
-[[bench]]
-name = "rust"
-harness = false
-required-features = ["full", "parsing"]
-
-[[bench]]
-name = "file"
-required-features = ["full", "parsing"]
-[dependencies.proc-macro2]
-version = "1.0.26"
-default-features = false
-
-[dependencies.quote]
-version = "1.0"
-optional = true
-default-features = false
-
-[dependencies.unicode-xid]
-version = "0.2"
-[dev-dependencies.anyhow]
-version = "1.0"
-
-[dev-dependencies.flate2]
-version = "1.0"
-
-[dev-dependencies.insta]
-version = "1.0"
-
-[dev-dependencies.rayon]
-version = "1.0"
-
-[dev-dependencies.ref-cast]
-version = "1.0"
-
-[dev-dependencies.regex]
-version = "1.0"
-
-[dev-dependencies.reqwest]
-version = "0.10"
-features = ["blocking"]
-
-[dev-dependencies.syn-test-suite]
-version = "0"
-
-[dev-dependencies.tar]
-version = "0.4.16"
-
-[dev-dependencies.termcolor]
-version = "1.0"
-
-[dev-dependencies.walkdir]
-version = "2.1"
-
-[features]
-clone-impls = []
-default = ["derive", "parsing", "printing", "clone-impls", "proc-macro"]
-derive = []
-extra-traits = []
-fold = []
-full = []
-parsing = []
-printing = ["quote"]
-proc-macro = ["proc-macro2/proc-macro", "quote/proc-macro"]
-test = ["syn-test-suite/all-features"]
-visit = []
-visit-mut = []
diff --git a/vendor/syn/LICENSE-APACHE b/vendor/syn/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/syn/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/syn/LICENSE-MIT b/vendor/syn/LICENSE-MIT
deleted file mode 100644
index 31aa7938..00000000
--- a/vendor/syn/LICENSE-MIT
+++ /dev/null
@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/syn/README.md b/vendor/syn/README.md
deleted file mode 100644
index 38005f5e..00000000
--- a/vendor/syn/README.md
+++ /dev/null
@@ -1,285 +0,0 @@
-Parser for Rust source code
-===========================
-
-[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/syn-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/syn)
-[<img alt="crates.io" src="https://img.shields.io/crates/v/syn.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/syn)
-[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-syn-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K" height="20">](https://docs.rs/syn)
-[<img alt="build status" src="https://img.shields.io/github/workflow/status/dtolnay/syn/CI/master?style=for-the-badge" height="20">](https://github.com/dtolnay/syn/actions?query=branch%3Amaster)
-
-Syn is a parsing library for parsing a stream of Rust tokens into a syntax tree
-of Rust source code.
-
-Currently this library is geared toward use in Rust procedural macros, but
-contains some APIs that may be useful more generally.
-
-- **Data structures** — Syn provides a complete syntax tree that can represent
-  any valid Rust source code. The syntax tree is rooted at [`syn::File`] which
-  represents a full source file, but there are other entry points that may be
-  useful to procedural macros including [`syn::Item`], [`syn::Expr`] and
-  [`syn::Type`].
-
-- **Derives** — Of particular interest to derive macros is [`syn::DeriveInput`]
-  which is any of the three legal input items to a derive macro. An example
-  below shows using this type in a library that can derive implementations of a
-  user-defined trait.
-
-- **Parsing** — Parsing in Syn is built around [parser functions] with the
-  signature `fn(ParseStream) -> Result<T>`. Every syntax tree node defined by
-  Syn is individually parsable and may be used as a building block for custom
-  syntaxes, or you may dream up your own brand new syntax without involving any
-  of our syntax tree types.
-
-- **Location information** — Every token parsed by Syn is associated with a
-  `Span` that tracks line and column information back to the source of that
-  token. These spans allow a procedural macro to display detailed error messages
-  pointing to all the right places in the user's code. There is an example of
-  this below.
-
-- **Feature flags** — Functionality is aggressively feature gated so your
-  procedural macros enable only what they need, and do not pay in compile time
-  for all the rest.
-
-[`syn::File`]: https://docs.rs/syn/1.0/syn/struct.File.html
-[`syn::Item`]: https://docs.rs/syn/1.0/syn/enum.Item.html
-[`syn::Expr`]: https://docs.rs/syn/1.0/syn/enum.Expr.html
-[`syn::Type`]: https://docs.rs/syn/1.0/syn/enum.Type.html
-[`syn::DeriveInput`]: https://docs.rs/syn/1.0/syn/struct.DeriveInput.html
-[parser functions]: https://docs.rs/syn/1.0/syn/parse/index.html
-
-*Version requirement: Syn supports rustc 1.31 and up.*
-
-[*Release notes*](https://github.com/dtolnay/syn/releases)
-
-<br>
-
-## Resources
-
-The best way to learn about procedural macros is by writing some. Consider
-working through [this procedural macro workshop][workshop] to get familiar with
-the different types of procedural macros. The workshop contains relevant links
-into the Syn documentation as you work through each project.
-
-[workshop]: https://github.com/dtolnay/proc-macro-workshop
-
-<br>
-
-## Example of a derive macro
-
-The canonical derive macro using Syn looks like this. We write an ordinary Rust
-function tagged with a `proc_macro_derive` attribute and the name of the trait
-we are deriving. Any time that derive appears in the user's code, the Rust
-compiler passes their data structure as tokens into our macro. We get to execute
-arbitrary Rust code to figure out what to do with those tokens, then hand some
-tokens back to the compiler to compile into the user's crate.
-
-[`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
-
-```toml
-[dependencies]
-syn = "1.0"
-quote = "1.0"
-
-[lib]
-proc-macro = true
-```
-
-```rust
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
-
-#[proc_macro_derive(MyMacro)]
-pub fn my_macro(input: TokenStream) -> TokenStream {
-    // Parse the input tokens into a syntax tree
-    let input = parse_macro_input!(input as DeriveInput);
-
-    // Build the output, possibly using quasi-quotation
-    let expanded = quote! {
-        // ...
-    };
-
-    // Hand the output tokens back to the compiler
-    TokenStream::from(expanded)
-}
-```
-
-The [`heapsize`] example directory shows a complete working implementation of a
-derive macro. It works on any Rust compiler 1.31+. The example derives a
-`HeapSize` trait which computes an estimate of the amount of heap memory owned
-by a value.
-
-[`heapsize`]: examples/heapsize
-
-```rust
-pub trait HeapSize {
-    /// Total number of bytes of heap memory owned by `self`.
-    fn heap_size_of_children(&self) -> usize;
-}
-```
-
-The derive macro allows users to write `#[derive(HeapSize)]` on data structures
-in their program.
-
-```rust
-#[derive(HeapSize)]
-struct Demo<'a, T: ?Sized> {
-    a: Box<T>,
-    b: u8,
-    c: &'a str,
-    d: String,
-}
-```
-
-<br>
-
-## Spans and error reporting
-
-The token-based procedural macro API provides great control over where the
-compiler's error messages are displayed in user code. Consider the error the
-user sees if one of their field types does not implement `HeapSize`.
-
-```rust
-#[derive(HeapSize)]
-struct Broken {
-    ok: String,
-    bad: std::thread::Thread,
-}
-```
-
-By tracking span information all the way through the expansion of a procedural
-macro as shown in the `heapsize` example, token-based macros in Syn are able to
-trigger errors that directly pinpoint the source of the problem.
-
-```console
-error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied
- --> src/main.rs:7:5
-  |
-7 |     bad: std::thread::Thread,
-  |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `std::thread::Thread`
-```
-
-<br>
-
-## Parsing a custom syntax
-
-The [`lazy-static`] example directory shows the implementation of a
-`functionlike!(...)` procedural macro in which the input tokens are parsed using
-Syn's parsing API.
-
-[`lazy-static`]: examples/lazy-static
-
-The example reimplements the popular `lazy_static` crate from crates.io as a
-procedural macro.
-
-```rust
-lazy_static! {
-    static ref USERNAME: Regex = Regex::new("^[a-z0-9_-]{3,16}$").unwrap();
-}
-```
-
-The implementation shows how to trigger custom warnings and error messages on
-the macro input.
-
-```console
-warning: come on, pick a more creative name
-  --> src/main.rs:10:16
-   |
-10 |     static ref FOO: String = "lazy_static".to_owned();
-   |                ^^^
-```
-
-<br>
-
-## Testing
-
-When testing macros, we often care not just that the macro can be used
-successfully but also that when the macro is provided with invalid input it
-produces maximally helpful error messages. Consider using the [`trybuild`] crate
-to write tests for errors that are emitted by your macro or errors detected by
-the Rust compiler in the expanded code following misuse of the macro. Such tests
-help avoid regressions from later refactors that mistakenly make an error no
-longer trigger or be less helpful than it used to be.
-
-[`trybuild`]: https://github.com/dtolnay/trybuild
-
-<br>
-
-## Debugging
-
-When developing a procedural macro it can be helpful to look at what the
-generated code looks like. Use `cargo rustc -- -Zunstable-options
---pretty=expanded` or the [`cargo expand`] subcommand.
-
-[`cargo expand`]: https://github.com/dtolnay/cargo-expand
-
-To show the expanded code for some crate that uses your procedural macro, run
-`cargo expand` from that crate. To show the expanded code for one of your own
-test cases, run `cargo expand --test the_test_case` where the last argument is
-the name of the test file without the `.rs` extension.
-
-This write-up by Brandon W Maister discusses debugging in more detail:
-[Debugging Rust's new Custom Derive system][debugging].
-
-[debugging]: https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/
-
-<br>
-
-## Optional features
-
-Syn puts a lot of functionality behind optional features in order to optimize
-compile time for the most common use cases. The following features are
-available.
-
-- **`derive`** *(enabled by default)* — Data structures for representing the
-  possible input to a derive macro, including structs and enums and types.
-- **`full`** — Data structures for representing the syntax tree of all valid
-  Rust source code, including items and expressions.
-- **`parsing`** *(enabled by default)* — Ability to parse input tokens into a
-  syntax tree node of a chosen type.
-- **`printing`** *(enabled by default)* — Ability to print a syntax tree node as
-  tokens of Rust source code.
-- **`visit`** — Trait for traversing a syntax tree.
-- **`visit-mut`** — Trait for traversing and mutating in place a syntax tree.
-- **`fold`** — Trait for transforming an owned syntax tree.
-- **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree
-  types.
-- **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree
-  types.
-- **`proc-macro`** *(enabled by default)* — Runtime dependency on the dynamic
-  library libproc_macro from rustc toolchain.
-
-<br>
-
-## Proc macro shim
-
-Syn operates on the token representation provided by the [proc-macro2] crate
-from crates.io rather than using the compiler's built in proc-macro crate
-directly. This enables code using Syn to execute outside of the context of a
-procedural macro, such as in unit tests or build.rs, and we avoid needing
-incompatible ecosystems for proc macros vs non-macro use cases.
-
-In general all of your code should be written against proc-macro2 rather than
-proc-macro. The one exception is in the signatures of procedural macro entry
-points, which are required by the language to use `proc_macro::TokenStream`.
-
-The proc-macro2 crate will automatically detect and use the compiler's data
-structures when a procedural macro is active.
-
-[proc-macro2]: https://docs.rs/proc-macro2/1.0/proc_macro2/
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/syn/benches/file.rs b/vendor/syn/benches/file.rs
deleted file mode 100644
index 33d201c1..00000000
--- a/vendor/syn/benches/file.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// $ cargo bench --features full --bench file
-
-#![feature(rustc_private, test)]
-#![recursion_limit = "1024"]
-
-extern crate test;
-
-#[macro_use]
-#[path = "../tests/macros/mod.rs"]
-mod macros;
-
-#[path = "../tests/common/mod.rs"]
-mod common;
-#[path = "../tests/repo/mod.rs"]
-pub mod repo;
-
-use proc_macro2::TokenStream;
-use std::fs;
-use std::str::FromStr;
-use test::Bencher;
-
-const FILE: &str = "tests/rust/library/core/src/str/mod.rs";
-
-#[bench]
-fn parse_file(b: &mut Bencher) {
-    repo::clone_rust();
-    let content = fs::read_to_string(FILE).unwrap();
-    let tokens = TokenStream::from_str(&content).unwrap();
-    b.iter(|| syn::parse2::<syn::File>(tokens.clone()));
-}
diff --git a/vendor/syn/benches/rust.rs b/vendor/syn/benches/rust.rs
deleted file mode 100644
index 28dff947..00000000
--- a/vendor/syn/benches/rust.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-// $ cargo bench --features full --bench rust
-//
-// Syn only, useful for profiling:
-// $ RUSTFLAGS='--cfg syn_only' cargo build --release --features full --bench rust
-
-#![cfg_attr(not(syn_only), feature(rustc_private))]
-#![recursion_limit = "1024"]
-
-#[macro_use]
-#[path = "../tests/macros/mod.rs"]
-mod macros;
-
-#[path = "../tests/common/mod.rs"]
-mod common;
-#[path = "../tests/repo/mod.rs"]
-mod repo;
-
-use std::fs;
-use std::time::{Duration, Instant};
-
-#[cfg(not(syn_only))]
-mod tokenstream_parse {
-    use proc_macro2::TokenStream;
-    use std::str::FromStr;
-
-    pub fn bench(content: &str) -> Result<(), ()> {
-        TokenStream::from_str(content).map(drop).map_err(drop)
-    }
-}
-
-mod syn_parse {
-    pub fn bench(content: &str) -> Result<(), ()> {
-        syn::parse_file(content).map(drop).map_err(drop)
-    }
-}
-
-#[cfg(not(syn_only))]
-mod librustc_parse {
-    extern crate rustc_data_structures;
-    extern crate rustc_errors;
-    extern crate rustc_parse;
-    extern crate rustc_session;
-    extern crate rustc_span;
-
-    use rustc_data_structures::sync::Lrc;
-    use rustc_errors::{emitter::Emitter, Diagnostic, Handler};
-    use rustc_session::parse::ParseSess;
-    use rustc_span::source_map::{FilePathMapping, SourceMap};
-    use rustc_span::{edition::Edition, FileName};
-
-    pub fn bench(content: &str) -> Result<(), ()> {
-        struct SilentEmitter;
-
-        impl Emitter for SilentEmitter {
-            fn emit_diagnostic(&mut self, _diag: &Diagnostic) {}
-            fn source_map(&self) -> Option<&Lrc<SourceMap>> {
-                None
-            }
-        }
-
-        rustc_span::create_session_if_not_set_then(Edition::Edition2018, |_| {
-            let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-            let emitter = Box::new(SilentEmitter);
-            let handler = Handler::with_emitter(false, None, emitter);
-            let sess = ParseSess::with_span_handler(handler, cm);
-            if let Err(mut diagnostic) = rustc_parse::parse_crate_from_source_str(
-                FileName::Custom("bench".to_owned()),
-                content.to_owned(),
-                &sess,
-            ) {
-                diagnostic.cancel();
-                return Err(());
-            };
-            Ok(())
-        })
-    }
-}
-
-#[cfg(not(syn_only))]
-mod read_from_disk {
-    pub fn bench(content: &str) -> Result<(), ()> {
-        let _ = content;
-        Ok(())
-    }
-}
-
-fn exec(mut codepath: impl FnMut(&str) -> Result<(), ()>) -> Duration {
-    let begin = Instant::now();
-    let mut success = 0;
-    let mut total = 0;
-
-    walkdir::WalkDir::new("tests/rust/src")
-        .into_iter()
-        .filter_entry(repo::base_dir_filter)
-        .for_each(|entry| {
-            let entry = entry.unwrap();
-            let path = entry.path();
-            if path.is_dir() {
-                return;
-            }
-            let content = fs::read_to_string(path).unwrap();
-            let ok = codepath(&content).is_ok();
-            success += ok as usize;
-            total += 1;
-            if !ok {
-                eprintln!("FAIL {}", path.display());
-            }
-        });
-
-    assert_eq!(success, total);
-    begin.elapsed()
-}
-
-fn main() {
-    repo::clone_rust();
-
-    macro_rules! testcases {
-        ($($(#[$cfg:meta])* $name:ident,)*) => {
-            vec![
-                $(
-                    $(#[$cfg])*
-                    (stringify!($name), $name::bench as fn(&str) -> Result<(), ()>),
-                )*
-            ]
-        };
-    }
-
-    #[cfg(not(syn_only))]
-    {
-        let mut lines = 0;
-        let mut files = 0;
-        exec(|content| {
-            lines += content.lines().count();
-            files += 1;
-            Ok(())
-        });
-        eprintln!("\n{} lines in {} files", lines, files);
-    }
-
-    for (name, f) in testcases!(
-        #[cfg(not(syn_only))]
-        read_from_disk,
-        #[cfg(not(syn_only))]
-        tokenstream_parse,
-        syn_parse,
-        #[cfg(not(syn_only))]
-        librustc_parse,
-    ) {
-        eprint!("{:20}", format!("{}:", name));
-        let elapsed = exec(f);
-        eprintln!(
-            "elapsed={}.{:03}s",
-            elapsed.as_secs(),
-            elapsed.subsec_millis(),
-        );
-    }
-    eprintln!();
-}
diff --git a/vendor/syn/build.rs b/vendor/syn/build.rs
deleted file mode 100644
index 25190f4c..00000000
--- a/vendor/syn/build.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use std::env;
-use std::process::Command;
-use std::str;
-
-// The rustc-cfg strings below are *not* public API. Please let us know by
-// opening a GitHub issue if your build environment requires some way to enable
-// these cfgs other than by executing our build script.
-fn main() {
-    let compiler = match rustc_version() {
-        Some(compiler) => compiler,
-        None => return,
-    };
-
-    if compiler.minor < 36 {
-        println!("cargo:rustc-cfg=syn_omit_await_from_token_macro");
-    }
-
-    if compiler.minor < 39 {
-        println!("cargo:rustc-cfg=syn_no_const_vec_new");
-    }
-
-    if !compiler.nightly {
-        println!("cargo:rustc-cfg=syn_disable_nightly_tests");
-    }
-}
-
-struct Compiler {
-    minor: u32,
-    nightly: bool,
-}
-
-fn rustc_version() -> Option<Compiler> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    let minor = pieces.next()?.parse().ok()?;
-    let nightly = version.contains("nightly");
-    Some(Compiler { minor, nightly })
-}
diff --git a/vendor/syn/src/attr.rs b/vendor/syn/src/attr.rs
deleted file mode 100644
index 5d6877ae..00000000
--- a/vendor/syn/src/attr.rs
+++ /dev/null
@@ -1,664 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-use proc_macro2::TokenStream;
-use std::iter;
-
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, ParseBuffer, ParseStream, Parser, Result};
-#[cfg(feature = "parsing")]
-use crate::punctuated::Pair;
-
-ast_struct! {
-    /// An attribute like `#[repr(transparent)]`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// <br>
-    ///
-    /// # Syntax
-    ///
-    /// Rust has six types of attributes.
-    ///
-    /// - Outer attributes like `#[repr(transparent)]`. These appear outside or
-    ///   in front of the item they describe.
-    /// - Inner attributes like `#![feature(proc_macro)]`. These appear inside
-    ///   of the item they describe, usually a module.
-    /// - Outer doc comments like `/// # Example`.
-    /// - Inner doc comments like `//! Please file an issue`.
-    /// - Outer block comments `/** # Example */`.
-    /// - Inner block comments `/*! Please file an issue */`.
-    ///
-    /// The `style` field of type `AttrStyle` distinguishes whether an attribute
-    /// is outer or inner. Doc comments and block comments are promoted to
-    /// attributes, as this is how they are processed by the compiler and by
-    /// `macro_rules!` macros.
-    ///
-    /// The `path` field gives the possibly colon-delimited path against which
-    /// the attribute is resolved. It is equal to `"doc"` for desugared doc
-    /// comments. The `tokens` field contains the rest of the attribute body as
-    /// tokens.
-    ///
-    /// ```text
-    /// #[derive(Copy)]      #[crate::precondition x < 5]
-    ///   ^^^^^^~~~~~~         ^^^^^^^^^^^^^^^^^^^ ~~~~~
-    ///   path  tokens                 path        tokens
-    /// ```
-    ///
-    /// <br>
-    ///
-    /// # Parsing from tokens to Attribute
-    ///
-    /// This type does not implement the [`Parse`] trait and thus cannot be
-    /// parsed directly by [`ParseStream::parse`]. Instead use
-    /// [`ParseStream::call`] with one of the two parser functions
-    /// [`Attribute::parse_outer`] or [`Attribute::parse_inner`] depending on
-    /// which you intend to parse.
-    ///
-    /// [`Parse`]: parse::Parse
-    /// [`ParseStream::parse`]: parse::ParseBuffer::parse
-    /// [`ParseStream::call`]: parse::ParseBuffer::call
-    ///
-    /// ```
-    /// use syn::{Attribute, Ident, Result, Token};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // Parses a unit struct with attributes.
-    /// //
-    /// //     #[path = "s.tmpl"]
-    /// //     struct S;
-    /// struct UnitStruct {
-    ///     attrs: Vec<Attribute>,
-    ///     struct_token: Token![struct],
-    ///     name: Ident,
-    ///     semi_token: Token![;],
-    /// }
-    ///
-    /// impl Parse for UnitStruct {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         Ok(UnitStruct {
-    ///             attrs: input.call(Attribute::parse_outer)?,
-    ///             struct_token: input.parse()?,
-    ///             name: input.parse()?,
-    ///             semi_token: input.parse()?,
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// <p><br></p>
-    ///
-    /// # Parsing from Attribute to structured arguments
-    ///
-    /// The grammar of attributes in Rust is very flexible, which makes the
-    /// syntax tree not that useful on its own. In particular, arguments of the
-    /// attribute are held in an arbitrary `tokens: TokenStream`. Macros are
-    /// expected to check the `path` of the attribute, decide whether they
-    /// recognize it, and then parse the remaining tokens according to whatever
-    /// grammar they wish to require for that kind of attribute.
-    ///
-    /// If the attribute you are parsing is expected to conform to the
-    /// conventional structured form of attribute, use [`parse_meta()`] to
-    /// obtain that structured representation. If the attribute follows some
-    /// other grammar of its own, use [`parse_args()`] to parse that into the
-    /// expected data structure.
-    ///
-    /// [`parse_meta()`]: Attribute::parse_meta
-    /// [`parse_args()`]: Attribute::parse_args
-    ///
-    /// <p><br></p>
-    ///
-    /// # Doc comments
-    ///
-    /// The compiler transforms doc comments, such as `/// comment` and `/*!
-    /// comment */`, into attributes before macros are expanded. Each comment is
-    /// expanded into an attribute of the form `#[doc = r"comment"]`.
-    ///
-    /// As an example, the following `mod` items are expanded identically:
-    ///
-    /// ```
-    /// # use syn::{ItemMod, parse_quote};
-    /// let doc: ItemMod = parse_quote! {
-    ///     /// Single line doc comments
-    ///     /// We write so many!
-    ///     /**
-    ///      * Multi-line comments...
-    ///      * May span many lines
-    ///      */
-    ///     mod example {
-    ///         //! Of course, they can be inner too
-    ///         /*! And fit in a single line */
-    ///     }
-    /// };
-    /// let attr: ItemMod = parse_quote! {
-    ///     #[doc = r" Single line doc comments"]
-    ///     #[doc = r" We write so many!"]
-    ///     #[doc = r"
-    ///      * Multi-line comments...
-    ///      * May span many lines
-    ///      "]
-    ///     mod example {
-    ///         #![doc = r" Of course, they can be inner too"]
-    ///         #![doc = r" And fit in a single line "]
-    ///     }
-    /// };
-    /// assert_eq!(doc, attr);
-    /// ```
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Attribute {
-        pub pound_token: Token![#],
-        pub style: AttrStyle,
-        pub bracket_token: token::Bracket,
-        pub path: Path,
-        pub tokens: TokenStream,
-    }
-}
-
-impl Attribute {
-    /// Parses the content of the attribute, consisting of the path and tokens,
-    /// as a [`Meta`] if possible.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_meta(&self) -> Result<Meta> {
-        fn clone_ident_segment(segment: &PathSegment) -> PathSegment {
-            PathSegment {
-                ident: segment.ident.clone(),
-                arguments: PathArguments::None,
-            }
-        }
-
-        let path = Path {
-            leading_colon: self
-                .path
-                .leading_colon
-                .as_ref()
-                .map(|colon| Token![::](colon.spans)),
-            segments: self
-                .path
-                .segments
-                .pairs()
-                .map(|pair| match pair {
-                    Pair::Punctuated(seg, punct) => {
-                        Pair::Punctuated(clone_ident_segment(seg), Token![::](punct.spans))
-                    }
-                    Pair::End(seg) => Pair::End(clone_ident_segment(seg)),
-                })
-                .collect(),
-        };
-
-        let parser = |input: ParseStream| parsing::parse_meta_after_path(path, input);
-        parse::Parser::parse2(parser, self.tokens.clone())
-    }
-
-    /// Parse the arguments to the attribute as a syntax tree.
-    ///
-    /// This is similar to `syn::parse2::<T>(attr.tokens)` except that:
-    ///
-    /// - the surrounding delimiters are *not* included in the input to the
-    ///   parser; and
-    /// - the error message has a more useful span when `tokens` is empty.
-    ///
-    /// ```text
-    /// #[my_attr(value < 5)]
-    ///           ^^^^^^^^^ what gets parsed
-    /// ```
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_args<T: Parse>(&self) -> Result<T> {
-        self.parse_args_with(T::parse)
-    }
-
-    /// Parse the arguments to the attribute using the given parser.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_args_with<F: Parser>(&self, parser: F) -> Result<F::Output> {
-        let parser = |input: ParseStream| {
-            let args = enter_args(self, input)?;
-            parse::parse_stream(parser, &args)
-        };
-        parser.parse2(self.tokens.clone())
-    }
-
-    /// Parses zero or more outer attributes from the stream.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_outer(input: ParseStream) -> Result<Vec<Self>> {
-        let mut attrs = Vec::new();
-        while input.peek(Token![#]) {
-            attrs.push(input.call(parsing::single_parse_outer)?);
-        }
-        Ok(attrs)
-    }
-
-    /// Parses zero or more inner attributes from the stream.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_inner(input: ParseStream) -> Result<Vec<Self>> {
-        let mut attrs = Vec::new();
-        parsing::parse_inner(input, &mut attrs)?;
-        Ok(attrs)
-    }
-}
-
-#[cfg(feature = "parsing")]
-fn expected_parentheses(attr: &Attribute) -> String {
-    let style = match attr.style {
-        AttrStyle::Outer => "#",
-        AttrStyle::Inner(_) => "#!",
-    };
-
-    let mut path = String::new();
-    for segment in &attr.path.segments {
-        if !path.is_empty() || attr.path.leading_colon.is_some() {
-            path += "::";
-        }
-        path += &segment.ident.to_string();
-    }
-
-    format!("{}[{}(...)]", style, path)
-}
-
-#[cfg(feature = "parsing")]
-fn enter_args<'a>(attr: &Attribute, input: ParseStream<'a>) -> Result<ParseBuffer<'a>> {
-    if input.is_empty() {
-        let expected = expected_parentheses(attr);
-        let msg = format!("expected attribute arguments in parentheses: {}", expected);
-        return Err(crate::error::new2(
-            attr.pound_token.span,
-            attr.bracket_token.span,
-            msg,
-        ));
-    } else if input.peek(Token![=]) {
-        let expected = expected_parentheses(attr);
-        let msg = format!("expected parentheses: {}", expected);
-        return Err(input.error(msg));
-    };
-
-    let content;
-    if input.peek(token::Paren) {
-        parenthesized!(content in input);
-    } else if input.peek(token::Bracket) {
-        bracketed!(content in input);
-    } else if input.peek(token::Brace) {
-        braced!(content in input);
-    } else {
-        return Err(input.error("unexpected token in attribute arguments"));
-    }
-
-    if input.is_empty() {
-        Ok(content)
-    } else {
-        Err(input.error("unexpected token in attribute arguments"))
-    }
-}
-
-ast_enum! {
-    /// Distinguishes between attributes that decorate an item and attributes
-    /// that are contained within an item.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Outer attributes
-    ///
-    /// - `#[repr(transparent)]`
-    /// - `/// # Example`
-    /// - `/** Please file an issue */`
-    ///
-    /// # Inner attributes
-    ///
-    /// - `#![feature(proc_macro)]`
-    /// - `//! # Example`
-    /// - `/*! Please file an issue */`
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum AttrStyle {
-        Outer,
-        Inner(Token![!]),
-    }
-}
-
-ast_enum_of_structs! {
-    /// Content of a compile-time structured attribute.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// ## Path
-    ///
-    /// A meta path is like the `test` in `#[test]`.
-    ///
-    /// ## List
-    ///
-    /// A meta list is like the `derive(Copy)` in `#[derive(Copy)]`.
-    ///
-    /// ## NameValue
-    ///
-    /// A name-value meta is like the `path = "..."` in `#[path =
-    /// "sys/windows.rs"]`.
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Meta {
-        Path(Path),
-
-        /// A structured list within an attribute, like `derive(Copy, Clone)`.
-        List(MetaList),
-
-        /// A name-value pair within an attribute, like `feature = "nightly"`.
-        NameValue(MetaNameValue),
-    }
-}
-
-ast_struct! {
-    /// A structured list within an attribute, like `derive(Copy, Clone)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct MetaList {
-        pub path: Path,
-        pub paren_token: token::Paren,
-        pub nested: Punctuated<NestedMeta, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A name-value pair within an attribute, like `feature = "nightly"`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct MetaNameValue {
-        pub path: Path,
-        pub eq_token: Token![=],
-        pub lit: Lit,
-    }
-}
-
-impl Meta {
-    /// Returns the identifier that begins this structured meta item.
-    ///
-    /// For example this would return the `test` in `#[test]`, the `derive` in
-    /// `#[derive(Copy)]`, and the `path` in `#[path = "sys/windows.rs"]`.
-    pub fn path(&self) -> &Path {
-        match self {
-            Meta::Path(path) => path,
-            Meta::List(meta) => &meta.path,
-            Meta::NameValue(meta) => &meta.path,
-        }
-    }
-}
-
-ast_enum_of_structs! {
-    /// Element of a compile-time attribute list.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum NestedMeta {
-        /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which
-        /// would be a nested `Meta::Path`.
-        Meta(Meta),
-
-        /// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`.
-        Lit(Lit),
-    }
-}
-
-/// Conventional argument type associated with an invocation of an attribute
-/// macro.
-///
-/// For example if we are developing an attribute macro that is intended to be
-/// invoked on function items as follows:
-///
-/// ```
-/// # const IGNORE: &str = stringify! {
-/// #[my_attribute(path = "/v1/refresh")]
-/// # };
-/// pub fn refresh() {
-///     /* ... */
-/// }
-/// ```
-///
-/// The implementation of this macro would want to parse its attribute arguments
-/// as type `AttributeArgs`.
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// use proc_macro::TokenStream;
-/// use syn::{parse_macro_input, AttributeArgs, ItemFn};
-///
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro_attribute]
-/// # };
-/// pub fn my_attribute(args: TokenStream, input: TokenStream) -> TokenStream {
-///     let args = parse_macro_input!(args as AttributeArgs);
-///     let input = parse_macro_input!(input as ItemFn);
-///
-///     /* ... */
-/// #   "".parse().unwrap()
-/// }
-/// ```
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-pub type AttributeArgs = Vec<NestedMeta>;
-
-pub trait FilterAttrs<'a> {
-    type Ret: Iterator<Item = &'a Attribute>;
-
-    fn outer(self) -> Self::Ret;
-    fn inner(self) -> Self::Ret;
-}
-
-impl<'a, T> FilterAttrs<'a> for T
-where
-    T: IntoIterator<Item = &'a Attribute>,
-{
-    type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>;
-
-    fn outer(self) -> Self::Ret {
-        fn is_outer(attr: &&Attribute) -> bool {
-            match attr.style {
-                AttrStyle::Outer => true,
-                AttrStyle::Inner(_) => false,
-            }
-        }
-        self.into_iter().filter(is_outer)
-    }
-
-    fn inner(self) -> Self::Ret {
-        fn is_inner(attr: &&Attribute) -> bool {
-            match attr.style {
-                AttrStyle::Inner(_) => true,
-                AttrStyle::Outer => false,
-            }
-        }
-        self.into_iter().filter(is_inner)
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    pub fn parse_inner(input: ParseStream, attrs: &mut Vec<Attribute>) -> Result<()> {
-        while input.peek(Token![#]) && input.peek2(Token![!]) {
-            attrs.push(input.call(parsing::single_parse_inner)?);
-        }
-        Ok(())
-    }
-
-    pub fn single_parse_inner(input: ParseStream) -> Result<Attribute> {
-        let content;
-        Ok(Attribute {
-            pound_token: input.parse()?,
-            style: AttrStyle::Inner(input.parse()?),
-            bracket_token: bracketed!(content in input),
-            path: content.call(Path::parse_mod_style)?,
-            tokens: content.parse()?,
-        })
-    }
-
-    pub fn single_parse_outer(input: ParseStream) -> Result<Attribute> {
-        let content;
-        Ok(Attribute {
-            pound_token: input.parse()?,
-            style: AttrStyle::Outer,
-            bracket_token: bracketed!(content in input),
-            path: content.call(Path::parse_mod_style)?,
-            tokens: content.parse()?,
-        })
-    }
-
-    // Like Path::parse_mod_style but accepts keywords in the path.
-    fn parse_meta_path(input: ParseStream) -> Result<Path> {
-        Ok(Path {
-            leading_colon: input.parse()?,
-            segments: {
-                let mut segments = Punctuated::new();
-                while input.peek(Ident::peek_any) {
-                    let ident = Ident::parse_any(input)?;
-                    segments.push_value(PathSegment::from(ident));
-                    if !input.peek(Token![::]) {
-                        break;
-                    }
-                    let punct = input.parse()?;
-                    segments.push_punct(punct);
-                }
-                if segments.is_empty() {
-                    return Err(input.error("expected path"));
-                } else if segments.trailing_punct() {
-                    return Err(input.error("expected path segment"));
-                }
-                segments
-            },
-        })
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Meta {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let path = input.call(parse_meta_path)?;
-            parse_meta_after_path(path, input)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for MetaList {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let path = input.call(parse_meta_path)?;
-            parse_meta_list_after_path(path, input)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for MetaNameValue {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let path = input.call(parse_meta_path)?;
-            parse_meta_name_value_after_path(path, input)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for NestedMeta {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Lit) && !(input.peek(LitBool) && input.peek2(Token![=])) {
-                input.parse().map(NestedMeta::Lit)
-            } else if input.peek(Ident::peek_any)
-                || input.peek(Token![::]) && input.peek3(Ident::peek_any)
-            {
-                input.parse().map(NestedMeta::Meta)
-            } else {
-                Err(input.error("expected identifier or literal"))
-            }
-        }
-    }
-
-    pub fn parse_meta_after_path(path: Path, input: ParseStream) -> Result<Meta> {
-        if input.peek(token::Paren) {
-            parse_meta_list_after_path(path, input).map(Meta::List)
-        } else if input.peek(Token![=]) {
-            parse_meta_name_value_after_path(path, input).map(Meta::NameValue)
-        } else {
-            Ok(Meta::Path(path))
-        }
-    }
-
-    fn parse_meta_list_after_path(path: Path, input: ParseStream) -> Result<MetaList> {
-        let content;
-        Ok(MetaList {
-            path,
-            paren_token: parenthesized!(content in input),
-            nested: content.parse_terminated(NestedMeta::parse)?,
-        })
-    }
-
-    fn parse_meta_name_value_after_path(path: Path, input: ParseStream) -> Result<MetaNameValue> {
-        Ok(MetaNameValue {
-            path,
-            eq_token: input.parse()?,
-            lit: input.parse()?,
-        })
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::ToTokens;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Attribute {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.pound_token.to_tokens(tokens);
-            if let AttrStyle::Inner(b) = &self.style {
-                b.to_tokens(tokens);
-            }
-            self.bracket_token.surround(tokens, |tokens| {
-                self.path.to_tokens(tokens);
-                self.tokens.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for MetaList {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.path.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.nested.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for MetaNameValue {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.path.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.lit.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/await.rs b/vendor/syn/src/await.rs
deleted file mode 100644
index 038c6a5d..00000000
--- a/vendor/syn/src/await.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-// See include!("await.rs") in token.rs.
-export_token_macro! {[await]}
diff --git a/vendor/syn/src/bigint.rs b/vendor/syn/src/bigint.rs
deleted file mode 100644
index 5397d6be..00000000
--- a/vendor/syn/src/bigint.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use std::ops::{AddAssign, MulAssign};
-
-// For implementing base10_digits() accessor on LitInt.
-pub struct BigInt {
-    digits: Vec<u8>,
-}
-
-impl BigInt {
-    pub fn new() -> Self {
-        BigInt { digits: Vec::new() }
-    }
-
-    pub fn to_string(&self) -> String {
-        let mut repr = String::with_capacity(self.digits.len());
-
-        let mut has_nonzero = false;
-        for digit in self.digits.iter().rev() {
-            has_nonzero |= *digit != 0;
-            if has_nonzero {
-                repr.push((*digit + b'0') as char);
-            }
-        }
-
-        if repr.is_empty() {
-            repr.push('0');
-        }
-
-        repr
-    }
-
-    fn reserve_two_digits(&mut self) {
-        let len = self.digits.len();
-        let desired =
-            len + !self.digits.ends_with(&[0, 0]) as usize + !self.digits.ends_with(&[0]) as usize;
-        self.digits.resize(desired, 0);
-    }
-}
-
-impl AddAssign<u8> for BigInt {
-    // Assumes increment <16.
-    fn add_assign(&mut self, mut increment: u8) {
-        self.reserve_two_digits();
-
-        let mut i = 0;
-        while increment > 0 {
-            let sum = self.digits[i] + increment;
-            self.digits[i] = sum % 10;
-            increment = sum / 10;
-            i += 1;
-        }
-    }
-}
-
-impl MulAssign<u8> for BigInt {
-    // Assumes base <=16.
-    fn mul_assign(&mut self, base: u8) {
-        self.reserve_two_digits();
-
-        let mut carry = 0;
-        for digit in &mut self.digits {
-            let prod = *digit * base + carry;
-            *digit = prod % 10;
-            carry = prod / 10;
-        }
-    }
-}
diff --git a/vendor/syn/src/buffer.rs b/vendor/syn/src/buffer.rs
deleted file mode 100644
index ec172259..00000000
--- a/vendor/syn/src/buffer.rs
+++ /dev/null
@@ -1,399 +0,0 @@
-//! A stably addressed token buffer supporting efficient traversal based on a
-//! cheaply copyable cursor.
-//!
-//! *This module is available only if Syn is built with the `"parsing"` feature.*
-
-// This module is heavily commented as it contains most of the unsafe code in
-// Syn, and caution should be used when editing it. The public-facing interface
-// is 100% safe but the implementation is fragile internally.
-
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "proc-macro"
-))]
-use crate::proc_macro as pm;
-use crate::Lifetime;
-use proc_macro2::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
-use std::marker::PhantomData;
-use std::ptr;
-
-/// Internal type which is used instead of `TokenTree` to represent a token tree
-/// within a `TokenBuffer`.
-enum Entry {
-    // Mimicking types from proc-macro.
-    Group(Group, TokenBuffer),
-    Ident(Ident),
-    Punct(Punct),
-    Literal(Literal),
-    // End entries contain a raw pointer to the entry from the containing
-    // token tree, or null if this is the outermost level.
-    End(*const Entry),
-}
-
-/// A buffer that can be efficiently traversed multiple times, unlike
-/// `TokenStream` which requires a deep copy in order to traverse more than
-/// once.
-///
-/// *This type is available only if Syn is built with the `"parsing"` feature.*
-pub struct TokenBuffer {
-    // NOTE: Do not derive clone on this - there are raw pointers inside which
-    // will be messed up. Moving the `TokenBuffer` itself is safe as the actual
-    // backing slices won't be moved.
-    data: Box<[Entry]>,
-}
-
-impl TokenBuffer {
-    // NOTE: DO NOT MUTATE THE `Vec` RETURNED FROM THIS FUNCTION ONCE IT
-    // RETURNS, THE ADDRESS OF ITS BACKING MEMORY MUST REMAIN STABLE.
-    fn inner_new(stream: TokenStream, up: *const Entry) -> TokenBuffer {
-        // Build up the entries list, recording the locations of any Groups
-        // in the list to be processed later.
-        let mut entries = Vec::new();
-        let mut seqs = Vec::new();
-        for tt in stream {
-            match tt {
-                TokenTree::Ident(sym) => {
-                    entries.push(Entry::Ident(sym));
-                }
-                TokenTree::Punct(op) => {
-                    entries.push(Entry::Punct(op));
-                }
-                TokenTree::Literal(l) => {
-                    entries.push(Entry::Literal(l));
-                }
-                TokenTree::Group(g) => {
-                    // Record the index of the interesting entry, and store an
-                    // `End(null)` there temporarially.
-                    seqs.push((entries.len(), g));
-                    entries.push(Entry::End(ptr::null()));
-                }
-            }
-        }
-        // Add an `End` entry to the end with a reference to the enclosing token
-        // stream which was passed in.
-        entries.push(Entry::End(up));
-
-        // NOTE: This is done to ensure that we don't accidentally modify the
-        // length of the backing buffer. The backing buffer must remain at a
-        // constant address after this point, as we are going to store a raw
-        // pointer into it.
-        let mut entries = entries.into_boxed_slice();
-        for (idx, group) in seqs {
-            // We know that this index refers to one of the temporary
-            // `End(null)` entries, and we know that the last entry is
-            // `End(up)`, so the next index is also valid.
-            let seq_up = &entries[idx + 1] as *const Entry;
-
-            // The end entry stored at the end of this Entry::Group should
-            // point to the Entry which follows the Group in the list.
-            let inner = Self::inner_new(group.stream(), seq_up);
-            entries[idx] = Entry::Group(group, inner);
-        }
-
-        TokenBuffer { data: entries }
-    }
-
-    /// Creates a `TokenBuffer` containing all the tokens from the input
-    /// `TokenStream`.
-    ///
-    /// *This method is available only if Syn is built with both the `"parsing"` and
-    /// `"proc-macro"` features.*
-    #[cfg(all(
-        not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-        feature = "proc-macro"
-    ))]
-    pub fn new(stream: pm::TokenStream) -> TokenBuffer {
-        Self::new2(stream.into())
-    }
-
-    /// Creates a `TokenBuffer` containing all the tokens from the input
-    /// `TokenStream`.
-    pub fn new2(stream: TokenStream) -> TokenBuffer {
-        Self::inner_new(stream, ptr::null())
-    }
-
-    /// Creates a cursor referencing the first token in the buffer and able to
-    /// traverse until the end of the buffer.
-    pub fn begin(&self) -> Cursor {
-        unsafe { Cursor::create(&self.data[0], &self.data[self.data.len() - 1]) }
-    }
-}
-
-/// A cheaply copyable cursor into a `TokenBuffer`.
-///
-/// This cursor holds a shared reference into the immutable data which is used
-/// internally to represent a `TokenStream`, and can be efficiently manipulated
-/// and copied around.
-///
-/// An empty `Cursor` can be created directly, or one may create a `TokenBuffer`
-/// object and get a cursor to its first token with `begin()`.
-///
-/// Two cursors are equal if they have the same location in the same input
-/// stream, and have the same scope.
-///
-/// *This type is available only if Syn is built with the `"parsing"` feature.*
-pub struct Cursor<'a> {
-    // The current entry which the `Cursor` is pointing at.
-    ptr: *const Entry,
-    // This is the only `Entry::End(..)` object which this cursor is allowed to
-    // point at. All other `End` objects are skipped over in `Cursor::create`.
-    scope: *const Entry,
-    // Cursor is covariant in 'a. This field ensures that our pointers are still
-    // valid.
-    marker: PhantomData<&'a Entry>,
-}
-
-impl<'a> Cursor<'a> {
-    /// Creates a cursor referencing a static empty TokenStream.
-    pub fn empty() -> Self {
-        // It's safe in this situation for us to put an `Entry` object in global
-        // storage, despite it not actually being safe to send across threads
-        // (`Ident` is a reference into a thread-local table). This is because
-        // this entry never includes a `Ident` object.
-        //
-        // This wrapper struct allows us to break the rules and put a `Sync`
-        // object in global storage.
-        struct UnsafeSyncEntry(Entry);
-        unsafe impl Sync for UnsafeSyncEntry {}
-        static EMPTY_ENTRY: UnsafeSyncEntry = UnsafeSyncEntry(Entry::End(0 as *const Entry));
-
-        Cursor {
-            ptr: &EMPTY_ENTRY.0,
-            scope: &EMPTY_ENTRY.0,
-            marker: PhantomData,
-        }
-    }
-
-    /// This create method intelligently exits non-explicitly-entered
-    /// `None`-delimited scopes when the cursor reaches the end of them,
-    /// allowing for them to be treated transparently.
-    unsafe fn create(mut ptr: *const Entry, scope: *const Entry) -> Self {
-        // NOTE: If we're looking at a `End(..)`, we want to advance the cursor
-        // past it, unless `ptr == scope`, which means that we're at the edge of
-        // our cursor's scope. We should only have `ptr != scope` at the exit
-        // from None-delimited groups entered with `ignore_none`.
-        while let Entry::End(exit) = *ptr {
-            if ptr == scope {
-                break;
-            }
-            ptr = exit;
-        }
-
-        Cursor {
-            ptr,
-            scope,
-            marker: PhantomData,
-        }
-    }
-
-    /// Get the current entry.
-    fn entry(self) -> &'a Entry {
-        unsafe { &*self.ptr }
-    }
-
-    /// Bump the cursor to point at the next token after the current one. This
-    /// is undefined behavior if the cursor is currently looking at an
-    /// `Entry::End`.
-    unsafe fn bump(self) -> Cursor<'a> {
-        Cursor::create(self.ptr.offset(1), self.scope)
-    }
-
-    /// While the cursor is looking at a `None`-delimited group, move it to look
-    /// at the first token inside instead. If the group is empty, this will move
-    /// the cursor past the `None`-delimited group.
-    ///
-    /// WARNING: This mutates its argument.
-    fn ignore_none(&mut self) {
-        while let Entry::Group(group, buf) = self.entry() {
-            if group.delimiter() == Delimiter::None {
-                // NOTE: We call `Cursor::create` here to make sure that
-                // situations where we should immediately exit the span after
-                // entering it are handled correctly.
-                unsafe {
-                    *self = Cursor::create(&buf.data[0], self.scope);
-                }
-            } else {
-                break;
-            }
-        }
-    }
-
-    /// Checks whether the cursor is currently pointing at the end of its valid
-    /// scope.
-    pub fn eof(self) -> bool {
-        // We're at eof if we're at the end of our scope.
-        self.ptr == self.scope
-    }
-
-    /// If the cursor is pointing at a `Group` with the given delimiter, returns
-    /// a cursor into that group and one pointing to the next `TokenTree`.
-    pub fn group(mut self, delim: Delimiter) -> Option<(Cursor<'a>, Span, Cursor<'a>)> {
-        // If we're not trying to enter a none-delimited group, we want to
-        // ignore them. We have to make sure to _not_ ignore them when we want
-        // to enter them, of course. For obvious reasons.
-        if delim != Delimiter::None {
-            self.ignore_none();
-        }
-
-        if let Entry::Group(group, buf) = self.entry() {
-            if group.delimiter() == delim {
-                return Some((buf.begin(), group.span(), unsafe { self.bump() }));
-            }
-        }
-
-        None
-    }
-
-    /// If the cursor is pointing at a `Ident`, returns it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn ident(mut self) -> Option<(Ident, Cursor<'a>)> {
-        self.ignore_none();
-        match self.entry() {
-            Entry::Ident(ident) => Some((ident.clone(), unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// If the cursor is pointing at an `Punct`, returns it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn punct(mut self) -> Option<(Punct, Cursor<'a>)> {
-        self.ignore_none();
-        match self.entry() {
-            Entry::Punct(op) if op.as_char() != '\'' => Some((op.clone(), unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// If the cursor is pointing at a `Literal`, return it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn literal(mut self) -> Option<(Literal, Cursor<'a>)> {
-        self.ignore_none();
-        match self.entry() {
-            Entry::Literal(lit) => Some((lit.clone(), unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// If the cursor is pointing at a `Lifetime`, returns it along with a
-    /// cursor pointing at the next `TokenTree`.
-    pub fn lifetime(mut self) -> Option<(Lifetime, Cursor<'a>)> {
-        self.ignore_none();
-        match self.entry() {
-            Entry::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
-                let next = unsafe { self.bump() };
-                match next.ident() {
-                    Some((ident, rest)) => {
-                        let lifetime = Lifetime {
-                            apostrophe: op.span(),
-                            ident,
-                        };
-                        Some((lifetime, rest))
-                    }
-                    None => None,
-                }
-            }
-            _ => None,
-        }
-    }
-
-    /// Copies all remaining tokens visible from this cursor into a
-    /// `TokenStream`.
-    pub fn token_stream(self) -> TokenStream {
-        let mut tts = Vec::new();
-        let mut cursor = self;
-        while let Some((tt, rest)) = cursor.token_tree() {
-            tts.push(tt);
-            cursor = rest;
-        }
-        tts.into_iter().collect()
-    }
-
-    /// If the cursor is pointing at a `TokenTree`, returns it along with a
-    /// cursor pointing at the next `TokenTree`.
-    ///
-    /// Returns `None` if the cursor has reached the end of its stream.
-    ///
-    /// This method does not treat `None`-delimited groups as transparent, and
-    /// will return a `Group(None, ..)` if the cursor is looking at one.
-    pub fn token_tree(self) -> Option<(TokenTree, Cursor<'a>)> {
-        let tree = match self.entry() {
-            Entry::Group(group, _) => group.clone().into(),
-            Entry::Literal(lit) => lit.clone().into(),
-            Entry::Ident(ident) => ident.clone().into(),
-            Entry::Punct(op) => op.clone().into(),
-            Entry::End(..) => {
-                return None;
-            }
-        };
-
-        Some((tree, unsafe { self.bump() }))
-    }
-
-    /// Returns the `Span` of the current token, or `Span::call_site()` if this
-    /// cursor points to eof.
-    pub fn span(self) -> Span {
-        match self.entry() {
-            Entry::Group(group, _) => group.span(),
-            Entry::Literal(l) => l.span(),
-            Entry::Ident(t) => t.span(),
-            Entry::Punct(o) => o.span(),
-            Entry::End(..) => Span::call_site(),
-        }
-    }
-
-    /// Skip over the next token without cloning it. Returns `None` if this
-    /// cursor points to eof.
-    ///
-    /// This method treats `'lifetimes` as a single token.
-    pub(crate) fn skip(self) -> Option<Cursor<'a>> {
-        match self.entry() {
-            Entry::End(..) => None,
-
-            // Treat lifetimes as a single tt for the purposes of 'skip'.
-            Entry::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
-                let next = unsafe { self.bump() };
-                match next.entry() {
-                    Entry::Ident(_) => Some(unsafe { next.bump() }),
-                    _ => Some(next),
-                }
-            }
-            _ => Some(unsafe { self.bump() }),
-        }
-    }
-}
-
-impl<'a> Copy for Cursor<'a> {}
-
-impl<'a> Clone for Cursor<'a> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<'a> Eq for Cursor<'a> {}
-
-impl<'a> PartialEq for Cursor<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        let Cursor { ptr, scope, marker } = self;
-        let _ = marker;
-        *ptr == other.ptr && *scope == other.scope
-    }
-}
-
-pub(crate) fn same_scope(a: Cursor, b: Cursor) -> bool {
-    a.scope == b.scope
-}
-
-pub(crate) fn open_span_of_group(cursor: Cursor) -> Span {
-    match cursor.entry() {
-        Entry::Group(group, _) => group.span_open(),
-        _ => cursor.span(),
-    }
-}
-
-pub(crate) fn close_span_of_group(cursor: Cursor) -> Span {
-    match cursor.entry() {
-        Entry::Group(group, _) => group.span_close(),
-        _ => cursor.span(),
-    }
-}
diff --git a/vendor/syn/src/custom_keyword.rs b/vendor/syn/src/custom_keyword.rs
deleted file mode 100644
index 69d787e5..00000000
--- a/vendor/syn/src/custom_keyword.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-/// Define a type that supports parsing and printing a given identifier as if it
-/// were a keyword.
-///
-/// # Usage
-///
-/// As a convention, it is recommended that this macro be invoked within a
-/// module called `kw` or `keyword` and that the resulting parser be invoked
-/// with a `kw::` or `keyword::` prefix.
-///
-/// ```
-/// mod kw {
-///     syn::custom_keyword!(whatever);
-/// }
-/// ```
-///
-/// The generated syntax tree node supports the following operations just like
-/// any built-in keyword token.
-///
-/// - [Peeking] — `input.peek(kw::whatever)`
-///
-/// - [Parsing] — `input.parse::<kw::whatever>()?`
-///
-/// - [Printing] — `quote!( ... #whatever_token ... )`
-///
-/// - Construction from a [`Span`] — `let whatever_token = kw::whatever(sp)`
-///
-/// - Field access to its span — `let sp = whatever_token.span`
-///
-/// [Peeking]: crate::parse::ParseBuffer::peek
-/// [Parsing]: crate::parse::ParseBuffer::parse
-/// [Printing]: quote::ToTokens
-/// [`Span`]: proc_macro2::Span
-///
-/// # Example
-///
-/// This example parses input that looks like `bool = true` or `str = "value"`.
-/// The key must be either the identifier `bool` or the identifier `str`. If
-/// `bool`, the value may be either `true` or `false`. If `str`, the value may
-/// be any string literal.
-///
-/// The symbols `bool` and `str` are not reserved keywords in Rust so these are
-/// not considered keywords in the `syn::token` module. Like any other
-/// identifier that is not a keyword, these can be declared as custom keywords
-/// by crates that need to use them as such.
-///
-/// ```
-/// use syn::{LitBool, LitStr, Result, Token};
-/// use syn::parse::{Parse, ParseStream};
-///
-/// mod kw {
-///     syn::custom_keyword!(bool);
-///     syn::custom_keyword!(str);
-/// }
-///
-/// enum Argument {
-///     Bool {
-///         bool_token: kw::bool,
-///         eq_token: Token![=],
-///         value: LitBool,
-///     },
-///     Str {
-///         str_token: kw::str,
-///         eq_token: Token![=],
-///         value: LitStr,
-///     },
-/// }
-///
-/// impl Parse for Argument {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let lookahead = input.lookahead1();
-///         if lookahead.peek(kw::bool) {
-///             Ok(Argument::Bool {
-///                 bool_token: input.parse::<kw::bool>()?,
-///                 eq_token: input.parse()?,
-///                 value: input.parse()?,
-///             })
-///         } else if lookahead.peek(kw::str) {
-///             Ok(Argument::Str {
-///                 str_token: input.parse::<kw::str>()?,
-///                 eq_token: input.parse()?,
-///                 value: input.parse()?,
-///             })
-///         } else {
-///             Err(lookahead.error())
-///         }
-///     }
-/// }
-/// ```
-#[macro_export]
-macro_rules! custom_keyword {
-    ($ident:ident) => {
-        #[allow(non_camel_case_types)]
-        pub struct $ident {
-            pub span: $crate::__private::Span,
-        }
-
-        #[doc(hidden)]
-        #[allow(dead_code, non_snake_case)]
-        pub fn $ident<__S: $crate::__private::IntoSpans<[$crate::__private::Span; 1]>>(
-            span: __S,
-        ) -> $ident {
-            $ident {
-                span: $crate::__private::IntoSpans::into_spans(span)[0],
-            }
-        }
-
-        impl $crate::__private::Default for $ident {
-            fn default() -> Self {
-                $ident {
-                    span: $crate::__private::Span::call_site(),
-                }
-            }
-        }
-
-        $crate::impl_parse_for_custom_keyword!($ident);
-        $crate::impl_to_tokens_for_custom_keyword!($ident);
-        $crate::impl_clone_for_custom_keyword!($ident);
-        $crate::impl_extra_traits_for_custom_keyword!($ident);
-    };
-}
-
-// Not public API.
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_parse_for_custom_keyword {
-    ($ident:ident) => {
-        // For peek.
-        impl $crate::token::CustomToken for $ident {
-            fn peek(cursor: $crate::buffer::Cursor) -> $crate::__private::bool {
-                if let Some((ident, _rest)) = cursor.ident() {
-                    ident == stringify!($ident)
-                } else {
-                    false
-                }
-            }
-
-            fn display() -> &'static $crate::__private::str {
-                concat!("`", stringify!($ident), "`")
-            }
-        }
-
-        impl $crate::parse::Parse for $ident {
-            fn parse(input: $crate::parse::ParseStream) -> $crate::parse::Result<$ident> {
-                input.step(|cursor| {
-                    if let $crate::__private::Some((ident, rest)) = cursor.ident() {
-                        if ident == stringify!($ident) {
-                            return $crate::__private::Ok(($ident { span: ident.span() }, rest));
-                        }
-                    }
-                    $crate::__private::Err(cursor.error(concat!(
-                        "expected `",
-                        stringify!($ident),
-                        "`"
-                    )))
-                })
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "parsing"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_parse_for_custom_keyword {
-    ($ident:ident) => {};
-}
-
-// Not public API.
-#[cfg(feature = "printing")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_to_tokens_for_custom_keyword {
-    ($ident:ident) => {
-        impl $crate::__private::ToTokens for $ident {
-            fn to_tokens(&self, tokens: &mut $crate::__private::TokenStream2) {
-                let ident = $crate::Ident::new(stringify!($ident), self.span);
-                $crate::__private::TokenStreamExt::append(tokens, ident);
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "printing"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_to_tokens_for_custom_keyword {
-    ($ident:ident) => {};
-}
-
-// Not public API.
-#[cfg(feature = "clone-impls")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_clone_for_custom_keyword {
-    ($ident:ident) => {
-        impl $crate::__private::Copy for $ident {}
-
-        #[allow(clippy::expl_impl_clone_on_copy)]
-        impl $crate::__private::Clone for $ident {
-            fn clone(&self) -> Self {
-                *self
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "clone-impls"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_clone_for_custom_keyword {
-    ($ident:ident) => {};
-}
-
-// Not public API.
-#[cfg(feature = "extra-traits")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_extra_traits_for_custom_keyword {
-    ($ident:ident) => {
-        impl $crate::__private::Debug for $ident {
-            fn fmt(&self, f: &mut $crate::__private::Formatter) -> $crate::__private::fmt::Result {
-                $crate::__private::Formatter::write_str(
-                    f,
-                    concat!("Keyword [", stringify!($ident), "]"),
-                )
-            }
-        }
-
-        impl $crate::__private::Eq for $ident {}
-
-        impl $crate::__private::PartialEq for $ident {
-            fn eq(&self, _other: &Self) -> $crate::__private::bool {
-                true
-            }
-        }
-
-        impl $crate::__private::Hash for $ident {
-            fn hash<__H: $crate::__private::Hasher>(&self, _state: &mut __H) {}
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "extra-traits"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_extra_traits_for_custom_keyword {
-    ($ident:ident) => {};
-}
diff --git a/vendor/syn/src/custom_punctuation.rs b/vendor/syn/src/custom_punctuation.rs
deleted file mode 100644
index 118a8453..00000000
--- a/vendor/syn/src/custom_punctuation.rs
+++ /dev/null
@@ -1,300 +0,0 @@
-/// Define a type that supports parsing and printing a multi-character symbol
-/// as if it were a punctuation token.
-///
-/// # Usage
-///
-/// ```
-/// syn::custom_punctuation!(LeftRightArrow, <=>);
-/// ```
-///
-/// The generated syntax tree node supports the following operations just like
-/// any built-in punctuation token.
-///
-/// - [Peeking] — `input.peek(LeftRightArrow)`
-///
-/// - [Parsing] — `input.parse::<LeftRightArrow>()?`
-///
-/// - [Printing] — `quote!( ... #lrarrow ... )`
-///
-/// - Construction from a [`Span`] — `let lrarrow = LeftRightArrow(sp)`
-///
-/// - Construction from multiple [`Span`] — `let lrarrow = LeftRightArrow([sp, sp, sp])`
-///
-/// - Field access to its spans — `let spans = lrarrow.spans`
-///
-/// [Peeking]: crate::parse::ParseBuffer::peek
-/// [Parsing]: crate::parse::ParseBuffer::parse
-/// [Printing]: quote::ToTokens
-/// [`Span`]: proc_macro2::Span
-///
-/// # Example
-///
-/// ```
-/// use proc_macro2::{TokenStream, TokenTree};
-/// use syn::parse::{Parse, ParseStream, Peek, Result};
-/// use syn::punctuated::Punctuated;
-/// use syn::Expr;
-///
-/// syn::custom_punctuation!(PathSeparator, </>);
-///
-/// // expr </> expr </> expr ...
-/// struct PathSegments {
-///     segments: Punctuated<Expr, PathSeparator>,
-/// }
-///
-/// impl Parse for PathSegments {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let mut segments = Punctuated::new();
-///
-///         let first = parse_until(input, PathSeparator)?;
-///         segments.push_value(syn::parse2(first)?);
-///
-///         while input.peek(PathSeparator) {
-///             segments.push_punct(input.parse()?);
-///
-///             let next = parse_until(input, PathSeparator)?;
-///             segments.push_value(syn::parse2(next)?);
-///         }
-///
-///         Ok(PathSegments { segments })
-///     }
-/// }
-///
-/// fn parse_until<E: Peek>(input: ParseStream, end: E) -> Result<TokenStream> {
-///     let mut tokens = TokenStream::new();
-///     while !input.is_empty() && !input.peek(end) {
-///         let next: TokenTree = input.parse()?;
-///         tokens.extend(Some(next));
-///     }
-///     Ok(tokens)
-/// }
-///
-/// fn main() {
-///     let input = r#" a::b </> c::d::e "#;
-///     let _: PathSegments = syn::parse_str(input).unwrap();
-/// }
-/// ```
-#[macro_export]
-macro_rules! custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {
-        pub struct $ident {
-            pub spans: $crate::custom_punctuation_repr!($($tt)+),
-        }
-
-        #[doc(hidden)]
-        #[allow(dead_code, non_snake_case)]
-        pub fn $ident<__S: $crate::__private::IntoSpans<$crate::custom_punctuation_repr!($($tt)+)>>(
-            spans: __S,
-        ) -> $ident {
-            let _validate_len = 0 $(+ $crate::custom_punctuation_len!(strict, $tt))*;
-            $ident {
-                spans: $crate::__private::IntoSpans::into_spans(spans)
-            }
-        }
-
-        impl $crate::__private::Default for $ident {
-            fn default() -> Self {
-                $ident($crate::__private::Span::call_site())
-            }
-        }
-
-        $crate::impl_parse_for_custom_punctuation!($ident, $($tt)+);
-        $crate::impl_to_tokens_for_custom_punctuation!($ident, $($tt)+);
-        $crate::impl_clone_for_custom_punctuation!($ident, $($tt)+);
-        $crate::impl_extra_traits_for_custom_punctuation!($ident, $($tt)+);
-    };
-}
-
-// Not public API.
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_parse_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {
-        impl $crate::token::CustomToken for $ident {
-            fn peek(cursor: $crate::buffer::Cursor) -> bool {
-                $crate::token::parsing::peek_punct(cursor, $crate::stringify_punct!($($tt)+))
-            }
-
-            fn display() -> &'static $crate::__private::str {
-                concat!("`", $crate::stringify_punct!($($tt)+), "`")
-            }
-        }
-
-        impl $crate::parse::Parse for $ident {
-            fn parse(input: $crate::parse::ParseStream) -> $crate::parse::Result<$ident> {
-                let spans: $crate::custom_punctuation_repr!($($tt)+) =
-                    $crate::token::parsing::punct(input, $crate::stringify_punct!($($tt)+))?;
-                Ok($ident(spans))
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "parsing"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_parse_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {};
-}
-
-// Not public API.
-#[cfg(feature = "printing")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_to_tokens_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {
-        impl $crate::__private::ToTokens for $ident {
-            fn to_tokens(&self, tokens: &mut $crate::__private::TokenStream2) {
-                $crate::token::printing::punct($crate::stringify_punct!($($tt)+), &self.spans, tokens)
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "printing"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_to_tokens_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {};
-}
-
-// Not public API.
-#[cfg(feature = "clone-impls")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_clone_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {
-        impl $crate::__private::Copy for $ident {}
-
-        #[allow(clippy::expl_impl_clone_on_copy)]
-        impl $crate::__private::Clone for $ident {
-            fn clone(&self) -> Self {
-                *self
-            }
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "clone-impls"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_clone_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {};
-}
-
-// Not public API.
-#[cfg(feature = "extra-traits")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_extra_traits_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {
-        impl $crate::__private::Debug for $ident {
-            fn fmt(&self, f: &mut $crate::__private::Formatter) -> $crate::__private::fmt::Result {
-                $crate::__private::Formatter::write_str(f, stringify!($ident))
-            }
-        }
-
-        impl $crate::__private::Eq for $ident {}
-
-        impl $crate::__private::PartialEq for $ident {
-            fn eq(&self, _other: &Self) -> $crate::__private::bool {
-                true
-            }
-        }
-
-        impl $crate::__private::Hash for $ident {
-            fn hash<__H: $crate::__private::Hasher>(&self, _state: &mut __H) {}
-        }
-    };
-}
-
-// Not public API.
-#[cfg(not(feature = "extra-traits"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_extra_traits_for_custom_punctuation {
-    ($ident:ident, $($tt:tt)+) => {};
-}
-
-// Not public API.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! custom_punctuation_repr {
-    ($($tt:tt)+) => {
-        [$crate::__private::Span; 0 $(+ $crate::custom_punctuation_len!(lenient, $tt))+]
-    };
-}
-
-// Not public API.
-#[doc(hidden)]
-#[macro_export]
-#[rustfmt::skip]
-macro_rules! custom_punctuation_len {
-    ($mode:ident, +)     => { 1 };
-    ($mode:ident, +=)    => { 2 };
-    ($mode:ident, &)     => { 1 };
-    ($mode:ident, &&)    => { 2 };
-    ($mode:ident, &=)    => { 2 };
-    ($mode:ident, @)     => { 1 };
-    ($mode:ident, !)     => { 1 };
-    ($mode:ident, ^)     => { 1 };
-    ($mode:ident, ^=)    => { 2 };
-    ($mode:ident, :)     => { 1 };
-    ($mode:ident, ::)    => { 2 };
-    ($mode:ident, ,)     => { 1 };
-    ($mode:ident, /)     => { 1 };
-    ($mode:ident, /=)    => { 2 };
-    ($mode:ident, .)     => { 1 };
-    ($mode:ident, ..)    => { 2 };
-    ($mode:ident, ...)   => { 3 };
-    ($mode:ident, ..=)   => { 3 };
-    ($mode:ident, =)     => { 1 };
-    ($mode:ident, ==)    => { 2 };
-    ($mode:ident, >=)    => { 2 };
-    ($mode:ident, >)     => { 1 };
-    ($mode:ident, <=)    => { 2 };
-    ($mode:ident, <)     => { 1 };
-    ($mode:ident, *=)    => { 2 };
-    ($mode:ident, !=)    => { 2 };
-    ($mode:ident, |)     => { 1 };
-    ($mode:ident, |=)    => { 2 };
-    ($mode:ident, ||)    => { 2 };
-    ($mode:ident, #)     => { 1 };
-    ($mode:ident, ?)     => { 1 };
-    ($mode:ident, ->)    => { 2 };
-    ($mode:ident, <-)    => { 2 };
-    ($mode:ident, %)     => { 1 };
-    ($mode:ident, %=)    => { 2 };
-    ($mode:ident, =>)    => { 2 };
-    ($mode:ident, ;)     => { 1 };
-    ($mode:ident, <<)    => { 2 };
-    ($mode:ident, <<=)   => { 3 };
-    ($mode:ident, >>)    => { 2 };
-    ($mode:ident, >>=)   => { 3 };
-    ($mode:ident, *)     => { 1 };
-    ($mode:ident, -)     => { 1 };
-    ($mode:ident, -=)    => { 2 };
-    ($mode:ident, ~)     => { 1 };
-    (lenient, $tt:tt)    => { 0 };
-    (strict, $tt:tt)     => {{ $crate::custom_punctuation_unexpected!($tt); 0 }};
-}
-
-// Not public API.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! custom_punctuation_unexpected {
-    () => {};
-}
-
-// Not public API.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! stringify_punct {
-    ($($tt:tt)+) => {
-        concat!($(stringify!($tt)),+)
-    };
-}
diff --git a/vendor/syn/src/data.rs b/vendor/syn/src/data.rs
deleted file mode 100644
index 837224e1..00000000
--- a/vendor/syn/src/data.rs
+++ /dev/null
@@ -1,501 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-
-ast_struct! {
-    /// An enum variant.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Variant {
-        /// Attributes tagged on the variant.
-        pub attrs: Vec<Attribute>,
-
-        /// Name of the variant.
-        pub ident: Ident,
-
-        /// Content stored in the variant.
-        pub fields: Fields,
-
-        /// Explicit discriminant: `Variant = 1`
-        pub discriminant: Option<(Token![=], Expr)>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// Data stored within an enum variant or struct.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Fields {
-        /// Named fields of a struct or struct variant such as `Point { x: f64,
-        /// y: f64 }`.
-        Named(FieldsNamed),
-
-        /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
-        Unnamed(FieldsUnnamed),
-
-        /// Unit struct or unit variant such as `None`.
-        Unit,
-    }
-}
-
-ast_struct! {
-    /// Named fields of a struct or struct variant such as `Point { x: f64,
-    /// y: f64 }`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct FieldsNamed {
-        pub brace_token: token::Brace,
-        pub named: Punctuated<Field, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct FieldsUnnamed {
-        pub paren_token: token::Paren,
-        pub unnamed: Punctuated<Field, Token![,]>,
-    }
-}
-
-impl Fields {
-    /// Get an iterator over the borrowed [`Field`] items in this object. This
-    /// iterator can be used to iterate over a named or unnamed struct or
-    /// variant's fields uniformly.
-    pub fn iter(&self) -> punctuated::Iter<Field> {
-        match self {
-            Fields::Unit => crate::punctuated::empty_punctuated_iter(),
-            Fields::Named(f) => f.named.iter(),
-            Fields::Unnamed(f) => f.unnamed.iter(),
-        }
-    }
-
-    /// Get an iterator over the mutably borrowed [`Field`] items in this
-    /// object. This iterator can be used to iterate over a named or unnamed
-    /// struct or variant's fields uniformly.
-    pub fn iter_mut(&mut self) -> punctuated::IterMut<Field> {
-        match self {
-            Fields::Unit => crate::punctuated::empty_punctuated_iter_mut(),
-            Fields::Named(f) => f.named.iter_mut(),
-            Fields::Unnamed(f) => f.unnamed.iter_mut(),
-        }
-    }
-
-    /// Returns the number of fields.
-    pub fn len(&self) -> usize {
-        match self {
-            Fields::Unit => 0,
-            Fields::Named(f) => f.named.len(),
-            Fields::Unnamed(f) => f.unnamed.len(),
-        }
-    }
-
-    /// Returns `true` if there are zero fields.
-    pub fn is_empty(&self) -> bool {
-        match self {
-            Fields::Unit => true,
-            Fields::Named(f) => f.named.is_empty(),
-            Fields::Unnamed(f) => f.unnamed.is_empty(),
-        }
-    }
-}
-
-impl IntoIterator for Fields {
-    type Item = Field;
-    type IntoIter = punctuated::IntoIter<Field>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        match self {
-            Fields::Unit => Punctuated::<Field, ()>::new().into_iter(),
-            Fields::Named(f) => f.named.into_iter(),
-            Fields::Unnamed(f) => f.unnamed.into_iter(),
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a Fields {
-    type Item = &'a Field;
-    type IntoIter = punctuated::Iter<'a, Field>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-impl<'a> IntoIterator for &'a mut Fields {
-    type Item = &'a mut Field;
-    type IntoIter = punctuated::IterMut<'a, Field>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter_mut()
-    }
-}
-
-ast_struct! {
-    /// A field of a struct or enum variant.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Field {
-        /// Attributes tagged on the field.
-        pub attrs: Vec<Attribute>,
-
-        /// Visibility of the field.
-        pub vis: Visibility,
-
-        /// Name of the field, if any.
-        ///
-        /// Fields of tuple structs have no names.
-        pub ident: Option<Ident>,
-
-        pub colon_token: Option<Token![:]>,
-
-        /// Type of the field.
-        pub ty: Type,
-    }
-}
-
-ast_enum_of_structs! {
-    /// The visibility level of an item: inherited or `pub` or
-    /// `pub(restricted)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Visibility {
-        /// A public visibility level: `pub`.
-        Public(VisPublic),
-
-        /// A crate-level visibility: `crate`.
-        Crate(VisCrate),
-
-        /// A visibility level restricted to some path: `pub(self)` or
-        /// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
-        Restricted(VisRestricted),
-
-        /// An inherited visibility, which usually means private.
-        Inherited,
-    }
-}
-
-ast_struct! {
-    /// A public visibility level: `pub`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct VisPublic {
-        pub pub_token: Token![pub],
-    }
-}
-
-ast_struct! {
-    /// A crate-level visibility: `crate`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct VisCrate {
-        pub crate_token: Token![crate],
-    }
-}
-
-ast_struct! {
-    /// A visibility level restricted to some path: `pub(self)` or
-    /// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct VisRestricted {
-        pub pub_token: Token![pub],
-        pub paren_token: token::Paren,
-        pub in_token: Option<Token![in]>,
-        pub path: Box<Path>,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::discouraged::Speculative;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Variant {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let _visibility: Visibility = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let fields = if input.peek(token::Brace) {
-                let fields = parse_braced(input, &mut attrs)?;
-                Fields::Named(fields)
-            } else if input.peek(token::Paren) {
-                Fields::Unnamed(input.parse()?)
-            } else {
-                Fields::Unit
-            };
-            let discriminant = if input.peek(Token![=]) {
-                let eq_token: Token![=] = input.parse()?;
-                let discriminant: Expr = input.parse()?;
-                Some((eq_token, discriminant))
-            } else {
-                None
-            };
-            Ok(Variant {
-                attrs,
-                ident,
-                fields,
-                discriminant,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for FieldsNamed {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(FieldsNamed {
-                brace_token: braced!(content in input),
-                named: content.parse_terminated(Field::parse_named)?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for FieldsUnnamed {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(FieldsUnnamed {
-                paren_token: parenthesized!(content in input),
-                unnamed: content.parse_terminated(Field::parse_unnamed)?,
-            })
-        }
-    }
-
-    pub(crate) fn parse_braced(
-        input: ParseStream,
-        attrs: &mut Vec<Attribute>,
-    ) -> Result<FieldsNamed> {
-        let content;
-        let brace_token = braced!(content in input);
-        attr::parsing::parse_inner(&content, attrs)?;
-        let named = content.parse_terminated(Field::parse_named)?;
-        Ok(FieldsNamed { brace_token, named })
-    }
-
-    impl Field {
-        /// Parses a named (braced struct) field.
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn parse_named(input: ParseStream) -> Result<Self> {
-            Ok(Field {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                ident: Some(input.parse()?),
-                colon_token: Some(input.parse()?),
-                ty: input.parse()?,
-            })
-        }
-
-        /// Parses an unnamed (tuple struct) field.
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn parse_unnamed(input: ParseStream) -> Result<Self> {
-            Ok(Field {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                ident: None,
-                colon_token: None,
-                ty: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Visibility {
-        fn parse(input: ParseStream) -> Result<Self> {
-            // Recognize an empty None-delimited group, as produced by a $:vis
-            // matcher that matched no tokens.
-            if input.peek(token::Group) {
-                let ahead = input.fork();
-                let group = crate::group::parse_group(&ahead)?;
-                if group.content.is_empty() {
-                    input.advance_to(&ahead);
-                    return Ok(Visibility::Inherited);
-                }
-            }
-
-            if input.peek(Token![pub]) {
-                Self::parse_pub(input)
-            } else if input.peek(Token![crate]) {
-                Self::parse_crate(input)
-            } else {
-                Ok(Visibility::Inherited)
-            }
-        }
-    }
-
-    impl Visibility {
-        fn parse_pub(input: ParseStream) -> Result<Self> {
-            let pub_token = input.parse::<Token![pub]>()?;
-
-            if input.peek(token::Paren) {
-                let ahead = input.fork();
-
-                let content;
-                let paren_token = parenthesized!(content in ahead);
-                if content.peek(Token![crate])
-                    || content.peek(Token![self])
-                    || content.peek(Token![super])
-                {
-                    let path = content.call(Ident::parse_any)?;
-
-                    // Ensure there are no additional tokens within `content`.
-                    // Without explicitly checking, we may misinterpret a tuple
-                    // field as a restricted visibility, causing a parse error.
-                    // e.g. `pub (crate::A, crate::B)` (Issue #720).
-                    if content.is_empty() {
-                        input.advance_to(&ahead);
-                        return Ok(Visibility::Restricted(VisRestricted {
-                            pub_token,
-                            paren_token,
-                            in_token: None,
-                            path: Box::new(Path::from(path)),
-                        }));
-                    }
-                } else if content.peek(Token![in]) {
-                    let in_token: Token![in] = content.parse()?;
-                    let path = content.call(Path::parse_mod_style)?;
-
-                    input.advance_to(&ahead);
-                    return Ok(Visibility::Restricted(VisRestricted {
-                        pub_token,
-                        paren_token,
-                        in_token: Some(in_token),
-                        path: Box::new(path),
-                    }));
-                }
-            }
-
-            Ok(Visibility::Public(VisPublic { pub_token }))
-        }
-
-        fn parse_crate(input: ParseStream) -> Result<Self> {
-            if input.peek2(Token![::]) {
-                Ok(Visibility::Inherited)
-            } else {
-                Ok(Visibility::Crate(VisCrate {
-                    crate_token: input.parse()?,
-                }))
-            }
-        }
-
-        #[cfg(feature = "full")]
-        pub(crate) fn is_some(&self) -> bool {
-            match self {
-                Visibility::Inherited => false,
-                _ => true,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::print::TokensOrDefault;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Variant {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(&self.attrs);
-            self.ident.to_tokens(tokens);
-            self.fields.to_tokens(tokens);
-            if let Some((eq_token, disc)) = &self.discriminant {
-                eq_token.to_tokens(tokens);
-                disc.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for FieldsNamed {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.brace_token.surround(tokens, |tokens| {
-                self.named.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for FieldsUnnamed {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.paren_token.surround(tokens, |tokens| {
-                self.unnamed.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Field {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(&self.attrs);
-            self.vis.to_tokens(tokens);
-            if let Some(ident) = &self.ident {
-                ident.to_tokens(tokens);
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-            }
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for VisPublic {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.pub_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for VisCrate {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.crate_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for VisRestricted {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.pub_token.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                // TODO: If we have a path which is not "self" or "super" or
-                // "crate", automatically add the "in" token.
-                self.in_token.to_tokens(tokens);
-                self.path.to_tokens(tokens);
-            });
-        }
-    }
-}
diff --git a/vendor/syn/src/derive.rs b/vendor/syn/src/derive.rs
deleted file mode 100644
index 17387e45..00000000
--- a/vendor/syn/src/derive.rs
+++ /dev/null
@@ -1,280 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-
-ast_struct! {
-    /// Data structure sent to a `proc_macro_derive` macro.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-    pub struct DeriveInput {
-        /// Attributes tagged on the whole struct or enum.
-        pub attrs: Vec<Attribute>,
-
-        /// Visibility of the struct or enum.
-        pub vis: Visibility,
-
-        /// Name of the struct or enum.
-        pub ident: Ident,
-
-        /// Generics required to complete the definition.
-        pub generics: Generics,
-
-        /// Data within the struct or enum.
-        pub data: Data,
-    }
-}
-
-ast_enum_of_structs! {
-    /// The storage of a struct, enum or union data structure.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-    pub enum Data {
-        /// A struct input to a `proc_macro_derive` macro.
-        Struct(DataStruct),
-
-        /// An enum input to a `proc_macro_derive` macro.
-        Enum(DataEnum),
-
-        /// An untagged union input to a `proc_macro_derive` macro.
-        Union(DataUnion),
-    }
-
-    do_not_generate_to_tokens
-}
-
-ast_struct! {
-    /// A struct input to a `proc_macro_derive` macro.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-    pub struct DataStruct {
-        pub struct_token: Token![struct],
-        pub fields: Fields,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// An enum input to a `proc_macro_derive` macro.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-    pub struct DataEnum {
-        pub enum_token: Token![enum],
-        pub brace_token: token::Brace,
-        pub variants: Punctuated<Variant, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// An untagged union input to a `proc_macro_derive` macro.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-    pub struct DataUnion {
-        pub union_token: Token![union],
-        pub fields: FieldsNamed,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for DeriveInput {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis = input.parse::<Visibility>()?;
-
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Token![struct]) {
-                let struct_token = input.parse::<Token![struct]>()?;
-                let ident = input.parse::<Ident>()?;
-                let generics = input.parse::<Generics>()?;
-                let (where_clause, fields, semi) = data_struct(input, &mut attrs)?;
-                Ok(DeriveInput {
-                    attrs,
-                    vis,
-                    ident,
-                    generics: Generics {
-                        where_clause,
-                        ..generics
-                    },
-                    data: Data::Struct(DataStruct {
-                        struct_token,
-                        fields,
-                        semi_token: semi,
-                    }),
-                })
-            } else if lookahead.peek(Token![enum]) {
-                let enum_token = input.parse::<Token![enum]>()?;
-                let ident = input.parse::<Ident>()?;
-                let generics = input.parse::<Generics>()?;
-                let (where_clause, brace, variants) = data_enum(input, &mut attrs)?;
-                Ok(DeriveInput {
-                    attrs,
-                    vis,
-                    ident,
-                    generics: Generics {
-                        where_clause,
-                        ..generics
-                    },
-                    data: Data::Enum(DataEnum {
-                        enum_token,
-                        brace_token: brace,
-                        variants,
-                    }),
-                })
-            } else if lookahead.peek(Token![union]) {
-                let union_token = input.parse::<Token![union]>()?;
-                let ident = input.parse::<Ident>()?;
-                let generics = input.parse::<Generics>()?;
-                let (where_clause, fields) = data_union(input, &mut attrs)?;
-                Ok(DeriveInput {
-                    attrs,
-                    vis,
-                    ident,
-                    generics: Generics {
-                        where_clause,
-                        ..generics
-                    },
-                    data: Data::Union(DataUnion {
-                        union_token,
-                        fields,
-                    }),
-                })
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    pub fn data_struct(
-        input: ParseStream,
-        attrs: &mut Vec<Attribute>,
-    ) -> Result<(Option<WhereClause>, Fields, Option<Token![;]>)> {
-        let mut lookahead = input.lookahead1();
-        let mut where_clause = None;
-        if lookahead.peek(Token![where]) {
-            where_clause = Some(input.parse()?);
-            lookahead = input.lookahead1();
-        }
-
-        if where_clause.is_none() && lookahead.peek(token::Paren) {
-            let fields = input.parse()?;
-
-            lookahead = input.lookahead1();
-            if lookahead.peek(Token![where]) {
-                where_clause = Some(input.parse()?);
-                lookahead = input.lookahead1();
-            }
-
-            if lookahead.peek(Token![;]) {
-                let semi = input.parse()?;
-                Ok((where_clause, Fields::Unnamed(fields), Some(semi)))
-            } else {
-                Err(lookahead.error())
-            }
-        } else if lookahead.peek(token::Brace) {
-            let fields = data::parsing::parse_braced(input, attrs)?;
-            Ok((where_clause, Fields::Named(fields), None))
-        } else if lookahead.peek(Token![;]) {
-            let semi = input.parse()?;
-            Ok((where_clause, Fields::Unit, Some(semi)))
-        } else {
-            Err(lookahead.error())
-        }
-    }
-
-    pub fn data_enum(
-        input: ParseStream,
-        attrs: &mut Vec<Attribute>,
-    ) -> Result<(
-        Option<WhereClause>,
-        token::Brace,
-        Punctuated<Variant, Token![,]>,
-    )> {
-        let where_clause = input.parse()?;
-
-        let content;
-        let brace = braced!(content in input);
-        attr::parsing::parse_inner(&content, attrs)?;
-        let variants = content.parse_terminated(Variant::parse)?;
-
-        Ok((where_clause, brace, variants))
-    }
-
-    pub fn data_union(
-        input: ParseStream,
-        attrs: &mut Vec<Attribute>,
-    ) -> Result<(Option<WhereClause>, FieldsNamed)> {
-        let where_clause = input.parse()?;
-        let fields = data::parsing::parse_braced(input, attrs)?;
-        Ok((where_clause, fields))
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use crate::print::TokensOrDefault;
-    use proc_macro2::TokenStream;
-    use quote::ToTokens;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for DeriveInput {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            for attr in self.attrs.outer() {
-                attr.to_tokens(tokens);
-            }
-            self.vis.to_tokens(tokens);
-            match &self.data {
-                Data::Struct(d) => d.struct_token.to_tokens(tokens),
-                Data::Enum(d) => d.enum_token.to_tokens(tokens),
-                Data::Union(d) => d.union_token.to_tokens(tokens),
-            }
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            match &self.data {
-                Data::Struct(data) => match &data.fields {
-                    Fields::Named(fields) => {
-                        self.generics.where_clause.to_tokens(tokens);
-                        fields.to_tokens(tokens);
-                    }
-                    Fields::Unnamed(fields) => {
-                        fields.to_tokens(tokens);
-                        self.generics.where_clause.to_tokens(tokens);
-                        TokensOrDefault(&data.semi_token).to_tokens(tokens);
-                    }
-                    Fields::Unit => {
-                        self.generics.where_clause.to_tokens(tokens);
-                        TokensOrDefault(&data.semi_token).to_tokens(tokens);
-                    }
-                },
-                Data::Enum(data) => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    data.brace_token.surround(tokens, |tokens| {
-                        data.variants.to_tokens(tokens);
-                    });
-                }
-                Data::Union(data) => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    data.fields.to_tokens(tokens);
-                }
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/discouraged.rs b/vendor/syn/src/discouraged.rs
deleted file mode 100644
index a46129b6..00000000
--- a/vendor/syn/src/discouraged.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-//! Extensions to the parsing API with niche applicability.
-
-use super::*;
-
-/// Extensions to the `ParseStream` API to support speculative parsing.
-pub trait Speculative {
-    /// Advance this parse stream to the position of a forked parse stream.
-    ///
-    /// This is the opposite operation to [`ParseStream::fork`]. You can fork a
-    /// parse stream, perform some speculative parsing, then join the original
-    /// stream to the fork to "commit" the parsing from the fork to the main
-    /// stream.
-    ///
-    /// If you can avoid doing this, you should, as it limits the ability to
-    /// generate useful errors. That said, it is often the only way to parse
-    /// syntax of the form `A* B*` for arbitrary syntax `A` and `B`. The problem
-    /// is that when the fork fails to parse an `A`, it's impossible to tell
-    /// whether that was because of a syntax error and the user meant to provide
-    /// an `A`, or that the `A`s are finished and it's time to start parsing
-    /// `B`s. Use with care.
-    ///
-    /// Also note that if `A` is a subset of `B`, `A* B*` can be parsed by
-    /// parsing `B*` and removing the leading members of `A` from the
-    /// repetition, bypassing the need to involve the downsides associated with
-    /// speculative parsing.
-    ///
-    /// [`ParseStream::fork`]: ParseBuffer::fork
-    ///
-    /// # Example
-    ///
-    /// There has been chatter about the possibility of making the colons in the
-    /// turbofish syntax like `path::to::<T>` no longer required by accepting
-    /// `path::to<T>` in expression position. Specifically, according to [RFC
-    /// 2544], [`PathSegment`] parsing should always try to consume a following
-    /// `<` token as the start of generic arguments, and reset to the `<` if
-    /// that fails (e.g. the token is acting as a less-than operator).
-    ///
-    /// This is the exact kind of parsing behavior which requires the "fork,
-    /// try, commit" behavior that [`ParseStream::fork`] discourages. With
-    /// `advance_to`, we can avoid having to parse the speculatively parsed
-    /// content a second time.
-    ///
-    /// This change in behavior can be implemented in syn by replacing just the
-    /// `Parse` implementation for `PathSegment`:
-    ///
-    /// ```
-    /// # use syn::ext::IdentExt;
-    /// use syn::parse::discouraged::Speculative;
-    /// # use syn::parse::{Parse, ParseStream};
-    /// # use syn::{Ident, PathArguments, Result, Token};
-    ///
-    /// pub struct PathSegment {
-    ///     pub ident: Ident,
-    ///     pub arguments: PathArguments,
-    /// }
-    /// #
-    /// # impl<T> From<T> for PathSegment
-    /// # where
-    /// #     T: Into<Ident>,
-    /// # {
-    /// #     fn from(ident: T) -> Self {
-    /// #         PathSegment {
-    /// #             ident: ident.into(),
-    /// #             arguments: PathArguments::None,
-    /// #         }
-    /// #     }
-    /// # }
-    ///
-    /// impl Parse for PathSegment {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         if input.peek(Token![super])
-    ///             || input.peek(Token![self])
-    ///             || input.peek(Token![Self])
-    ///             || input.peek(Token![crate])
-    ///         {
-    ///             let ident = input.call(Ident::parse_any)?;
-    ///             return Ok(PathSegment::from(ident));
-    ///         }
-    ///
-    ///         let ident = input.parse()?;
-    ///         if input.peek(Token![::]) && input.peek3(Token![<]) {
-    ///             return Ok(PathSegment {
-    ///                 ident,
-    ///                 arguments: PathArguments::AngleBracketed(input.parse()?),
-    ///             });
-    ///         }
-    ///         if input.peek(Token![<]) && !input.peek(Token![<=]) {
-    ///             let fork = input.fork();
-    ///             if let Ok(arguments) = fork.parse() {
-    ///                 input.advance_to(&fork);
-    ///                 return Ok(PathSegment {
-    ///                     ident,
-    ///                     arguments: PathArguments::AngleBracketed(arguments),
-    ///                 });
-    ///             }
-    ///         }
-    ///         Ok(PathSegment::from(ident))
-    ///     }
-    /// }
-    ///
-    /// # syn::parse_str::<PathSegment>("a<b,c>").unwrap();
-    /// ```
-    ///
-    /// # Drawbacks
-    ///
-    /// The main drawback of this style of speculative parsing is in error
-    /// presentation. Even if the lookahead is the "correct" parse, the error
-    /// that is shown is that of the "fallback" parse. To use the same example
-    /// as the turbofish above, take the following unfinished "turbofish":
-    ///
-    /// ```text
-    /// let _ = f<&'a fn(), for<'a> serde::>();
-    /// ```
-    ///
-    /// If this is parsed as generic arguments, we can provide the error message
-    ///
-    /// ```text
-    /// error: expected identifier
-    ///  --> src.rs:L:C
-    ///   |
-    /// L | let _ = f<&'a fn(), for<'a> serde::>();
-    ///   |                                    ^
-    /// ```
-    ///
-    /// but if parsed using the above speculative parsing, it falls back to
-    /// assuming that the `<` is a less-than when it fails to parse the generic
-    /// arguments, and tries to interpret the `&'a` as the start of a labelled
-    /// loop, resulting in the much less helpful error
-    ///
-    /// ```text
-    /// error: expected `:`
-    ///  --> src.rs:L:C
-    ///   |
-    /// L | let _ = f<&'a fn(), for<'a> serde::>();
-    ///   |               ^^
-    /// ```
-    ///
-    /// This can be mitigated with various heuristics (two examples: show both
-    /// forks' parse errors, or show the one that consumed more tokens), but
-    /// when you can control the grammar, sticking to something that can be
-    /// parsed LL(3) and without the LL(*) speculative parsing this makes
-    /// possible, displaying reasonable errors becomes much more simple.
-    ///
-    /// [RFC 2544]: https://github.com/rust-lang/rfcs/pull/2544
-    /// [`PathSegment`]: crate::PathSegment
-    ///
-    /// # Performance
-    ///
-    /// This method performs a cheap fixed amount of work that does not depend
-    /// on how far apart the two streams are positioned.
-    ///
-    /// # Panics
-    ///
-    /// The forked stream in the argument of `advance_to` must have been
-    /// obtained by forking `self`. Attempting to advance to any other stream
-    /// will cause a panic.
-    fn advance_to(&self, fork: &Self);
-}
-
-impl<'a> Speculative for ParseBuffer<'a> {
-    fn advance_to(&self, fork: &Self) {
-        if !crate::buffer::same_scope(self.cursor(), fork.cursor()) {
-            panic!("Fork was not derived from the advancing parse stream");
-        }
-
-        let (self_unexp, self_sp) = inner_unexpected(self);
-        let (fork_unexp, fork_sp) = inner_unexpected(fork);
-        if !Rc::ptr_eq(&self_unexp, &fork_unexp) {
-            match (fork_sp, self_sp) {
-                // Unexpected set on the fork, but not on `self`, copy it over.
-                (Some(span), None) => {
-                    self_unexp.set(Unexpected::Some(span));
-                }
-                // Unexpected unset. Use chain to propagate errors from fork.
-                (None, None) => {
-                    fork_unexp.set(Unexpected::Chain(self_unexp));
-
-                    // Ensure toplevel 'unexpected' tokens from the fork don't
-                    // bubble up the chain by replacing the root `unexpected`
-                    // pointer, only 'unexpected' tokens from existing group
-                    // parsers should bubble.
-                    fork.unexpected
-                        .set(Some(Rc::new(Cell::new(Unexpected::None))));
-                }
-                // Unexpected has been set on `self`. No changes needed.
-                (_, Some(_)) => {}
-            }
-        }
-
-        // See comment on `cell` in the struct definition.
-        self.cell
-            .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) });
-    }
-}
diff --git a/vendor/syn/src/error.rs b/vendor/syn/src/error.rs
deleted file mode 100644
index e2f23821..00000000
--- a/vendor/syn/src/error.rs
+++ /dev/null
@@ -1,412 +0,0 @@
-#[cfg(feature = "parsing")]
-use crate::buffer::Cursor;
-use crate::thread::ThreadBound;
-use proc_macro2::{
-    Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
-};
-#[cfg(feature = "printing")]
-use quote::ToTokens;
-use std::fmt::{self, Debug, Display};
-use std::iter::FromIterator;
-use std::slice;
-use std::vec;
-
-/// The result of a Syn parser.
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// Error returned when a Syn parser cannot parse the input tokens.
-///
-/// # Error reporting in proc macros
-///
-/// The correct way to report errors back to the compiler from a procedural
-/// macro is by emitting an appropriately spanned invocation of
-/// [`compile_error!`] in the generated code. This produces a better diagnostic
-/// message than simply panicking the macro.
-///
-/// [`compile_error!`]: std::compile_error!
-///
-/// When parsing macro input, the [`parse_macro_input!`] macro handles the
-/// conversion to `compile_error!` automatically.
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// use proc_macro::TokenStream;
-/// use syn::{parse_macro_input, AttributeArgs, ItemFn};
-///
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro_attribute]
-/// # };
-/// pub fn my_attr(args: TokenStream, input: TokenStream) -> TokenStream {
-///     let args = parse_macro_input!(args as AttributeArgs);
-///     let input = parse_macro_input!(input as ItemFn);
-///
-///     /* ... */
-///     # TokenStream::new()
-/// }
-/// ```
-///
-/// For errors that arise later than the initial parsing stage, the
-/// [`.to_compile_error()`] method can be used to perform an explicit conversion
-/// to `compile_error!`.
-///
-/// [`.to_compile_error()`]: Error::to_compile_error
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// # use proc_macro::TokenStream;
-/// # use syn::{parse_macro_input, DeriveInput};
-/// #
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro_derive(MyDerive)]
-/// # };
-/// pub fn my_derive(input: TokenStream) -> TokenStream {
-///     let input = parse_macro_input!(input as DeriveInput);
-///
-///     // fn(DeriveInput) -> syn::Result<proc_macro2::TokenStream>
-///     expand::my_derive(input)
-///         .unwrap_or_else(|err| err.to_compile_error())
-///         .into()
-/// }
-/// #
-/// # mod expand {
-/// #     use proc_macro2::TokenStream;
-/// #     use syn::{DeriveInput, Result};
-/// #
-/// #     pub fn my_derive(input: DeriveInput) -> Result<TokenStream> {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// ```
-pub struct Error {
-    messages: Vec<ErrorMessage>,
-}
-
-struct ErrorMessage {
-    // Span is implemented as an index into a thread-local interner to keep the
-    // size small. It is not safe to access from a different thread. We want
-    // errors to be Send and Sync to play nicely with the Failure crate, so pin
-    // the span we're given to its original thread and assume it is
-    // Span::call_site if accessed from any other thread.
-    start_span: ThreadBound<Span>,
-    end_span: ThreadBound<Span>,
-    message: String,
-}
-
-#[cfg(test)]
-struct _Test
-where
-    Error: Send + Sync;
-
-impl Error {
-    /// Usually the [`ParseStream::error`] method will be used instead, which
-    /// automatically uses the correct span from the current position of the
-    /// parse stream.
-    ///
-    /// Use `Error::new` when the error needs to be triggered on some span other
-    /// than where the parse stream is currently positioned.
-    ///
-    /// [`ParseStream::error`]: crate::parse::ParseBuffer::error
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{Error, Ident, LitStr, Result, Token};
-    /// use syn::parse::ParseStream;
-    ///
-    /// // Parses input that looks like `name = "string"` where the key must be
-    /// // the identifier `name` and the value may be any string literal.
-    /// // Returns the string literal.
-    /// fn parse_name(input: ParseStream) -> Result<LitStr> {
-    ///     let name_token: Ident = input.parse()?;
-    ///     if name_token != "name" {
-    ///         // Trigger an error not on the current position of the stream,
-    ///         // but on the position of the unexpected identifier.
-    ///         return Err(Error::new(name_token.span(), "expected `name`"));
-    ///     }
-    ///     input.parse::<Token![=]>()?;
-    ///     let s: LitStr = input.parse()?;
-    ///     Ok(s)
-    /// }
-    /// ```
-    pub fn new<T: Display>(span: Span, message: T) -> Self {
-        Error {
-            messages: vec![ErrorMessage {
-                start_span: ThreadBound::new(span),
-                end_span: ThreadBound::new(span),
-                message: message.to_string(),
-            }],
-        }
-    }
-
-    /// Creates an error with the specified message spanning the given syntax
-    /// tree node.
-    ///
-    /// Unlike the `Error::new` constructor, this constructor takes an argument
-    /// `tokens` which is a syntax tree node. This allows the resulting `Error`
-    /// to attempt to span all tokens inside of `tokens`. While you would
-    /// typically be able to use the `Spanned` trait with the above `Error::new`
-    /// constructor, implementation limitations today mean that
-    /// `Error::new_spanned` may provide a higher-quality error message on
-    /// stable Rust.
-    ///
-    /// When in doubt it's recommended to stick to `Error::new` (or
-    /// `ParseStream::error`)!
-    #[cfg(feature = "printing")]
-    pub fn new_spanned<T: ToTokens, U: Display>(tokens: T, message: U) -> Self {
-        let mut iter = tokens.into_token_stream().into_iter();
-        let start = iter.next().map_or_else(Span::call_site, |t| t.span());
-        let end = iter.last().map_or(start, |t| t.span());
-        Error {
-            messages: vec![ErrorMessage {
-                start_span: ThreadBound::new(start),
-                end_span: ThreadBound::new(end),
-                message: message.to_string(),
-            }],
-        }
-    }
-
-    /// The source location of the error.
-    ///
-    /// Spans are not thread-safe so this function returns `Span::call_site()`
-    /// if called from a different thread than the one on which the `Error` was
-    /// originally created.
-    pub fn span(&self) -> Span {
-        let start = match self.messages[0].start_span.get() {
-            Some(span) => *span,
-            None => return Span::call_site(),
-        };
-        let end = match self.messages[0].end_span.get() {
-            Some(span) => *span,
-            None => return Span::call_site(),
-        };
-        start.join(end).unwrap_or(start)
-    }
-
-    /// Render the error as an invocation of [`compile_error!`].
-    ///
-    /// The [`parse_macro_input!`] macro provides a convenient way to invoke
-    /// this method correctly in a procedural macro.
-    ///
-    /// [`compile_error!`]: std::compile_error!
-    pub fn to_compile_error(&self) -> TokenStream {
-        self.messages
-            .iter()
-            .map(ErrorMessage::to_compile_error)
-            .collect()
-    }
-
-    /// Render the error as an invocation of [`compile_error!`].
-    ///
-    /// [`compile_error!`]: std::compile_error!
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # extern crate proc_macro;
-    /// #
-    /// use proc_macro::TokenStream;
-    /// use syn::{parse_macro_input, DeriveInput, Error};
-    ///
-    /// # const _: &str = stringify! {
-    /// #[proc_macro_derive(MyTrait)]
-    /// # };
-    /// pub fn derive_my_trait(input: TokenStream) -> TokenStream {
-    ///     let input = parse_macro_input!(input as DeriveInput);
-    ///     my_trait::expand(input)
-    ///         .unwrap_or_else(Error::into_compile_error)
-    ///         .into()
-    /// }
-    ///
-    /// mod my_trait {
-    ///     use proc_macro2::TokenStream;
-    ///     use syn::{DeriveInput, Result};
-    ///
-    ///     pub(crate) fn expand(input: DeriveInput) -> Result<TokenStream> {
-    ///         /* ... */
-    ///         # unimplemented!()
-    ///     }
-    /// }
-    /// ```
-    pub fn into_compile_error(self) -> TokenStream {
-        self.to_compile_error()
-    }
-
-    /// Add another error message to self such that when `to_compile_error()` is
-    /// called, both errors will be emitted together.
-    pub fn combine(&mut self, another: Error) {
-        self.messages.extend(another.messages);
-    }
-}
-
-impl ErrorMessage {
-    fn to_compile_error(&self) -> TokenStream {
-        let start = self
-            .start_span
-            .get()
-            .cloned()
-            .unwrap_or_else(Span::call_site);
-        let end = self.end_span.get().cloned().unwrap_or_else(Span::call_site);
-
-        // compile_error!($message)
-        TokenStream::from_iter(vec![
-            TokenTree::Ident(Ident::new("compile_error", start)),
-            TokenTree::Punct({
-                let mut punct = Punct::new('!', Spacing::Alone);
-                punct.set_span(start);
-                punct
-            }),
-            TokenTree::Group({
-                let mut group = Group::new(Delimiter::Brace, {
-                    TokenStream::from_iter(vec![TokenTree::Literal({
-                        let mut string = Literal::string(&self.message);
-                        string.set_span(end);
-                        string
-                    })])
-                });
-                group.set_span(end);
-                group
-            }),
-        ])
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub fn new_at<T: Display>(scope: Span, cursor: Cursor, message: T) -> Error {
-    if cursor.eof() {
-        Error::new(scope, format!("unexpected end of input, {}", message))
-    } else {
-        let span = crate::buffer::open_span_of_group(cursor);
-        Error::new(span, message)
-    }
-}
-
-#[cfg(all(feature = "parsing", any(feature = "full", feature = "derive")))]
-pub fn new2<T: Display>(start: Span, end: Span, message: T) -> Error {
-    Error {
-        messages: vec![ErrorMessage {
-            start_span: ThreadBound::new(start),
-            end_span: ThreadBound::new(end),
-            message: message.to_string(),
-        }],
-    }
-}
-
-impl Debug for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        if self.messages.len() == 1 {
-            formatter
-                .debug_tuple("Error")
-                .field(&self.messages[0])
-                .finish()
-        } else {
-            formatter
-                .debug_tuple("Error")
-                .field(&self.messages)
-                .finish()
-        }
-    }
-}
-
-impl Debug for ErrorMessage {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.message, formatter)
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(&self.messages[0].message)
-    }
-}
-
-impl Clone for Error {
-    fn clone(&self) -> Self {
-        Error {
-            messages: self.messages.clone(),
-        }
-    }
-}
-
-impl Clone for ErrorMessage {
-    fn clone(&self) -> Self {
-        let start = self
-            .start_span
-            .get()
-            .cloned()
-            .unwrap_or_else(Span::call_site);
-        let end = self.end_span.get().cloned().unwrap_or_else(Span::call_site);
-        ErrorMessage {
-            start_span: ThreadBound::new(start),
-            end_span: ThreadBound::new(end),
-            message: self.message.clone(),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
-
-impl From<LexError> for Error {
-    fn from(err: LexError) -> Self {
-        Error::new(err.span(), "lex error")
-    }
-}
-
-impl IntoIterator for Error {
-    type Item = Error;
-    type IntoIter = IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter {
-            messages: self.messages.into_iter(),
-        }
-    }
-}
-
-pub struct IntoIter {
-    messages: vec::IntoIter<ErrorMessage>,
-}
-
-impl Iterator for IntoIter {
-    type Item = Error;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        Some(Error {
-            messages: vec![self.messages.next()?],
-        })
-    }
-}
-
-impl<'a> IntoIterator for &'a Error {
-    type Item = Error;
-    type IntoIter = Iter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Iter {
-            messages: self.messages.iter(),
-        }
-    }
-}
-
-pub struct Iter<'a> {
-    messages: slice::Iter<'a, ErrorMessage>,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = Error;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        Some(Error {
-            messages: vec![self.messages.next()?.clone()],
-        })
-    }
-}
-
-impl Extend<Error> for Error {
-    fn extend<T: IntoIterator<Item = Error>>(&mut self, iter: T) {
-        for err in iter {
-            self.combine(err);
-        }
-    }
-}
diff --git a/vendor/syn/src/export.rs b/vendor/syn/src/export.rs
deleted file mode 100644
index 601a214b..00000000
--- a/vendor/syn/src/export.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-pub use std::clone::Clone;
-pub use std::cmp::{Eq, PartialEq};
-pub use std::convert::From;
-pub use std::default::Default;
-pub use std::fmt::{self, Debug, Formatter};
-pub use std::hash::{Hash, Hasher};
-pub use std::marker::Copy;
-pub use std::option::Option::{None, Some};
-pub use std::result::Result::{Err, Ok};
-
-#[cfg(feature = "printing")]
-pub extern crate quote;
-
-pub use proc_macro2::{Span, TokenStream as TokenStream2};
-
-pub use crate::span::IntoSpans;
-
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "proc-macro"
-))]
-pub use proc_macro::TokenStream;
-
-#[cfg(feature = "printing")]
-pub use quote::{ToTokens, TokenStreamExt};
-
-#[allow(non_camel_case_types)]
-pub type bool = help::Bool;
-#[allow(non_camel_case_types)]
-pub type str = help::Str;
-
-mod help {
-    pub type Bool = bool;
-    pub type Str = str;
-}
-
-pub struct private(pub(crate) ());
diff --git a/vendor/syn/src/expr.rs b/vendor/syn/src/expr.rs
deleted file mode 100644
index 24f79117..00000000
--- a/vendor/syn/src/expr.rs
+++ /dev/null
@@ -1,3497 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-#[cfg(feature = "full")]
-use crate::reserved::Reserved;
-use proc_macro2::{Span, TokenStream};
-#[cfg(feature = "printing")]
-use quote::IdentFragment;
-#[cfg(feature = "printing")]
-use std::fmt::{self, Display};
-use std::hash::{Hash, Hasher};
-#[cfg(feature = "parsing")]
-use std::mem;
-
-ast_enum_of_structs! {
-    /// A Rust expression.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature, but most of the variants are not available unless "full" is enabled.*
-    ///
-    /// # Syntax tree enums
-    ///
-    /// This type is a syntax tree enum. In Syn this and other syntax tree enums
-    /// are designed to be traversed using the following rebinding idiom.
-    ///
-    /// ```
-    /// # use syn::Expr;
-    /// #
-    /// # fn example(expr: Expr) {
-    /// # const IGNORE: &str = stringify! {
-    /// let expr: Expr = /* ... */;
-    /// # };
-    /// match expr {
-    ///     Expr::MethodCall(expr) => {
-    ///         /* ... */
-    ///     }
-    ///     Expr::Cast(expr) => {
-    ///         /* ... */
-    ///     }
-    ///     Expr::If(expr) => {
-    ///         /* ... */
-    ///     }
-    ///
-    ///     /* ... */
-    ///     # _ => {}
-    /// # }
-    /// # }
-    /// ```
-    ///
-    /// We begin with a variable `expr` of type `Expr` that has no fields
-    /// (because it is an enum), and by matching on it and rebinding a variable
-    /// with the same name `expr` we effectively imbue our variable with all of
-    /// the data fields provided by the variant that it turned out to be. So for
-    /// example above if we ended up in the `MethodCall` case then we get to use
-    /// `expr.receiver`, `expr.args` etc; if we ended up in the `If` case we get
-    /// to use `expr.cond`, `expr.then_branch`, `expr.else_branch`.
-    ///
-    /// This approach avoids repeating the variant names twice on every line.
-    ///
-    /// ```
-    /// # use syn::{Expr, ExprMethodCall};
-    /// #
-    /// # fn example(expr: Expr) {
-    /// // Repetitive; recommend not doing this.
-    /// match expr {
-    ///     Expr::MethodCall(ExprMethodCall { method, args, .. }) => {
-    /// # }
-    /// # _ => {}
-    /// # }
-    /// # }
-    /// ```
-    ///
-    /// In general, the name to which a syntax tree enum variant is bound should
-    /// be a suitable name for the complete syntax tree enum type.
-    ///
-    /// ```
-    /// # use syn::{Expr, ExprField};
-    /// #
-    /// # fn example(discriminant: ExprField) {
-    /// // Binding is called `base` which is the name I would use if I were
-    /// // assigning `*discriminant.base` without an `if let`.
-    /// if let Expr::Tuple(base) = *discriminant.base {
-    /// # }
-    /// # }
-    /// ```
-    ///
-    /// A sign that you may not be choosing the right variable names is if you
-    /// see names getting repeated in your code, like accessing
-    /// `receiver.receiver` or `pat.pat` or `cond.cond`.
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Expr {
-        /// A slice literal expression: `[a, b, c, d]`.
-        Array(ExprArray),
-
-        /// An assignment expression: `a = compute()`.
-        Assign(ExprAssign),
-
-        /// A compound assignment expression: `counter += 1`.
-        AssignOp(ExprAssignOp),
-
-        /// An async block: `async { ... }`.
-        Async(ExprAsync),
-
-        /// An await expression: `fut.await`.
-        Await(ExprAwait),
-
-        /// A binary operation: `a + b`, `a * b`.
-        Binary(ExprBinary),
-
-        /// A blocked scope: `{ ... }`.
-        Block(ExprBlock),
-
-        /// A box expression: `box f`.
-        Box(ExprBox),
-
-        /// A `break`, with an optional label to break and an optional
-        /// expression.
-        Break(ExprBreak),
-
-        /// A function call expression: `invoke(a, b)`.
-        Call(ExprCall),
-
-        /// A cast expression: `foo as f64`.
-        Cast(ExprCast),
-
-        /// A closure expression: `|a, b| a + b`.
-        Closure(ExprClosure),
-
-        /// A `continue`, with an optional label.
-        Continue(ExprContinue),
-
-        /// Access of a named struct field (`obj.k`) or unnamed tuple struct
-        /// field (`obj.0`).
-        Field(ExprField),
-
-        /// A for loop: `for pat in expr { ... }`.
-        ForLoop(ExprForLoop),
-
-        /// An expression contained within invisible delimiters.
-        ///
-        /// This variant is important for faithfully representing the precedence
-        /// of expressions and is related to `None`-delimited spans in a
-        /// `TokenStream`.
-        Group(ExprGroup),
-
-        /// An `if` expression with an optional `else` block: `if expr { ... }
-        /// else { ... }`.
-        ///
-        /// The `else` branch expression may only be an `If` or `Block`
-        /// expression, not any of the other types of expression.
-        If(ExprIf),
-
-        /// A square bracketed indexing expression: `vector[2]`.
-        Index(ExprIndex),
-
-        /// A `let` guard: `let Some(x) = opt`.
-        Let(ExprLet),
-
-        /// A literal in place of an expression: `1`, `"foo"`.
-        Lit(ExprLit),
-
-        /// Conditionless loop: `loop { ... }`.
-        Loop(ExprLoop),
-
-        /// A macro invocation expression: `format!("{}", q)`.
-        Macro(ExprMacro),
-
-        /// A `match` expression: `match n { Some(n) => {}, None => {} }`.
-        Match(ExprMatch),
-
-        /// A method call expression: `x.foo::<T>(a, b)`.
-        MethodCall(ExprMethodCall),
-
-        /// A parenthesized expression: `(a + b)`.
-        Paren(ExprParen),
-
-        /// A path like `std::mem::replace` possibly containing generic
-        /// parameters and a qualified self-type.
-        ///
-        /// A plain identifier like `x` is a path of length 1.
-        Path(ExprPath),
-
-        /// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
-        Range(ExprRange),
-
-        /// A referencing operation: `&a` or `&mut a`.
-        Reference(ExprReference),
-
-        /// An array literal constructed from one repeated element: `[0u8; N]`.
-        Repeat(ExprRepeat),
-
-        /// A `return`, with an optional value to be returned.
-        Return(ExprReturn),
-
-        /// A struct literal expression: `Point { x: 1, y: 1 }`.
-        ///
-        /// The `rest` provides the value of the remaining fields as in `S { a:
-        /// 1, b: 1, ..rest }`.
-        Struct(ExprStruct),
-
-        /// A try-expression: `expr?`.
-        Try(ExprTry),
-
-        /// A try block: `try { ... }`.
-        TryBlock(ExprTryBlock),
-
-        /// A tuple expression: `(a, b, c, d)`.
-        Tuple(ExprTuple),
-
-        /// A type ascription expression: `foo: f64`.
-        Type(ExprType),
-
-        /// A unary operation: `!x`, `*x`.
-        Unary(ExprUnary),
-
-        /// An unsafe block: `unsafe { ... }`.
-        Unsafe(ExprUnsafe),
-
-        /// Tokens in expression position not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        /// A while loop: `while expr { ... }`.
-        While(ExprWhile),
-
-        /// A yield expression: `yield expr`.
-        Yield(ExprYield),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         Expr::Array(e) => {...}
-        //         Expr::Assign(e) => {...}
-        //         ...
-        //         Expr::Yield(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         Expr::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, Expr will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// A slice literal expression: `[a, b, c, d]`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprArray #full {
-        pub attrs: Vec<Attribute>,
-        pub bracket_token: token::Bracket,
-        pub elems: Punctuated<Expr, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// An assignment expression: `a = compute()`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprAssign #full {
-        pub attrs: Vec<Attribute>,
-        pub left: Box<Expr>,
-        pub eq_token: Token![=],
-        pub right: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A compound assignment expression: `counter += 1`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprAssignOp #full {
-        pub attrs: Vec<Attribute>,
-        pub left: Box<Expr>,
-        pub op: BinOp,
-        pub right: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// An async block: `async { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprAsync #full {
-        pub attrs: Vec<Attribute>,
-        pub async_token: Token![async],
-        pub capture: Option<Token![move]>,
-        pub block: Block,
-    }
-}
-
-ast_struct! {
-    /// An await expression: `fut.await`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprAwait #full {
-        pub attrs: Vec<Attribute>,
-        pub base: Box<Expr>,
-        pub dot_token: Token![.],
-        pub await_token: token::Await,
-    }
-}
-
-ast_struct! {
-    /// A binary operation: `a + b`, `a * b`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprBinary {
-        pub attrs: Vec<Attribute>,
-        pub left: Box<Expr>,
-        pub op: BinOp,
-        pub right: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A blocked scope: `{ ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprBlock #full {
-        pub attrs: Vec<Attribute>,
-        pub label: Option<Label>,
-        pub block: Block,
-    }
-}
-
-ast_struct! {
-    /// A box expression: `box f`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprBox #full {
-        pub attrs: Vec<Attribute>,
-        pub box_token: Token![box],
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A `break`, with an optional label to break and an optional
-    /// expression.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprBreak #full {
-        pub attrs: Vec<Attribute>,
-        pub break_token: Token![break],
-        pub label: Option<Lifetime>,
-        pub expr: Option<Box<Expr>>,
-    }
-}
-
-ast_struct! {
-    /// A function call expression: `invoke(a, b)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprCall {
-        pub attrs: Vec<Attribute>,
-        pub func: Box<Expr>,
-        pub paren_token: token::Paren,
-        pub args: Punctuated<Expr, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A cast expression: `foo as f64`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprCast {
-        pub attrs: Vec<Attribute>,
-        pub expr: Box<Expr>,
-        pub as_token: Token![as],
-        pub ty: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A closure expression: `|a, b| a + b`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprClosure #full {
-        pub attrs: Vec<Attribute>,
-        pub asyncness: Option<Token![async]>,
-        pub movability: Option<Token![static]>,
-        pub capture: Option<Token![move]>,
-        pub or1_token: Token![|],
-        pub inputs: Punctuated<Pat, Token![,]>,
-        pub or2_token: Token![|],
-        pub output: ReturnType,
-        pub body: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A `continue`, with an optional label.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprContinue #full {
-        pub attrs: Vec<Attribute>,
-        pub continue_token: Token![continue],
-        pub label: Option<Lifetime>,
-    }
-}
-
-ast_struct! {
-    /// Access of a named struct field (`obj.k`) or unnamed tuple struct
-    /// field (`obj.0`).
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprField {
-        pub attrs: Vec<Attribute>,
-        pub base: Box<Expr>,
-        pub dot_token: Token![.],
-        pub member: Member,
-    }
-}
-
-ast_struct! {
-    /// A for loop: `for pat in expr { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprForLoop #full {
-        pub attrs: Vec<Attribute>,
-        pub label: Option<Label>,
-        pub for_token: Token![for],
-        pub pat: Pat,
-        pub in_token: Token![in],
-        pub expr: Box<Expr>,
-        pub body: Block,
-    }
-}
-
-ast_struct! {
-    /// An expression contained within invisible delimiters.
-    ///
-    /// This variant is important for faithfully representing the precedence
-    /// of expressions and is related to `None`-delimited spans in a
-    /// `TokenStream`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprGroup #full {
-        pub attrs: Vec<Attribute>,
-        pub group_token: token::Group,
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// An `if` expression with an optional `else` block: `if expr { ... }
-    /// else { ... }`.
-    ///
-    /// The `else` branch expression may only be an `If` or `Block`
-    /// expression, not any of the other types of expression.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprIf #full {
-        pub attrs: Vec<Attribute>,
-        pub if_token: Token![if],
-        pub cond: Box<Expr>,
-        pub then_branch: Block,
-        pub else_branch: Option<(Token![else], Box<Expr>)>,
-    }
-}
-
-ast_struct! {
-    /// A square bracketed indexing expression: `vector[2]`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprIndex {
-        pub attrs: Vec<Attribute>,
-        pub expr: Box<Expr>,
-        pub bracket_token: token::Bracket,
-        pub index: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A `let` guard: `let Some(x) = opt`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprLet #full {
-        pub attrs: Vec<Attribute>,
-        pub let_token: Token![let],
-        pub pat: Pat,
-        pub eq_token: Token![=],
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A literal in place of an expression: `1`, `"foo"`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprLit {
-        pub attrs: Vec<Attribute>,
-        pub lit: Lit,
-    }
-}
-
-ast_struct! {
-    /// Conditionless loop: `loop { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprLoop #full {
-        pub attrs: Vec<Attribute>,
-        pub label: Option<Label>,
-        pub loop_token: Token![loop],
-        pub body: Block,
-    }
-}
-
-ast_struct! {
-    /// A macro invocation expression: `format!("{}", q)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprMacro #full {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-    }
-}
-
-ast_struct! {
-    /// A `match` expression: `match n { Some(n) => {}, None => {} }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprMatch #full {
-        pub attrs: Vec<Attribute>,
-        pub match_token: Token![match],
-        pub expr: Box<Expr>,
-        pub brace_token: token::Brace,
-        pub arms: Vec<Arm>,
-    }
-}
-
-ast_struct! {
-    /// A method call expression: `x.foo::<T>(a, b)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprMethodCall #full {
-        pub attrs: Vec<Attribute>,
-        pub receiver: Box<Expr>,
-        pub dot_token: Token![.],
-        pub method: Ident,
-        pub turbofish: Option<MethodTurbofish>,
-        pub paren_token: token::Paren,
-        pub args: Punctuated<Expr, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A parenthesized expression: `(a + b)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprParen {
-        pub attrs: Vec<Attribute>,
-        pub paren_token: token::Paren,
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A path like `std::mem::replace` possibly containing generic
-    /// parameters and a qualified self-type.
-    ///
-    /// A plain identifier like `x` is a path of length 1.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprPath {
-        pub attrs: Vec<Attribute>,
-        pub qself: Option<QSelf>,
-        pub path: Path,
-    }
-}
-
-ast_struct! {
-    /// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprRange #full {
-        pub attrs: Vec<Attribute>,
-        pub from: Option<Box<Expr>>,
-        pub limits: RangeLimits,
-        pub to: Option<Box<Expr>>,
-    }
-}
-
-ast_struct! {
-    /// A referencing operation: `&a` or `&mut a`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprReference #full {
-        pub attrs: Vec<Attribute>,
-        pub and_token: Token![&],
-        pub raw: Reserved,
-        pub mutability: Option<Token![mut]>,
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// An array literal constructed from one repeated element: `[0u8; N]`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprRepeat #full {
-        pub attrs: Vec<Attribute>,
-        pub bracket_token: token::Bracket,
-        pub expr: Box<Expr>,
-        pub semi_token: Token![;],
-        pub len: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A `return`, with an optional value to be returned.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprReturn #full {
-        pub attrs: Vec<Attribute>,
-        pub return_token: Token![return],
-        pub expr: Option<Box<Expr>>,
-    }
-}
-
-ast_struct! {
-    /// A struct literal expression: `Point { x: 1, y: 1 }`.
-    ///
-    /// The `rest` provides the value of the remaining fields as in `S { a:
-    /// 1, b: 1, ..rest }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprStruct #full {
-        pub attrs: Vec<Attribute>,
-        pub path: Path,
-        pub brace_token: token::Brace,
-        pub fields: Punctuated<FieldValue, Token![,]>,
-        pub dot2_token: Option<Token![..]>,
-        pub rest: Option<Box<Expr>>,
-    }
-}
-
-ast_struct! {
-    /// A try-expression: `expr?`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprTry #full {
-        pub attrs: Vec<Attribute>,
-        pub expr: Box<Expr>,
-        pub question_token: Token![?],
-    }
-}
-
-ast_struct! {
-    /// A try block: `try { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprTryBlock #full {
-        pub attrs: Vec<Attribute>,
-        pub try_token: Token![try],
-        pub block: Block,
-    }
-}
-
-ast_struct! {
-    /// A tuple expression: `(a, b, c, d)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprTuple #full {
-        pub attrs: Vec<Attribute>,
-        pub paren_token: token::Paren,
-        pub elems: Punctuated<Expr, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A type ascription expression: `foo: f64`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprType #full {
-        pub attrs: Vec<Attribute>,
-        pub expr: Box<Expr>,
-        pub colon_token: Token![:],
-        pub ty: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A unary operation: `!x`, `*x`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ExprUnary {
-        pub attrs: Vec<Attribute>,
-        pub op: UnOp,
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// An unsafe block: `unsafe { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprUnsafe #full {
-        pub attrs: Vec<Attribute>,
-        pub unsafe_token: Token![unsafe],
-        pub block: Block,
-    }
-}
-
-ast_struct! {
-    /// A while loop: `while expr { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprWhile #full {
-        pub attrs: Vec<Attribute>,
-        pub label: Option<Label>,
-        pub while_token: Token![while],
-        pub cond: Box<Expr>,
-        pub body: Block,
-    }
-}
-
-ast_struct! {
-    /// A yield expression: `yield expr`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ExprYield #full {
-        pub attrs: Vec<Attribute>,
-        pub yield_token: Token![yield],
-        pub expr: Option<Box<Expr>>,
-    }
-}
-
-impl Expr {
-    #[cfg(all(feature = "parsing", feature = "full"))]
-    pub(crate) fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> {
-        match self {
-            Expr::Box(ExprBox { attrs, .. })
-            | Expr::Array(ExprArray { attrs, .. })
-            | Expr::Call(ExprCall { attrs, .. })
-            | Expr::MethodCall(ExprMethodCall { attrs, .. })
-            | Expr::Tuple(ExprTuple { attrs, .. })
-            | Expr::Binary(ExprBinary { attrs, .. })
-            | Expr::Unary(ExprUnary { attrs, .. })
-            | Expr::Lit(ExprLit { attrs, .. })
-            | Expr::Cast(ExprCast { attrs, .. })
-            | Expr::Type(ExprType { attrs, .. })
-            | Expr::Let(ExprLet { attrs, .. })
-            | Expr::If(ExprIf { attrs, .. })
-            | Expr::While(ExprWhile { attrs, .. })
-            | Expr::ForLoop(ExprForLoop { attrs, .. })
-            | Expr::Loop(ExprLoop { attrs, .. })
-            | Expr::Match(ExprMatch { attrs, .. })
-            | Expr::Closure(ExprClosure { attrs, .. })
-            | Expr::Unsafe(ExprUnsafe { attrs, .. })
-            | Expr::Block(ExprBlock { attrs, .. })
-            | Expr::Assign(ExprAssign { attrs, .. })
-            | Expr::AssignOp(ExprAssignOp { attrs, .. })
-            | Expr::Field(ExprField { attrs, .. })
-            | Expr::Index(ExprIndex { attrs, .. })
-            | Expr::Range(ExprRange { attrs, .. })
-            | Expr::Path(ExprPath { attrs, .. })
-            | Expr::Reference(ExprReference { attrs, .. })
-            | Expr::Break(ExprBreak { attrs, .. })
-            | Expr::Continue(ExprContinue { attrs, .. })
-            | Expr::Return(ExprReturn { attrs, .. })
-            | Expr::Macro(ExprMacro { attrs, .. })
-            | Expr::Struct(ExprStruct { attrs, .. })
-            | Expr::Repeat(ExprRepeat { attrs, .. })
-            | Expr::Paren(ExprParen { attrs, .. })
-            | Expr::Group(ExprGroup { attrs, .. })
-            | Expr::Try(ExprTry { attrs, .. })
-            | Expr::Async(ExprAsync { attrs, .. })
-            | Expr::Await(ExprAwait { attrs, .. })
-            | Expr::TryBlock(ExprTryBlock { attrs, .. })
-            | Expr::Yield(ExprYield { attrs, .. }) => mem::replace(attrs, new),
-            Expr::Verbatim(_) => Vec::new(),
-
-            #[cfg(test)]
-            Expr::__TestExhaustive(_) => unimplemented!(),
-            #[cfg(not(test))]
-            _ => unreachable!(),
-        }
-    }
-}
-
-ast_enum! {
-    /// A struct or tuple struct field accessed in a struct literal or field
-    /// expression.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Member {
-        /// A named field like `self.x`.
-        Named(Ident),
-        /// An unnamed field like `self.0`.
-        Unnamed(Index),
-    }
-}
-
-impl From<Ident> for Member {
-    fn from(ident: Ident) -> Member {
-        Member::Named(ident)
-    }
-}
-
-impl From<Index> for Member {
-    fn from(index: Index) -> Member {
-        Member::Unnamed(index)
-    }
-}
-
-impl From<usize> for Member {
-    fn from(index: usize) -> Member {
-        Member::Unnamed(Index::from(index))
-    }
-}
-
-impl Eq for Member {}
-
-impl PartialEq for Member {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Member::Named(this), Member::Named(other)) => this == other,
-            (Member::Unnamed(this), Member::Unnamed(other)) => this == other,
-            _ => false,
-        }
-    }
-}
-
-impl Hash for Member {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        match self {
-            Member::Named(m) => m.hash(state),
-            Member::Unnamed(m) => m.hash(state),
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-impl IdentFragment for Member {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Member::Named(m) => Display::fmt(m, formatter),
-            Member::Unnamed(m) => Display::fmt(&m.index, formatter),
-        }
-    }
-
-    fn span(&self) -> Option<Span> {
-        match self {
-            Member::Named(m) => Some(m.span()),
-            Member::Unnamed(m) => Some(m.span),
-        }
-    }
-}
-
-ast_struct! {
-    /// The index of an unnamed tuple struct field.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Index {
-        pub index: u32,
-        pub span: Span,
-    }
-}
-
-impl From<usize> for Index {
-    fn from(index: usize) -> Index {
-        assert!(index < u32::max_value() as usize);
-        Index {
-            index: index as u32,
-            span: Span::call_site(),
-        }
-    }
-}
-
-impl Eq for Index {}
-
-impl PartialEq for Index {
-    fn eq(&self, other: &Self) -> bool {
-        self.index == other.index
-    }
-}
-
-impl Hash for Index {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.index.hash(state);
-    }
-}
-
-#[cfg(feature = "printing")]
-impl IdentFragment for Index {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.index, formatter)
-    }
-
-    fn span(&self) -> Option<Span> {
-        Some(self.span)
-    }
-}
-
-#[cfg(feature = "full")]
-ast_struct! {
-    /// The `::<>` explicit type parameters passed to a method call:
-    /// `parse::<u64>()`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct MethodTurbofish {
-        pub colon2_token: Token![::],
-        pub lt_token: Token![<],
-        pub args: Punctuated<GenericMethodArgument, Token![,]>,
-        pub gt_token: Token![>],
-    }
-}
-
-#[cfg(feature = "full")]
-ast_enum! {
-    /// An individual generic argument to a method, like `T`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum GenericMethodArgument {
-        /// A type argument.
-        Type(Type),
-        /// A const expression. Must be inside of a block.
-        ///
-        /// NOTE: Identity expressions are represented as Type arguments, as
-        /// they are indistinguishable syntactically.
-        Const(Expr),
-    }
-}
-
-#[cfg(feature = "full")]
-ast_struct! {
-    /// A field-value pair in a struct literal.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct FieldValue {
-        /// Attributes tagged on the field.
-        pub attrs: Vec<Attribute>,
-
-        /// Name or index of the field.
-        pub member: Member,
-
-        /// The colon in `Struct { x: x }`. If written in shorthand like
-        /// `Struct { x }`, there is no colon.
-        pub colon_token: Option<Token![:]>,
-
-        /// Value of the field.
-        pub expr: Expr,
-    }
-}
-
-#[cfg(feature = "full")]
-ast_struct! {
-    /// A lifetime labeling a `for`, `while`, or `loop`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Label {
-        pub name: Lifetime,
-        pub colon_token: Token![:],
-    }
-}
-
-#[cfg(feature = "full")]
-ast_struct! {
-    /// One arm of a `match` expression: `0...10 => { return true; }`.
-    ///
-    /// As in:
-    ///
-    /// ```
-    /// # fn f() -> bool {
-    /// #     let n = 0;
-    /// match n {
-    ///     0...10 => {
-    ///         return true;
-    ///     }
-    ///     // ...
-    ///     # _ => {}
-    /// }
-    /// #   false
-    /// # }
-    /// ```
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Arm {
-        pub attrs: Vec<Attribute>,
-        pub pat: Pat,
-        pub guard: Option<(Token![if], Box<Expr>)>,
-        pub fat_arrow_token: Token![=>],
-        pub body: Box<Expr>,
-        pub comma: Option<Token![,]>,
-    }
-}
-
-#[cfg(feature = "full")]
-ast_enum! {
-    /// Limit types of a range, inclusive or exclusive.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum RangeLimits {
-        /// Inclusive at the beginning, exclusive at the end.
-        HalfOpen(Token![..]),
-        /// Inclusive at the beginning and end.
-        Closed(Token![..=]),
-    }
-}
-
-#[cfg(any(feature = "parsing", feature = "printing"))]
-#[cfg(feature = "full")]
-pub(crate) fn requires_terminator(expr: &Expr) -> bool {
-    // see https://github.com/rust-lang/rust/blob/2679c38fc/src/librustc_ast/util/classify.rs#L7-L25
-    match *expr {
-        Expr::Unsafe(..)
-        | Expr::Block(..)
-        | Expr::If(..)
-        | Expr::Match(..)
-        | Expr::While(..)
-        | Expr::Loop(..)
-        | Expr::ForLoop(..)
-        | Expr::Async(..)
-        | Expr::TryBlock(..) => false,
-        _ => true,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub(crate) mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-    use crate::path;
-    #[cfg(feature = "full")]
-    use proc_macro2::TokenTree;
-    use std::cmp::Ordering;
-
-    crate::custom_keyword!(raw);
-
-    // When we're parsing expressions which occur before blocks, like in an if
-    // statement's condition, we cannot parse a struct literal.
-    //
-    // Struct literals are ambiguous in certain positions
-    // https://github.com/rust-lang/rfcs/pull/92
-    pub struct AllowStruct(bool);
-
-    enum Precedence {
-        Any,
-        Assign,
-        Range,
-        Or,
-        And,
-        Compare,
-        BitOr,
-        BitXor,
-        BitAnd,
-        Shift,
-        Arithmetic,
-        Term,
-        Cast,
-    }
-
-    impl Precedence {
-        fn of(op: &BinOp) -> Self {
-            match *op {
-                BinOp::Add(_) | BinOp::Sub(_) => Precedence::Arithmetic,
-                BinOp::Mul(_) | BinOp::Div(_) | BinOp::Rem(_) => Precedence::Term,
-                BinOp::And(_) => Precedence::And,
-                BinOp::Or(_) => Precedence::Or,
-                BinOp::BitXor(_) => Precedence::BitXor,
-                BinOp::BitAnd(_) => Precedence::BitAnd,
-                BinOp::BitOr(_) => Precedence::BitOr,
-                BinOp::Shl(_) | BinOp::Shr(_) => Precedence::Shift,
-                BinOp::Eq(_)
-                | BinOp::Lt(_)
-                | BinOp::Le(_)
-                | BinOp::Ne(_)
-                | BinOp::Ge(_)
-                | BinOp::Gt(_) => Precedence::Compare,
-                BinOp::AddEq(_)
-                | BinOp::SubEq(_)
-                | BinOp::MulEq(_)
-                | BinOp::DivEq(_)
-                | BinOp::RemEq(_)
-                | BinOp::BitXorEq(_)
-                | BinOp::BitAndEq(_)
-                | BinOp::BitOrEq(_)
-                | BinOp::ShlEq(_)
-                | BinOp::ShrEq(_) => Precedence::Assign,
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Expr {
-        fn parse(input: ParseStream) -> Result<Self> {
-            ambiguous_expr(input, AllowStruct(true))
-        }
-    }
-
-    impl Expr {
-        /// An alternative to the primary `Expr::parse` parser (from the
-        /// [`Parse`] trait) for ambiguous syntactic positions in which a
-        /// trailing brace should not be taken as part of the expression.
-        ///
-        /// Rust grammar has an ambiguity where braces sometimes turn a path
-        /// expression into a struct initialization and sometimes do not. In the
-        /// following code, the expression `S {}` is one expression. Presumably
-        /// there is an empty struct `struct S {}` defined somewhere which it is
-        /// instantiating.
-        ///
-        /// ```
-        /// # struct S;
-        /// # impl std::ops::Deref for S {
-        /// #     type Target = bool;
-        /// #     fn deref(&self) -> &Self::Target {
-        /// #         &true
-        /// #     }
-        /// # }
-        /// let _ = *S {};
-        ///
-        /// // parsed by rustc as: `*(S {})`
-        /// ```
-        ///
-        /// We would want to parse the above using `Expr::parse` after the `=`
-        /// token.
-        ///
-        /// But in the following, `S {}` is *not* a struct init expression.
-        ///
-        /// ```
-        /// # const S: &bool = &true;
-        /// if *S {} {}
-        ///
-        /// // parsed by rustc as:
-        /// //
-        /// //    if (*S) {
-        /// //        /* empty block */
-        /// //    }
-        /// //    {
-        /// //        /* another empty block */
-        /// //    }
-        /// ```
-        ///
-        /// For that reason we would want to parse if-conditions using
-        /// `Expr::parse_without_eager_brace` after the `if` token. Same for
-        /// similar syntactic positions such as the condition expr after a
-        /// `while` token or the expr at the top of a `match`.
-        ///
-        /// The Rust grammar's choices around which way this ambiguity is
-        /// resolved at various syntactic positions is fairly arbitrary. Really
-        /// either parse behavior could work in most positions, and language
-        /// designers just decide each case based on which is more likely to be
-        /// what the programmer had in mind most of the time.
-        ///
-        /// ```
-        /// # struct S;
-        /// # fn doc() -> S {
-        /// if return S {} {}
-        /// # unreachable!()
-        /// # }
-        ///
-        /// // parsed by rustc as:
-        /// //
-        /// //    if (return (S {})) {
-        /// //    }
-        /// //
-        /// // but could equally well have been this other arbitrary choice:
-        /// //
-        /// //    if (return S) {
-        /// //    }
-        /// //    {}
-        /// ```
-        ///
-        /// Note the grammar ambiguity on trailing braces is distinct from
-        /// precedence and is not captured by assigning a precedence level to
-        /// the braced struct init expr in relation to other operators. This can
-        /// be illustrated by `return 0..S {}` vs `match 0..S {}`. The former
-        /// parses as `return (0..(S {}))` implying tighter precedence for
-        /// struct init than `..`, while the latter parses as `match (0..S) {}`
-        /// implying tighter precedence for `..` than struct init, a
-        /// contradiction.
-        #[cfg(feature = "full")]
-        #[cfg_attr(doc_cfg, doc(cfg(all(feature = "full", feature = "parsing"))))]
-        pub fn parse_without_eager_brace(input: ParseStream) -> Result<Expr> {
-            ambiguous_expr(input, AllowStruct(false))
-        }
-    }
-
-    impl Copy for AllowStruct {}
-
-    impl Clone for AllowStruct {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-
-    impl Copy for Precedence {}
-
-    impl Clone for Precedence {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-
-    impl PartialEq for Precedence {
-        fn eq(&self, other: &Self) -> bool {
-            *self as u8 == *other as u8
-        }
-    }
-
-    impl PartialOrd for Precedence {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            let this = *self as u8;
-            let other = *other as u8;
-            Some(this.cmp(&other))
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn parse_expr(
-        input: ParseStream,
-        mut lhs: Expr,
-        allow_struct: AllowStruct,
-        base: Precedence,
-    ) -> Result<Expr> {
-        loop {
-            if input
-                .fork()
-                .parse::<BinOp>()
-                .ok()
-                .map_or(false, |op| Precedence::of(&op) >= base)
-            {
-                let op: BinOp = input.parse()?;
-                let precedence = Precedence::of(&op);
-                let mut rhs = unary_expr(input, allow_struct)?;
-                loop {
-                    let next = peek_precedence(input);
-                    if next > precedence || next == precedence && precedence == Precedence::Assign {
-                        rhs = parse_expr(input, rhs, allow_struct, next)?;
-                    } else {
-                        break;
-                    }
-                }
-                lhs = if precedence == Precedence::Assign {
-                    Expr::AssignOp(ExprAssignOp {
-                        attrs: Vec::new(),
-                        left: Box::new(lhs),
-                        op,
-                        right: Box::new(rhs),
-                    })
-                } else {
-                    Expr::Binary(ExprBinary {
-                        attrs: Vec::new(),
-                        left: Box::new(lhs),
-                        op,
-                        right: Box::new(rhs),
-                    })
-                };
-            } else if Precedence::Assign >= base
-                && input.peek(Token![=])
-                && !input.peek(Token![==])
-                && !input.peek(Token![=>])
-            {
-                let eq_token: Token![=] = input.parse()?;
-                let mut rhs = unary_expr(input, allow_struct)?;
-                loop {
-                    let next = peek_precedence(input);
-                    if next >= Precedence::Assign {
-                        rhs = parse_expr(input, rhs, allow_struct, next)?;
-                    } else {
-                        break;
-                    }
-                }
-                lhs = Expr::Assign(ExprAssign {
-                    attrs: Vec::new(),
-                    left: Box::new(lhs),
-                    eq_token,
-                    right: Box::new(rhs),
-                });
-            } else if Precedence::Range >= base && input.peek(Token![..]) {
-                let limits: RangeLimits = input.parse()?;
-                let rhs = if input.is_empty()
-                    || input.peek(Token![,])
-                    || input.peek(Token![;])
-                    || input.peek(Token![.]) && !input.peek(Token![..])
-                    || !allow_struct.0 && input.peek(token::Brace)
-                {
-                    None
-                } else {
-                    let mut rhs = unary_expr(input, allow_struct)?;
-                    loop {
-                        let next = peek_precedence(input);
-                        if next > Precedence::Range {
-                            rhs = parse_expr(input, rhs, allow_struct, next)?;
-                        } else {
-                            break;
-                        }
-                    }
-                    Some(rhs)
-                };
-                lhs = Expr::Range(ExprRange {
-                    attrs: Vec::new(),
-                    from: Some(Box::new(lhs)),
-                    limits,
-                    to: rhs.map(Box::new),
-                });
-            } else if Precedence::Cast >= base && input.peek(Token![as]) {
-                let as_token: Token![as] = input.parse()?;
-                let ty = input.call(Type::without_plus)?;
-                lhs = Expr::Cast(ExprCast {
-                    attrs: Vec::new(),
-                    expr: Box::new(lhs),
-                    as_token,
-                    ty: Box::new(ty),
-                });
-            } else if Precedence::Cast >= base && input.peek(Token![:]) && !input.peek(Token![::]) {
-                let colon_token: Token![:] = input.parse()?;
-                let ty = input.call(Type::without_plus)?;
-                lhs = Expr::Type(ExprType {
-                    attrs: Vec::new(),
-                    expr: Box::new(lhs),
-                    colon_token,
-                    ty: Box::new(ty),
-                });
-            } else {
-                break;
-            }
-        }
-        Ok(lhs)
-    }
-
-    #[cfg(not(feature = "full"))]
-    fn parse_expr(
-        input: ParseStream,
-        mut lhs: Expr,
-        allow_struct: AllowStruct,
-        base: Precedence,
-    ) -> Result<Expr> {
-        loop {
-            if input
-                .fork()
-                .parse::<BinOp>()
-                .ok()
-                .map_or(false, |op| Precedence::of(&op) >= base)
-            {
-                let op: BinOp = input.parse()?;
-                let precedence = Precedence::of(&op);
-                let mut rhs = unary_expr(input, allow_struct)?;
-                loop {
-                    let next = peek_precedence(input);
-                    if next > precedence || next == precedence && precedence == Precedence::Assign {
-                        rhs = parse_expr(input, rhs, allow_struct, next)?;
-                    } else {
-                        break;
-                    }
-                }
-                lhs = Expr::Binary(ExprBinary {
-                    attrs: Vec::new(),
-                    left: Box::new(lhs),
-                    op,
-                    right: Box::new(rhs),
-                });
-            } else if Precedence::Cast >= base && input.peek(Token![as]) {
-                let as_token: Token![as] = input.parse()?;
-                let ty = input.call(Type::without_plus)?;
-                lhs = Expr::Cast(ExprCast {
-                    attrs: Vec::new(),
-                    expr: Box::new(lhs),
-                    as_token,
-                    ty: Box::new(ty),
-                });
-            } else {
-                break;
-            }
-        }
-        Ok(lhs)
-    }
-
-    fn peek_precedence(input: ParseStream) -> Precedence {
-        if let Ok(op) = input.fork().parse() {
-            Precedence::of(&op)
-        } else if input.peek(Token![=]) && !input.peek(Token![=>]) {
-            Precedence::Assign
-        } else if input.peek(Token![..]) {
-            Precedence::Range
-        } else if input.peek(Token![as])
-            || cfg!(feature = "full") && input.peek(Token![:]) && !input.peek(Token![::])
-        {
-            Precedence::Cast
-        } else {
-            Precedence::Any
-        }
-    }
-
-    // Parse an arbitrary expression.
-    fn ambiguous_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        let lhs = unary_expr(input, allow_struct)?;
-        parse_expr(input, lhs, allow_struct, Precedence::Any)
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_attrs(input: ParseStream) -> Result<Vec<Attribute>> {
-        let mut attrs = Vec::new();
-        loop {
-            if input.peek(token::Group) {
-                let ahead = input.fork();
-                let group = crate::group::parse_group(&ahead)?;
-                if !group.content.peek(Token![#]) || group.content.peek2(Token![!]) {
-                    break;
-                }
-                let attr = group.content.call(attr::parsing::single_parse_outer)?;
-                if !group.content.is_empty() {
-                    break;
-                }
-                attrs.push(attr);
-            } else if input.peek(Token![#]) {
-                attrs.push(input.call(attr::parsing::single_parse_outer)?);
-            } else {
-                break;
-            }
-        }
-        Ok(attrs)
-    }
-
-    // <UnOp> <trailer>
-    // & <trailer>
-    // &mut <trailer>
-    // box <trailer>
-    #[cfg(feature = "full")]
-    fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        let begin = input.fork();
-        let attrs = input.call(expr_attrs)?;
-        if input.peek(Token![&]) {
-            let and_token: Token![&] = input.parse()?;
-            let raw: Option<raw> =
-                if input.peek(raw) && (input.peek2(Token![mut]) || input.peek2(Token![const])) {
-                    Some(input.parse()?)
-                } else {
-                    None
-                };
-            let mutability: Option<Token![mut]> = input.parse()?;
-            if raw.is_some() && mutability.is_none() {
-                input.parse::<Token![const]>()?;
-            }
-            let expr = Box::new(unary_expr(input, allow_struct)?);
-            if raw.is_some() {
-                Ok(Expr::Verbatim(verbatim::between(begin, input)))
-            } else {
-                Ok(Expr::Reference(ExprReference {
-                    attrs,
-                    and_token,
-                    raw: Reserved::default(),
-                    mutability,
-                    expr,
-                }))
-            }
-        } else if input.peek(Token![box]) {
-            expr_box(input, attrs, allow_struct).map(Expr::Box)
-        } else if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) {
-            expr_unary(input, attrs, allow_struct).map(Expr::Unary)
-        } else {
-            trailer_expr(attrs, input, allow_struct)
-        }
-    }
-
-    #[cfg(not(feature = "full"))]
-    fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        if input.peek(Token![*]) || input.peek(Token![!]) || input.peek(Token![-]) {
-            Ok(Expr::Unary(ExprUnary {
-                attrs: Vec::new(),
-                op: input.parse()?,
-                expr: Box::new(unary_expr(input, allow_struct)?),
-            }))
-        } else {
-            trailer_expr(input, allow_struct)
-        }
-    }
-
-    // <atom> (..<args>) ...
-    // <atom> . <ident> (..<args>) ...
-    // <atom> . <ident> ...
-    // <atom> . <lit> ...
-    // <atom> [ <expr> ] ...
-    // <atom> ? ...
-    #[cfg(feature = "full")]
-    fn trailer_expr(
-        mut attrs: Vec<Attribute>,
-        input: ParseStream,
-        allow_struct: AllowStruct,
-    ) -> Result<Expr> {
-        let atom = atom_expr(input, allow_struct)?;
-        let mut e = trailer_helper(input, atom)?;
-
-        let inner_attrs = e.replace_attrs(Vec::new());
-        attrs.extend(inner_attrs);
-        e.replace_attrs(attrs);
-        Ok(e)
-    }
-
-    #[cfg(feature = "full")]
-    fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> {
-        loop {
-            if input.peek(token::Paren) {
-                let content;
-                e = Expr::Call(ExprCall {
-                    attrs: Vec::new(),
-                    func: Box::new(e),
-                    paren_token: parenthesized!(content in input),
-                    args: content.parse_terminated(Expr::parse)?,
-                });
-            } else if input.peek(Token![.])
-                && !input.peek(Token![..])
-                && match e {
-                    Expr::Range(_) => false,
-                    _ => true,
-                }
-            {
-                let mut dot_token: Token![.] = input.parse()?;
-
-                let await_token: Option<token::Await> = input.parse()?;
-                if let Some(await_token) = await_token {
-                    e = Expr::Await(ExprAwait {
-                        attrs: Vec::new(),
-                        base: Box::new(e),
-                        dot_token,
-                        await_token,
-                    });
-                    continue;
-                }
-
-                let float_token: Option<LitFloat> = input.parse()?;
-                if let Some(float_token) = float_token {
-                    if multi_index(&mut e, &mut dot_token, float_token)? {
-                        continue;
-                    }
-                }
-
-                let member: Member = input.parse()?;
-                let turbofish = if member.is_named() && input.peek(Token![::]) {
-                    Some(MethodTurbofish {
-                        colon2_token: input.parse()?,
-                        lt_token: input.parse()?,
-                        args: {
-                            let mut args = Punctuated::new();
-                            loop {
-                                if input.peek(Token![>]) {
-                                    break;
-                                }
-                                let value = input.call(generic_method_argument)?;
-                                args.push_value(value);
-                                if input.peek(Token![>]) {
-                                    break;
-                                }
-                                let punct = input.parse()?;
-                                args.push_punct(punct);
-                            }
-                            args
-                        },
-                        gt_token: input.parse()?,
-                    })
-                } else {
-                    None
-                };
-
-                if turbofish.is_some() || input.peek(token::Paren) {
-                    if let Member::Named(method) = member {
-                        let content;
-                        e = Expr::MethodCall(ExprMethodCall {
-                            attrs: Vec::new(),
-                            receiver: Box::new(e),
-                            dot_token,
-                            method,
-                            turbofish,
-                            paren_token: parenthesized!(content in input),
-                            args: content.parse_terminated(Expr::parse)?,
-                        });
-                        continue;
-                    }
-                }
-
-                e = Expr::Field(ExprField {
-                    attrs: Vec::new(),
-                    base: Box::new(e),
-                    dot_token,
-                    member,
-                });
-            } else if input.peek(token::Bracket) {
-                let content;
-                e = Expr::Index(ExprIndex {
-                    attrs: Vec::new(),
-                    expr: Box::new(e),
-                    bracket_token: bracketed!(content in input),
-                    index: content.parse()?,
-                });
-            } else if input.peek(Token![?]) {
-                e = Expr::Try(ExprTry {
-                    attrs: Vec::new(),
-                    expr: Box::new(e),
-                    question_token: input.parse()?,
-                });
-            } else {
-                break;
-            }
-        }
-        Ok(e)
-    }
-
-    #[cfg(not(feature = "full"))]
-    fn trailer_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        let mut e = atom_expr(input, allow_struct)?;
-
-        loop {
-            if input.peek(token::Paren) {
-                let content;
-                e = Expr::Call(ExprCall {
-                    attrs: Vec::new(),
-                    func: Box::new(e),
-                    paren_token: parenthesized!(content in input),
-                    args: content.parse_terminated(Expr::parse)?,
-                });
-            } else if input.peek(Token![.]) && !input.peek(Token![..]) && !input.peek2(token::Await)
-            {
-                let mut dot_token: Token![.] = input.parse()?;
-                let float_token: Option<LitFloat> = input.parse()?;
-                if let Some(float_token) = float_token {
-                    if multi_index(&mut e, &mut dot_token, float_token)? {
-                        continue;
-                    }
-                }
-                e = Expr::Field(ExprField {
-                    attrs: Vec::new(),
-                    base: Box::new(e),
-                    dot_token,
-                    member: input.parse()?,
-                });
-            } else if input.peek(token::Bracket) {
-                let content;
-                e = Expr::Index(ExprIndex {
-                    attrs: Vec::new(),
-                    expr: Box::new(e),
-                    bracket_token: bracketed!(content in input),
-                    index: content.parse()?,
-                });
-            } else {
-                break;
-            }
-        }
-
-        Ok(e)
-    }
-
-    // Parse all atomic expressions which don't have to worry about precedence
-    // interactions, as they are fully contained.
-    #[cfg(feature = "full")]
-    fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        if input.peek(token::Group)
-            && !input.peek2(Token![::])
-            && !input.peek2(Token![!])
-            && !input.peek2(token::Brace)
-        {
-            input.call(expr_group).map(Expr::Group)
-        } else if input.peek(Lit) {
-            input.parse().map(Expr::Lit)
-        } else if input.peek(Token![async])
-            && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace))
-        {
-            input.parse().map(Expr::Async)
-        } else if input.peek(Token![try]) && input.peek2(token::Brace) {
-            input.parse().map(Expr::TryBlock)
-        } else if input.peek(Token![|])
-            || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move]))
-            || input.peek(Token![static])
-            || input.peek(Token![move])
-        {
-            expr_closure(input, allow_struct).map(Expr::Closure)
-        } else if input.peek(Ident)
-            || input.peek(Token![::])
-            || input.peek(Token![<])
-            || input.peek(Token![self])
-            || input.peek(Token![Self])
-            || input.peek(Token![super])
-            || input.peek(Token![crate])
-        {
-            path_or_macro_or_struct(input, allow_struct)
-        } else if input.peek(token::Paren) {
-            paren_or_tuple(input)
-        } else if input.peek(Token![break]) {
-            expr_break(input, allow_struct).map(Expr::Break)
-        } else if input.peek(Token![continue]) {
-            input.parse().map(Expr::Continue)
-        } else if input.peek(Token![return]) {
-            expr_ret(input, allow_struct).map(Expr::Return)
-        } else if input.peek(token::Bracket) {
-            array_or_repeat(input)
-        } else if input.peek(Token![let]) {
-            input.parse().map(Expr::Let)
-        } else if input.peek(Token![if]) {
-            input.parse().map(Expr::If)
-        } else if input.peek(Token![while]) {
-            input.parse().map(Expr::While)
-        } else if input.peek(Token![for]) {
-            input.parse().map(Expr::ForLoop)
-        } else if input.peek(Token![loop]) {
-            input.parse().map(Expr::Loop)
-        } else if input.peek(Token![match]) {
-            input.parse().map(Expr::Match)
-        } else if input.peek(Token![yield]) {
-            input.parse().map(Expr::Yield)
-        } else if input.peek(Token![unsafe]) {
-            input.parse().map(Expr::Unsafe)
-        } else if input.peek(Token![const]) {
-            input.call(expr_const).map(Expr::Verbatim)
-        } else if input.peek(token::Brace) {
-            input.parse().map(Expr::Block)
-        } else if input.peek(Token![..]) {
-            expr_range(input, allow_struct).map(Expr::Range)
-        } else if input.peek(Token![_]) {
-            Ok(Expr::Verbatim(TokenStream::from(
-                input.parse::<TokenTree>()?,
-            )))
-        } else if input.peek(Lifetime) {
-            let the_label: Label = input.parse()?;
-            let mut expr = if input.peek(Token![while]) {
-                Expr::While(input.parse()?)
-            } else if input.peek(Token![for]) {
-                Expr::ForLoop(input.parse()?)
-            } else if input.peek(Token![loop]) {
-                Expr::Loop(input.parse()?)
-            } else if input.peek(token::Brace) {
-                Expr::Block(input.parse()?)
-            } else {
-                return Err(input.error("expected loop or block expression"));
-            };
-            match &mut expr {
-                Expr::While(ExprWhile { label, .. })
-                | Expr::ForLoop(ExprForLoop { label, .. })
-                | Expr::Loop(ExprLoop { label, .. })
-                | Expr::Block(ExprBlock { label, .. }) => *label = Some(the_label),
-                _ => unreachable!(),
-            }
-            Ok(expr)
-        } else {
-            Err(input.error("expected expression"))
-        }
-    }
-
-    #[cfg(not(feature = "full"))]
-    fn atom_expr(input: ParseStream, _allow_struct: AllowStruct) -> Result<Expr> {
-        if input.peek(Lit) {
-            input.parse().map(Expr::Lit)
-        } else if input.peek(token::Paren) {
-            input.call(expr_paren).map(Expr::Paren)
-        } else if input.peek(Ident)
-            || input.peek(Token![::])
-            || input.peek(Token![<])
-            || input.peek(Token![self])
-            || input.peek(Token![Self])
-            || input.peek(Token![super])
-            || input.peek(Token![crate])
-        {
-            input.parse().map(Expr::Path)
-        } else {
-            Err(input.error("unsupported expression; enable syn's features=[\"full\"]"))
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn path_or_macro_or_struct(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> {
-        let expr: ExprPath = input.parse()?;
-        if expr.qself.is_some() {
-            return Ok(Expr::Path(expr));
-        }
-
-        if input.peek(Token![!]) && !input.peek(Token![!=]) {
-            let mut contains_arguments = false;
-            for segment in &expr.path.segments {
-                match segment.arguments {
-                    PathArguments::None => {}
-                    PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => {
-                        contains_arguments = true;
-                    }
-                }
-            }
-
-            if !contains_arguments {
-                let bang_token: Token![!] = input.parse()?;
-                let (delimiter, tokens) = mac::parse_delimiter(input)?;
-                return Ok(Expr::Macro(ExprMacro {
-                    attrs: Vec::new(),
-                    mac: Macro {
-                        path: expr.path,
-                        bang_token,
-                        delimiter,
-                        tokens,
-                    },
-                }));
-            }
-        }
-
-        if allow_struct.0 && input.peek(token::Brace) {
-            let outer_attrs = Vec::new();
-            expr_struct_helper(input, outer_attrs, expr.path).map(Expr::Struct)
-        } else {
-            Ok(Expr::Path(expr))
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprMacro {
-                attrs: Vec::new(),
-                mac: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn paren_or_tuple(input: ParseStream) -> Result<Expr> {
-        let content;
-        let paren_token = parenthesized!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
-        if content.is_empty() {
-            return Ok(Expr::Tuple(ExprTuple {
-                attrs: inner_attrs,
-                paren_token,
-                elems: Punctuated::new(),
-            }));
-        }
-
-        let first: Expr = content.parse()?;
-        if content.is_empty() {
-            return Ok(Expr::Paren(ExprParen {
-                attrs: inner_attrs,
-                paren_token,
-                expr: Box::new(first),
-            }));
-        }
-
-        let mut elems = Punctuated::new();
-        elems.push_value(first);
-        while !content.is_empty() {
-            let punct = content.parse()?;
-            elems.push_punct(punct);
-            if content.is_empty() {
-                break;
-            }
-            let value = content.parse()?;
-            elems.push_value(value);
-        }
-        Ok(Expr::Tuple(ExprTuple {
-            attrs: inner_attrs,
-            paren_token,
-            elems,
-        }))
-    }
-
-    #[cfg(feature = "full")]
-    fn array_or_repeat(input: ParseStream) -> Result<Expr> {
-        let content;
-        let bracket_token = bracketed!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
-        if content.is_empty() {
-            return Ok(Expr::Array(ExprArray {
-                attrs: inner_attrs,
-                bracket_token,
-                elems: Punctuated::new(),
-            }));
-        }
-
-        let first: Expr = content.parse()?;
-        if content.is_empty() || content.peek(Token![,]) {
-            let mut elems = Punctuated::new();
-            elems.push_value(first);
-            while !content.is_empty() {
-                let punct = content.parse()?;
-                elems.push_punct(punct);
-                if content.is_empty() {
-                    break;
-                }
-                let value = content.parse()?;
-                elems.push_value(value);
-            }
-            Ok(Expr::Array(ExprArray {
-                attrs: inner_attrs,
-                bracket_token,
-                elems,
-            }))
-        } else if content.peek(Token![;]) {
-            let semi_token: Token![;] = content.parse()?;
-            let len: Expr = content.parse()?;
-            Ok(Expr::Repeat(ExprRepeat {
-                attrs: inner_attrs,
-                bracket_token,
-                expr: Box::new(first),
-                semi_token,
-                len: Box::new(len),
-            }))
-        } else {
-            Err(content.error("expected `,` or `;`"))
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprArray {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            let bracket_token = bracketed!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
-            let mut elems = Punctuated::new();
-
-            while !content.is_empty() {
-                let first: Expr = content.parse()?;
-                elems.push_value(first);
-                if content.is_empty() {
-                    break;
-                }
-                let punct = content.parse()?;
-                elems.push_punct(punct);
-            }
-
-            Ok(ExprArray {
-                attrs: inner_attrs,
-                bracket_token,
-                elems,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprRepeat {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(ExprRepeat {
-                bracket_token: bracketed!(content in input),
-                attrs: content.call(Attribute::parse_inner)?,
-                expr: content.parse()?,
-                semi_token: content.parse()?,
-                len: content.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    pub(crate) fn expr_early(input: ParseStream) -> Result<Expr> {
-        let mut attrs = input.call(expr_attrs)?;
-        let mut expr = if input.peek(Token![if]) {
-            Expr::If(input.parse()?)
-        } else if input.peek(Token![while]) {
-            Expr::While(input.parse()?)
-        } else if input.peek(Token![for]) {
-            Expr::ForLoop(input.parse()?)
-        } else if input.peek(Token![loop]) {
-            Expr::Loop(input.parse()?)
-        } else if input.peek(Token![match]) {
-            Expr::Match(input.parse()?)
-        } else if input.peek(Token![try]) && input.peek2(token::Brace) {
-            Expr::TryBlock(input.parse()?)
-        } else if input.peek(Token![unsafe]) {
-            Expr::Unsafe(input.parse()?)
-        } else if input.peek(Token![const]) {
-            Expr::Verbatim(input.call(expr_const)?)
-        } else if input.peek(token::Brace) {
-            Expr::Block(input.parse()?)
-        } else {
-            let allow_struct = AllowStruct(true);
-            let mut expr = unary_expr(input, allow_struct)?;
-
-            attrs.extend(expr.replace_attrs(Vec::new()));
-            expr.replace_attrs(attrs);
-
-            return parse_expr(input, expr, allow_struct, Precedence::Any);
-        };
-
-        if input.peek(Token![.]) && !input.peek(Token![..]) || input.peek(Token![?]) {
-            expr = trailer_helper(input, expr)?;
-
-            attrs.extend(expr.replace_attrs(Vec::new()));
-            expr.replace_attrs(attrs);
-
-            let allow_struct = AllowStruct(true);
-            return parse_expr(input, expr, allow_struct, Precedence::Any);
-        }
-
-        attrs.extend(expr.replace_attrs(Vec::new()));
-        expr.replace_attrs(attrs);
-        Ok(expr)
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprLit {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprLit {
-                attrs: Vec::new(),
-                lit: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_group(input: ParseStream) -> Result<ExprGroup> {
-        let group = crate::group::parse_group(input)?;
-        Ok(ExprGroup {
-            attrs: Vec::new(),
-            group_token: group.token,
-            expr: group.content.parse()?,
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprParen {
-        fn parse(input: ParseStream) -> Result<Self> {
-            expr_paren(input)
-        }
-    }
-
-    fn expr_paren(input: ParseStream) -> Result<ExprParen> {
-        let content;
-        Ok(ExprParen {
-            attrs: Vec::new(),
-            paren_token: parenthesized!(content in input),
-            expr: content.parse()?,
-        })
-    }
-
-    #[cfg(feature = "full")]
-    fn generic_method_argument(input: ParseStream) -> Result<GenericMethodArgument> {
-        if input.peek(Lit) {
-            let lit = input.parse()?;
-            return Ok(GenericMethodArgument::Const(Expr::Lit(lit)));
-        }
-
-        if input.peek(token::Brace) {
-            let block: ExprBlock = input.parse()?;
-            return Ok(GenericMethodArgument::Const(Expr::Block(block)));
-        }
-
-        input.parse().map(GenericMethodArgument::Type)
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprLet {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprLet {
-                attrs: Vec::new(),
-                let_token: input.parse()?,
-                pat: pat::parsing::multi_pat_with_leading_vert(input)?,
-                eq_token: input.parse()?,
-                expr: Box::new(input.call(Expr::parse_without_eager_brace)?),
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprIf {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            Ok(ExprIf {
-                attrs,
-                if_token: input.parse()?,
-                cond: Box::new(input.call(Expr::parse_without_eager_brace)?),
-                then_branch: input.parse()?,
-                else_branch: {
-                    if input.peek(Token![else]) {
-                        Some(input.call(else_block)?)
-                    } else {
-                        None
-                    }
-                },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn else_block(input: ParseStream) -> Result<(Token![else], Box<Expr>)> {
-        let else_token: Token![else] = input.parse()?;
-
-        let lookahead = input.lookahead1();
-        let else_branch = if input.peek(Token![if]) {
-            input.parse().map(Expr::If)?
-        } else if input.peek(token::Brace) {
-            Expr::Block(ExprBlock {
-                attrs: Vec::new(),
-                label: None,
-                block: input.parse()?,
-            })
-        } else {
-            return Err(lookahead.error());
-        };
-
-        Ok((else_token, Box::new(else_branch)))
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprForLoop {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let label: Option<Label> = input.parse()?;
-            let for_token: Token![for] = input.parse()?;
-
-            let pat = pat::parsing::multi_pat_with_leading_vert(input)?;
-
-            let in_token: Token![in] = input.parse()?;
-            let expr: Expr = input.call(Expr::parse_without_eager_brace)?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-            let stmts = content.call(Block::parse_within)?;
-
-            Ok(ExprForLoop {
-                attrs,
-                label,
-                for_token,
-                pat,
-                in_token,
-                expr: Box::new(expr),
-                body: Block { brace_token, stmts },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprLoop {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let label: Option<Label> = input.parse()?;
-            let loop_token: Token![loop] = input.parse()?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-            let stmts = content.call(Block::parse_within)?;
-
-            Ok(ExprLoop {
-                attrs,
-                label,
-                loop_token,
-                body: Block { brace_token, stmts },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprMatch {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let match_token: Token![match] = input.parse()?;
-            let expr = Expr::parse_without_eager_brace(input)?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-
-            let mut arms = Vec::new();
-            while !content.is_empty() {
-                arms.push(content.call(Arm::parse)?);
-            }
-
-            Ok(ExprMatch {
-                attrs,
-                match_token,
-                expr: Box::new(expr),
-                brace_token,
-                arms,
-            })
-        }
-    }
-
-    macro_rules! impl_by_parsing_expr {
-        (
-            $(
-                $expr_type:ty, $variant:ident, $msg:expr,
-            )*
-        ) => {
-            $(
-                #[cfg(all(feature = "full", feature = "printing"))]
-                #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-                impl Parse for $expr_type {
-                    fn parse(input: ParseStream) -> Result<Self> {
-                        let mut expr: Expr = input.parse()?;
-                        loop {
-                            match expr {
-                                Expr::$variant(inner) => return Ok(inner),
-                                Expr::Group(next) => expr = *next.expr,
-                                _ => return Err(Error::new_spanned(expr, $msg)),
-                            }
-                        }
-                    }
-                }
-            )*
-        };
-    }
-
-    impl_by_parsing_expr! {
-        ExprCall, Call, "expected function call expression",
-        ExprMethodCall, MethodCall, "expected method call expression",
-        ExprTuple, Tuple, "expected tuple expression",
-        ExprBinary, Binary, "expected binary operation",
-        ExprCast, Cast, "expected cast expression",
-        ExprType, Type, "expected type ascription expression",
-        ExprAssign, Assign, "expected assignment expression",
-        ExprAssignOp, AssignOp, "expected compound assignment expression",
-        ExprField, Field, "expected struct field access",
-        ExprIndex, Index, "expected indexing expression",
-        ExprRange, Range, "expected range expression",
-        ExprTry, Try, "expected try expression",
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprBox {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = Vec::new();
-            let allow_struct = AllowStruct(true);
-            expr_box(input, attrs, allow_struct)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_box(
-        input: ParseStream,
-        attrs: Vec<Attribute>,
-        allow_struct: AllowStruct,
-    ) -> Result<ExprBox> {
-        Ok(ExprBox {
-            attrs,
-            box_token: input.parse()?,
-            expr: Box::new(unary_expr(input, allow_struct)?),
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprUnary {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = Vec::new();
-            let allow_struct = AllowStruct(true);
-            expr_unary(input, attrs, allow_struct)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_unary(
-        input: ParseStream,
-        attrs: Vec<Attribute>,
-        allow_struct: AllowStruct,
-    ) -> Result<ExprUnary> {
-        Ok(ExprUnary {
-            attrs,
-            op: input.parse()?,
-            expr: Box::new(unary_expr(input, allow_struct)?),
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprClosure {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_struct = AllowStruct(true);
-            expr_closure(input, allow_struct)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprReference {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_struct = AllowStruct(true);
-            Ok(ExprReference {
-                attrs: Vec::new(),
-                and_token: input.parse()?,
-                raw: Reserved::default(),
-                mutability: input.parse()?,
-                expr: Box::new(unary_expr(input, allow_struct)?),
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprBreak {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_struct = AllowStruct(true);
-            expr_break(input, allow_struct)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprReturn {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_struct = AllowStruct(true);
-            expr_ret(input, allow_struct)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprTryBlock {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprTryBlock {
-                attrs: Vec::new(),
-                try_token: input.parse()?,
-                block: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprYield {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprYield {
-                attrs: Vec::new(),
-                yield_token: input.parse()?,
-                expr: {
-                    if !input.is_empty() && !input.peek(Token![,]) && !input.peek(Token![;]) {
-                        Some(input.parse()?)
-                    } else {
-                        None
-                    }
-                },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> {
-        let asyncness: Option<Token![async]> = input.parse()?;
-        let movability: Option<Token![static]> = if asyncness.is_none() {
-            input.parse()?
-        } else {
-            None
-        };
-        let capture: Option<Token![move]> = input.parse()?;
-        let or1_token: Token![|] = input.parse()?;
-
-        let mut inputs = Punctuated::new();
-        loop {
-            if input.peek(Token![|]) {
-                break;
-            }
-            let value = closure_arg(input)?;
-            inputs.push_value(value);
-            if input.peek(Token![|]) {
-                break;
-            }
-            let punct: Token![,] = input.parse()?;
-            inputs.push_punct(punct);
-        }
-
-        let or2_token: Token![|] = input.parse()?;
-
-        let (output, body) = if input.peek(Token![->]) {
-            let arrow_token: Token![->] = input.parse()?;
-            let ty: Type = input.parse()?;
-            let body: Block = input.parse()?;
-            let output = ReturnType::Type(arrow_token, Box::new(ty));
-            let block = Expr::Block(ExprBlock {
-                attrs: Vec::new(),
-                label: None,
-                block: body,
-            });
-            (output, block)
-        } else {
-            let body = ambiguous_expr(input, allow_struct)?;
-            (ReturnType::Default, body)
-        };
-
-        Ok(ExprClosure {
-            attrs: Vec::new(),
-            asyncness,
-            movability,
-            capture,
-            or1_token,
-            inputs,
-            or2_token,
-            output,
-            body: Box::new(body),
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprAsync {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprAsync {
-                attrs: Vec::new(),
-                async_token: input.parse()?,
-                capture: input.parse()?,
-                block: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn closure_arg(input: ParseStream) -> Result<Pat> {
-        let attrs = input.call(Attribute::parse_outer)?;
-        let mut pat: Pat = input.parse()?;
-
-        if input.peek(Token![:]) {
-            Ok(Pat::Type(PatType {
-                attrs,
-                pat: Box::new(pat),
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-            }))
-        } else {
-            match &mut pat {
-                Pat::Box(pat) => pat.attrs = attrs,
-                Pat::Ident(pat) => pat.attrs = attrs,
-                Pat::Lit(pat) => pat.attrs = attrs,
-                Pat::Macro(pat) => pat.attrs = attrs,
-                Pat::Or(pat) => pat.attrs = attrs,
-                Pat::Path(pat) => pat.attrs = attrs,
-                Pat::Range(pat) => pat.attrs = attrs,
-                Pat::Reference(pat) => pat.attrs = attrs,
-                Pat::Rest(pat) => pat.attrs = attrs,
-                Pat::Slice(pat) => pat.attrs = attrs,
-                Pat::Struct(pat) => pat.attrs = attrs,
-                Pat::Tuple(pat) => pat.attrs = attrs,
-                Pat::TupleStruct(pat) => pat.attrs = attrs,
-                Pat::Type(_) => unreachable!(),
-                Pat::Verbatim(_) => {}
-                Pat::Wild(pat) => pat.attrs = attrs,
-
-                #[cfg(test)]
-                Pat::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
-                _ => unreachable!(),
-            }
-            Ok(pat)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprWhile {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let label: Option<Label> = input.parse()?;
-            let while_token: Token![while] = input.parse()?;
-            let cond = Expr::parse_without_eager_brace(input)?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-            let stmts = content.call(Block::parse_within)?;
-
-            Ok(ExprWhile {
-                attrs,
-                label,
-                while_token,
-                cond: Box::new(cond),
-                body: Block { brace_token, stmts },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Label {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(Label {
-                name: input.parse()?,
-                colon_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Option<Label> {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Lifetime) {
-                input.parse().map(Some)
-            } else {
-                Ok(None)
-            }
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprContinue {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ExprContinue {
-                attrs: Vec::new(),
-                continue_token: input.parse()?,
-                label: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_break(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprBreak> {
-        Ok(ExprBreak {
-            attrs: Vec::new(),
-            break_token: input.parse()?,
-            label: input.parse()?,
-            expr: {
-                if input.is_empty()
-                    || input.peek(Token![,])
-                    || input.peek(Token![;])
-                    || !allow_struct.0 && input.peek(token::Brace)
-                {
-                    None
-                } else {
-                    let expr = ambiguous_expr(input, allow_struct)?;
-                    Some(Box::new(expr))
-                }
-            },
-        })
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_ret(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprReturn> {
-        Ok(ExprReturn {
-            attrs: Vec::new(),
-            return_token: input.parse()?,
-            expr: {
-                if input.is_empty() || input.peek(Token![,]) || input.peek(Token![;]) {
-                    None
-                } else {
-                    // NOTE: return is greedy and eats blocks after it even when in a
-                    // position where structs are not allowed, such as in if statement
-                    // conditions. For example:
-                    //
-                    // if return { println!("A") } {} // Prints "A"
-                    let expr = ambiguous_expr(input, allow_struct)?;
-                    Some(Box::new(expr))
-                }
-            },
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for FieldValue {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let member: Member = input.parse()?;
-            let (colon_token, value) = if input.peek(Token![:]) || !member.is_named() {
-                let colon_token: Token![:] = input.parse()?;
-                let value: Expr = input.parse()?;
-                (Some(colon_token), value)
-            } else if let Member::Named(ident) = &member {
-                let value = Expr::Path(ExprPath {
-                    attrs: Vec::new(),
-                    qself: None,
-                    path: Path::from(ident.clone()),
-                });
-                (None, value)
-            } else {
-                unreachable!()
-            };
-
-            Ok(FieldValue {
-                attrs,
-                member,
-                colon_token,
-                expr: value,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprStruct {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = Vec::new();
-            let path: Path = input.parse()?;
-            expr_struct_helper(input, attrs, path)
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_struct_helper(
-        input: ParseStream,
-        mut attrs: Vec<Attribute>,
-        path: Path,
-    ) -> Result<ExprStruct> {
-        let content;
-        let brace_token = braced!(content in input);
-        attr::parsing::parse_inner(&content, &mut attrs)?;
-
-        let mut fields = Punctuated::new();
-        while !content.is_empty() {
-            if content.peek(Token![..]) {
-                return Ok(ExprStruct {
-                    attrs,
-                    brace_token,
-                    path,
-                    fields,
-                    dot2_token: Some(content.parse()?),
-                    rest: if content.is_empty() {
-                        None
-                    } else {
-                        Some(Box::new(content.parse()?))
-                    },
-                });
-            }
-
-            fields.push(content.parse()?);
-            if content.is_empty() {
-                break;
-            }
-            let punct: Token![,] = content.parse()?;
-            fields.push_punct(punct);
-        }
-
-        Ok(ExprStruct {
-            attrs,
-            brace_token,
-            path,
-            fields,
-            dot2_token: None,
-            rest: None,
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprUnsafe {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let unsafe_token: Token![unsafe] = input.parse()?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            let inner_attrs = content.call(Attribute::parse_inner)?;
-            let stmts = content.call(Block::parse_within)?;
-
-            Ok(ExprUnsafe {
-                attrs: inner_attrs,
-                unsafe_token,
-                block: Block { brace_token, stmts },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    pub(crate) fn expr_const(input: ParseStream) -> Result<TokenStream> {
-        let begin = input.fork();
-        input.parse::<Token![const]>()?;
-
-        let content;
-        braced!(content in input);
-        content.call(Attribute::parse_inner)?;
-        content.call(Block::parse_within)?;
-
-        Ok(verbatim::between(begin, input))
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprBlock {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let label: Option<Label> = input.parse()?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-            let stmts = content.call(Block::parse_within)?;
-
-            Ok(ExprBlock {
-                attrs,
-                label,
-                block: Block { brace_token, stmts },
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn expr_range(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprRange> {
-        Ok(ExprRange {
-            attrs: Vec::new(),
-            from: None,
-            limits: input.parse()?,
-            to: {
-                if input.is_empty()
-                    || input.peek(Token![,])
-                    || input.peek(Token![;])
-                    || input.peek(Token![.]) && !input.peek(Token![..])
-                    || !allow_struct.0 && input.peek(token::Brace)
-                {
-                    None
-                } else {
-                    let to = ambiguous_expr(input, allow_struct)?;
-                    Some(Box::new(to))
-                }
-            },
-        })
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for RangeLimits {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Token![..=]) {
-                input.parse().map(RangeLimits::Closed)
-            } else if lookahead.peek(Token![...]) {
-                let dot3: Token![...] = input.parse()?;
-                Ok(RangeLimits::Closed(Token![..=](dot3.spans)))
-            } else if lookahead.peek(Token![..]) {
-                input.parse().map(RangeLimits::HalfOpen)
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ExprPath {
-        fn parse(input: ParseStream) -> Result<Self> {
-            #[cfg(not(feature = "full"))]
-            let attrs = Vec::new();
-            #[cfg(feature = "full")]
-            let attrs = input.call(Attribute::parse_outer)?;
-
-            let (qself, path) = path::parsing::qpath(input, true)?;
-
-            Ok(ExprPath { attrs, qself, path })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Member {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Ident) {
-                input.parse().map(Member::Named)
-            } else if input.peek(LitInt) {
-                input.parse().map(Member::Unnamed)
-            } else {
-                Err(input.error("expected identifier or integer"))
-            }
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Arm {
-        fn parse(input: ParseStream) -> Result<Arm> {
-            let requires_comma;
-            Ok(Arm {
-                attrs: input.call(Attribute::parse_outer)?,
-                pat: pat::parsing::multi_pat_with_leading_vert(input)?,
-                guard: {
-                    if input.peek(Token![if]) {
-                        let if_token: Token![if] = input.parse()?;
-                        let guard: Expr = input.parse()?;
-                        Some((if_token, Box::new(guard)))
-                    } else {
-                        None
-                    }
-                },
-                fat_arrow_token: input.parse()?,
-                body: {
-                    let body = input.call(expr_early)?;
-                    requires_comma = requires_terminator(&body);
-                    Box::new(body)
-                },
-                comma: {
-                    if requires_comma && !input.is_empty() {
-                        Some(input.parse()?)
-                    } else {
-                        input.parse()?
-                    }
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Index {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let lit: LitInt = input.parse()?;
-            if lit.suffix().is_empty() {
-                Ok(Index {
-                    index: lit
-                        .base10_digits()
-                        .parse()
-                        .map_err(|err| Error::new(lit.span(), err))?,
-                    span: lit.span(),
-                })
-            } else {
-                Err(Error::new(lit.span(), "expected unsuffixed integer"))
-            }
-        }
-    }
-
-    fn multi_index(e: &mut Expr, dot_token: &mut Token![.], float: LitFloat) -> Result<bool> {
-        let mut float_repr = float.to_string();
-        let trailing_dot = float_repr.ends_with('.');
-        if trailing_dot {
-            float_repr.truncate(float_repr.len() - 1);
-        }
-        for part in float_repr.split('.') {
-            let index = crate::parse_str(part).map_err(|err| Error::new(float.span(), err))?;
-            let base = mem::replace(e, Expr::__TestExhaustive(crate::private(())));
-            *e = Expr::Field(ExprField {
-                attrs: Vec::new(),
-                base: Box::new(base),
-                dot_token: Token![.](dot_token.span),
-                member: Member::Unnamed(index),
-            });
-            *dot_token = Token![.](float.span());
-        }
-        Ok(!trailing_dot)
-    }
-
-    #[cfg(feature = "full")]
-    impl Member {
-        fn is_named(&self) -> bool {
-            match *self {
-                Member::Named(_) => true,
-                Member::Unnamed(_) => false,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-pub(crate) mod printing {
-    use super::*;
-    #[cfg(feature = "full")]
-    use crate::attr::FilterAttrs;
-    use proc_macro2::{Literal, TokenStream};
-    use quote::{ToTokens, TokenStreamExt};
-
-    // If the given expression is a bare `ExprStruct`, wraps it in parenthesis
-    // before appending it to `TokenStream`.
-    #[cfg(feature = "full")]
-    fn wrap_bare_struct(tokens: &mut TokenStream, e: &Expr) {
-        if let Expr::Struct(_) = *e {
-            token::Paren::default().surround(tokens, |tokens| {
-                e.to_tokens(tokens);
-            });
-        } else {
-            e.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    pub(crate) fn outer_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) {
-        tokens.append_all(attrs.outer());
-    }
-
-    #[cfg(feature = "full")]
-    fn inner_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) {
-        tokens.append_all(attrs.inner());
-    }
-
-    #[cfg(not(feature = "full"))]
-    pub(crate) fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {}
-
-    #[cfg(not(feature = "full"))]
-    fn inner_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {}
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprBox {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.box_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprArray {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.bracket_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                self.elems.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprCall {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.func.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.args.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprMethodCall {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.receiver.to_tokens(tokens);
-            self.dot_token.to_tokens(tokens);
-            self.method.to_tokens(tokens);
-            self.turbofish.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.args.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for MethodTurbofish {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.colon2_token.to_tokens(tokens);
-            self.lt_token.to_tokens(tokens);
-            self.args.to_tokens(tokens);
-            self.gt_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for GenericMethodArgument {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                GenericMethodArgument::Type(t) => t.to_tokens(tokens),
-                GenericMethodArgument::Const(c) => c.to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprTuple {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                self.elems.to_tokens(tokens);
-                // If we only have one argument, we need a trailing comma to
-                // distinguish ExprTuple from ExprParen.
-                if self.elems.len() == 1 && !self.elems.trailing_punct() {
-                    <Token![,]>::default().to_tokens(tokens);
-                }
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprBinary {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.left.to_tokens(tokens);
-            self.op.to_tokens(tokens);
-            self.right.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprUnary {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.op.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprLit {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.lit.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprCast {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.expr.to_tokens(tokens);
-            self.as_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.expr.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn maybe_wrap_else(tokens: &mut TokenStream, else_: &Option<(Token![else], Box<Expr>)>) {
-        if let Some((else_token, else_)) = else_ {
-            else_token.to_tokens(tokens);
-
-            // If we are not one of the valid expressions to exist in an else
-            // clause, wrap ourselves in a block.
-            match **else_ {
-                Expr::If(_) | Expr::Block(_) => {
-                    else_.to_tokens(tokens);
-                }
-                _ => {
-                    token::Brace::default().surround(tokens, |tokens| {
-                        else_.to_tokens(tokens);
-                    });
-                }
-            }
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprLet {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.let_token.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            wrap_bare_struct(tokens, &self.expr);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprIf {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.if_token.to_tokens(tokens);
-            wrap_bare_struct(tokens, &self.cond);
-            self.then_branch.to_tokens(tokens);
-            maybe_wrap_else(tokens, &self.else_branch);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprWhile {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.label.to_tokens(tokens);
-            self.while_token.to_tokens(tokens);
-            wrap_bare_struct(tokens, &self.cond);
-            self.body.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                tokens.append_all(&self.body.stmts);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprForLoop {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.label.to_tokens(tokens);
-            self.for_token.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-            self.in_token.to_tokens(tokens);
-            wrap_bare_struct(tokens, &self.expr);
-            self.body.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                tokens.append_all(&self.body.stmts);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprLoop {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.label.to_tokens(tokens);
-            self.loop_token.to_tokens(tokens);
-            self.body.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                tokens.append_all(&self.body.stmts);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprMatch {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.match_token.to_tokens(tokens);
-            wrap_bare_struct(tokens, &self.expr);
-            self.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                for (i, arm) in self.arms.iter().enumerate() {
-                    arm.to_tokens(tokens);
-                    // Ensure that we have a comma after a non-block arm, except
-                    // for the last one.
-                    let is_last = i == self.arms.len() - 1;
-                    if !is_last && requires_terminator(&arm.body) && arm.comma.is_none() {
-                        <Token![,]>::default().to_tokens(tokens);
-                    }
-                }
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprAsync {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.async_token.to_tokens(tokens);
-            self.capture.to_tokens(tokens);
-            self.block.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprAwait {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.base.to_tokens(tokens);
-            self.dot_token.to_tokens(tokens);
-            self.await_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprTryBlock {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.try_token.to_tokens(tokens);
-            self.block.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprYield {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.yield_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprClosure {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.asyncness.to_tokens(tokens);
-            self.movability.to_tokens(tokens);
-            self.capture.to_tokens(tokens);
-            self.or1_token.to_tokens(tokens);
-            self.inputs.to_tokens(tokens);
-            self.or2_token.to_tokens(tokens);
-            self.output.to_tokens(tokens);
-            self.body.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprUnsafe {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.unsafe_token.to_tokens(tokens);
-            self.block.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                tokens.append_all(&self.block.stmts);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprBlock {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.label.to_tokens(tokens);
-            self.block.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                tokens.append_all(&self.block.stmts);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprAssign {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.left.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.right.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprAssignOp {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.left.to_tokens(tokens);
-            self.op.to_tokens(tokens);
-            self.right.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprField {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.base.to_tokens(tokens);
-            self.dot_token.to_tokens(tokens);
-            self.member.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Member {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                Member::Named(ident) => ident.to_tokens(tokens),
-                Member::Unnamed(index) => index.to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Index {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            let mut lit = Literal::i64_unsuffixed(i64::from(self.index));
-            lit.set_span(self.span);
-            tokens.append(lit);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprIndex {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.expr.to_tokens(tokens);
-            self.bracket_token.surround(tokens, |tokens| {
-                self.index.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprRange {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.from.to_tokens(tokens);
-            match &self.limits {
-                RangeLimits::HalfOpen(t) => t.to_tokens(tokens),
-                RangeLimits::Closed(t) => t.to_tokens(tokens),
-            }
-            self.to.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprPath {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            private::print_path(tokens, &self.qself, &self.path);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprReference {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.and_token.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprBreak {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.break_token.to_tokens(tokens);
-            self.label.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprContinue {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.continue_token.to_tokens(tokens);
-            self.label.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprReturn {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.return_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.mac.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprStruct {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.path.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                self.fields.to_tokens(tokens);
-                if let Some(dot2_token) = &self.dot2_token {
-                    dot2_token.to_tokens(tokens);
-                } else if self.rest.is_some() {
-                    Token![..](Span::call_site()).to_tokens(tokens);
-                }
-                self.rest.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprRepeat {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.bracket_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                self.expr.to_tokens(tokens);
-                self.semi_token.to_tokens(tokens);
-                self.len.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprGroup {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.group_token.surround(tokens, |tokens| {
-                self.expr.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprParen {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                inner_attrs_to_tokens(&self.attrs, tokens);
-                self.expr.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ExprTry {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.expr.to_tokens(tokens);
-            self.question_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Label {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.name.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for FieldValue {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            outer_attrs_to_tokens(&self.attrs, tokens);
-            self.member.to_tokens(tokens);
-            if let Some(colon_token) = &self.colon_token {
-                colon_token.to_tokens(tokens);
-                self.expr.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Arm {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(&self.attrs);
-            self.pat.to_tokens(tokens);
-            if let Some((if_token, guard)) = &self.guard {
-                if_token.to_tokens(tokens);
-                guard.to_tokens(tokens);
-            }
-            self.fat_arrow_token.to_tokens(tokens);
-            self.body.to_tokens(tokens);
-            self.comma.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/ext.rs b/vendor/syn/src/ext.rs
deleted file mode 100644
index 98d5550f..00000000
--- a/vendor/syn/src/ext.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-//! Extension traits to provide parsing methods on foreign types.
-//!
-//! *This module is available only if Syn is built with the `"parsing"` feature.*
-
-use crate::buffer::Cursor;
-use crate::parse::Peek;
-use crate::parse::{ParseStream, Result};
-use crate::sealed::lookahead;
-use crate::token::CustomToken;
-use proc_macro2::Ident;
-
-/// Additional methods for `Ident` not provided by proc-macro2 or libproc_macro.
-///
-/// This trait is sealed and cannot be implemented for types outside of Syn. It
-/// is implemented only for `proc_macro2::Ident`.
-///
-/// *This trait is available only if Syn is built with the `"parsing"` feature.*
-pub trait IdentExt: Sized + private::Sealed {
-    /// Parses any identifier including keywords.
-    ///
-    /// This is useful when parsing macro input which allows Rust keywords as
-    /// identifiers.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{Error, Ident, Result, Token};
-    /// use syn::ext::IdentExt;
-    /// use syn::parse::ParseStream;
-    ///
-    /// mod kw {
-    ///     syn::custom_keyword!(name);
-    /// }
-    ///
-    /// // Parses input that looks like `name = NAME` where `NAME` can be
-    /// // any identifier.
-    /// //
-    /// // Examples:
-    /// //
-    /// //     name = anything
-    /// //     name = impl
-    /// fn parse_dsl(input: ParseStream) -> Result<Ident> {
-    ///     input.parse::<kw::name>()?;
-    ///     input.parse::<Token![=]>()?;
-    ///     let name = input.call(Ident::parse_any)?;
-    ///     Ok(name)
-    /// }
-    /// ```
-    fn parse_any(input: ParseStream) -> Result<Self>;
-
-    /// Peeks any identifier including keywords. Usage:
-    /// `input.peek(Ident::peek_any)`
-    ///
-    /// This is different from `input.peek(Ident)` which only returns true in
-    /// the case of an ident which is not a Rust keyword.
-    #[allow(non_upper_case_globals)]
-    const peek_any: private::PeekFn = private::PeekFn;
-
-    /// Strips the raw marker `r#`, if any, from the beginning of an ident.
-    ///
-    ///   - unraw(`x`) = `x`
-    ///   - unraw(`move`) = `move`
-    ///   - unraw(`r#move`) = `move`
-    ///
-    /// # Example
-    ///
-    /// In the case of interop with other languages like Python that have a
-    /// different set of keywords than Rust, we might come across macro input
-    /// that involves raw identifiers to refer to ordinary variables in the
-    /// other language with a name that happens to be a Rust keyword.
-    ///
-    /// The function below appends an identifier from the caller's input onto a
-    /// fixed prefix. Without using `unraw()`, this would tend to produce
-    /// invalid identifiers like `__pyo3_get_r#move`.
-    ///
-    /// ```
-    /// use proc_macro2::Span;
-    /// use syn::Ident;
-    /// use syn::ext::IdentExt;
-    ///
-    /// fn ident_for_getter(variable: &Ident) -> Ident {
-    ///     let getter = format!("__pyo3_get_{}", variable.unraw());
-    ///     Ident::new(&getter, Span::call_site())
-    /// }
-    /// ```
-    fn unraw(&self) -> Ident;
-}
-
-impl IdentExt for Ident {
-    fn parse_any(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| match cursor.ident() {
-            Some((ident, rest)) => Ok((ident, rest)),
-            None => Err(cursor.error("expected ident")),
-        })
-    }
-
-    fn unraw(&self) -> Ident {
-        let string = self.to_string();
-        if string.starts_with("r#") {
-            Ident::new(&string[2..], self.span())
-        } else {
-            self.clone()
-        }
-    }
-}
-
-impl Peek for private::PeekFn {
-    type Token = private::IdentAny;
-}
-
-impl CustomToken for private::IdentAny {
-    fn peek(cursor: Cursor) -> bool {
-        cursor.ident().is_some()
-    }
-
-    fn display() -> &'static str {
-        "identifier"
-    }
-}
-
-impl lookahead::Sealed for private::PeekFn {}
-
-mod private {
-    use proc_macro2::Ident;
-
-    pub trait Sealed {}
-
-    impl Sealed for Ident {}
-
-    pub struct PeekFn;
-    pub struct IdentAny;
-
-    impl Copy for PeekFn {}
-    impl Clone for PeekFn {
-        fn clone(&self) -> Self {
-            *self
-        }
-    }
-}
diff --git a/vendor/syn/src/file.rs b/vendor/syn/src/file.rs
deleted file mode 100644
index 280484f9..00000000
--- a/vendor/syn/src/file.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-use super::*;
-
-ast_struct! {
-    /// A complete file of Rust source code.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Example
-    ///
-    /// Parse a Rust source file into a `syn::File` and print out a debug
-    /// representation of the syntax tree.
-    ///
-    /// ```
-    /// use std::env;
-    /// use std::fs::File;
-    /// use std::io::Read;
-    /// use std::process;
-    ///
-    /// fn main() {
-    /// # }
-    /// #
-    /// # fn fake_main() {
-    ///     let mut args = env::args();
-    ///     let _ = args.next(); // executable name
-    ///
-    ///     let filename = match (args.next(), args.next()) {
-    ///         (Some(filename), None) => filename,
-    ///         _ => {
-    ///             eprintln!("Usage: dump-syntax path/to/filename.rs");
-    ///             process::exit(1);
-    ///         }
-    ///     };
-    ///
-    ///     let mut file = File::open(&filename).expect("Unable to open file");
-    ///
-    ///     let mut src = String::new();
-    ///     file.read_to_string(&mut src).expect("Unable to read file");
-    ///
-    ///     let syntax = syn::parse_file(&src).expect("Unable to parse file");
-    ///
-    ///     // Debug impl is available if Syn is built with "extra-traits" feature.
-    ///     println!("{:#?}", syntax);
-    /// }
-    /// ```
-    ///
-    /// Running with its own source code as input, this program prints output
-    /// that begins with:
-    ///
-    /// ```text
-    /// File {
-    ///     shebang: None,
-    ///     attrs: [],
-    ///     items: [
-    ///         Use(
-    ///             ItemUse {
-    ///                 attrs: [],
-    ///                 vis: Inherited,
-    ///                 use_token: Use,
-    ///                 leading_colon: None,
-    ///                 tree: Path(
-    ///                     UsePath {
-    ///                         ident: Ident(
-    ///                             std,
-    ///                         ),
-    ///                         colon2_token: Colon2,
-    ///                         tree: Name(
-    ///                             UseName {
-    ///                                 ident: Ident(
-    ///                                     env,
-    ///                                 ),
-    ///                             },
-    ///                         ),
-    ///                     },
-    ///                 ),
-    ///                 semi_token: Semi,
-    ///             },
-    ///         ),
-    /// ...
-    /// ```
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct File {
-        pub shebang: Option<String>,
-        pub attrs: Vec<Attribute>,
-        pub items: Vec<Item>,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for File {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(File {
-                shebang: None,
-                attrs: input.call(Attribute::parse_inner)?,
-                items: {
-                    let mut items = Vec::new();
-                    while !input.is_empty() {
-                        items.push(input.parse()?);
-                    }
-                    items
-                },
-            })
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for File {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.inner());
-            tokens.append_all(&self.items);
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/clone.rs b/vendor/syn/src/gen/clone.rs
deleted file mode 100644
index 37670f22..00000000
--- a/vendor/syn/src/gen/clone.rs
+++ /dev/null
@@ -1,2234 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#![allow(clippy::clone_on_copy, clippy::expl_impl_clone_on_copy)]
-use crate::*;
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Abi {
-    fn clone(&self) -> Self {
-        Abi {
-            extern_token: self.extern_token.clone(),
-            name: self.name.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AngleBracketedGenericArguments {
-    fn clone(&self) -> Self {
-        AngleBracketedGenericArguments {
-            colon2_token: self.colon2_token.clone(),
-            lt_token: self.lt_token.clone(),
-            args: self.args.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Arm {
-    fn clone(&self) -> Self {
-        Arm {
-            attrs: self.attrs.clone(),
-            pat: self.pat.clone(),
-            guard: self.guard.clone(),
-            fat_arrow_token: self.fat_arrow_token.clone(),
-            body: self.body.clone(),
-            comma: self.comma.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for AttrStyle {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AttrStyle {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Attribute {
-    fn clone(&self) -> Self {
-        Attribute {
-            pound_token: self.pound_token.clone(),
-            style: self.style.clone(),
-            bracket_token: self.bracket_token.clone(),
-            path: self.path.clone(),
-            tokens: self.tokens.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BareFnArg {
-    fn clone(&self) -> Self {
-        BareFnArg {
-            attrs: self.attrs.clone(),
-            name: self.name.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for BinOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BinOp {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Binding {
-    fn clone(&self) -> Self {
-        Binding {
-            ident: self.ident.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Block {
-    fn clone(&self) -> Self {
-        Block {
-            brace_token: self.brace_token.clone(),
-            stmts: self.stmts.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BoundLifetimes {
-    fn clone(&self) -> Self {
-        BoundLifetimes {
-            for_token: self.for_token.clone(),
-            lt_token: self.lt_token.clone(),
-            lifetimes: self.lifetimes.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ConstParam {
-    fn clone(&self) -> Self {
-        ConstParam {
-            attrs: self.attrs.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            default: self.default.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Constraint {
-    fn clone(&self) -> Self {
-        Constraint {
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Data {
-    fn clone(&self) -> Self {
-        match self {
-            Data::Struct(v0) => Data::Struct(v0.clone()),
-            Data::Enum(v0) => Data::Enum(v0.clone()),
-            Data::Union(v0) => Data::Union(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataEnum {
-    fn clone(&self) -> Self {
-        DataEnum {
-            enum_token: self.enum_token.clone(),
-            brace_token: self.brace_token.clone(),
-            variants: self.variants.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataStruct {
-    fn clone(&self) -> Self {
-        DataStruct {
-            struct_token: self.struct_token.clone(),
-            fields: self.fields.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataUnion {
-    fn clone(&self) -> Self {
-        DataUnion {
-            union_token: self.union_token.clone(),
-            fields: self.fields.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DeriveInput {
-    fn clone(&self) -> Self {
-        DeriveInput {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            data: self.data.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Expr {
-    fn clone(&self) -> Self {
-        match self {
-            #[cfg(feature = "full")]
-            Expr::Array(v0) => Expr::Array(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Assign(v0) => Expr::Assign(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::AssignOp(v0) => Expr::AssignOp(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Async(v0) => Expr::Async(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Await(v0) => Expr::Await(v0.clone()),
-            Expr::Binary(v0) => Expr::Binary(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Block(v0) => Expr::Block(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Box(v0) => Expr::Box(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Break(v0) => Expr::Break(v0.clone()),
-            Expr::Call(v0) => Expr::Call(v0.clone()),
-            Expr::Cast(v0) => Expr::Cast(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Closure(v0) => Expr::Closure(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Continue(v0) => Expr::Continue(v0.clone()),
-            Expr::Field(v0) => Expr::Field(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::ForLoop(v0) => Expr::ForLoop(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Group(v0) => Expr::Group(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::If(v0) => Expr::If(v0.clone()),
-            Expr::Index(v0) => Expr::Index(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Let(v0) => Expr::Let(v0.clone()),
-            Expr::Lit(v0) => Expr::Lit(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Loop(v0) => Expr::Loop(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Macro(v0) => Expr::Macro(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Match(v0) => Expr::Match(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::MethodCall(v0) => Expr::MethodCall(v0.clone()),
-            Expr::Paren(v0) => Expr::Paren(v0.clone()),
-            Expr::Path(v0) => Expr::Path(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Range(v0) => Expr::Range(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Reference(v0) => Expr::Reference(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Repeat(v0) => Expr::Repeat(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Return(v0) => Expr::Return(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Struct(v0) => Expr::Struct(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Try(v0) => Expr::Try(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::TryBlock(v0) => Expr::TryBlock(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Tuple(v0) => Expr::Tuple(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Type(v0) => Expr::Type(v0.clone()),
-            Expr::Unary(v0) => Expr::Unary(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Unsafe(v0) => Expr::Unsafe(v0.clone()),
-            Expr::Verbatim(v0) => Expr::Verbatim(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::While(v0) => Expr::While(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Yield(v0) => Expr::Yield(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprArray {
-    fn clone(&self) -> Self {
-        ExprArray {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAssign {
-    fn clone(&self) -> Self {
-        ExprAssign {
-            attrs: self.attrs.clone(),
-            left: self.left.clone(),
-            eq_token: self.eq_token.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAssignOp {
-    fn clone(&self) -> Self {
-        ExprAssignOp {
-            attrs: self.attrs.clone(),
-            left: self.left.clone(),
-            op: self.op.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAsync {
-    fn clone(&self) -> Self {
-        ExprAsync {
-            attrs: self.attrs.clone(),
-            async_token: self.async_token.clone(),
-            capture: self.capture.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAwait {
-    fn clone(&self) -> Self {
-        ExprAwait {
-            attrs: self.attrs.clone(),
-            base: self.base.clone(),
-            dot_token: self.dot_token.clone(),
-            await_token: self.await_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBinary {
-    fn clone(&self) -> Self {
-        ExprBinary {
-            attrs: self.attrs.clone(),
-            left: self.left.clone(),
-            op: self.op.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBlock {
-    fn clone(&self) -> Self {
-        ExprBlock {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBox {
-    fn clone(&self) -> Self {
-        ExprBox {
-            attrs: self.attrs.clone(),
-            box_token: self.box_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBreak {
-    fn clone(&self) -> Self {
-        ExprBreak {
-            attrs: self.attrs.clone(),
-            break_token: self.break_token.clone(),
-            label: self.label.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprCall {
-    fn clone(&self) -> Self {
-        ExprCall {
-            attrs: self.attrs.clone(),
-            func: self.func.clone(),
-            paren_token: self.paren_token.clone(),
-            args: self.args.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprCast {
-    fn clone(&self) -> Self {
-        ExprCast {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            as_token: self.as_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprClosure {
-    fn clone(&self) -> Self {
-        ExprClosure {
-            attrs: self.attrs.clone(),
-            asyncness: self.asyncness.clone(),
-            movability: self.movability.clone(),
-            capture: self.capture.clone(),
-            or1_token: self.or1_token.clone(),
-            inputs: self.inputs.clone(),
-            or2_token: self.or2_token.clone(),
-            output: self.output.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprContinue {
-    fn clone(&self) -> Self {
-        ExprContinue {
-            attrs: self.attrs.clone(),
-            continue_token: self.continue_token.clone(),
-            label: self.label.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprField {
-    fn clone(&self) -> Self {
-        ExprField {
-            attrs: self.attrs.clone(),
-            base: self.base.clone(),
-            dot_token: self.dot_token.clone(),
-            member: self.member.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprForLoop {
-    fn clone(&self) -> Self {
-        ExprForLoop {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            for_token: self.for_token.clone(),
-            pat: self.pat.clone(),
-            in_token: self.in_token.clone(),
-            expr: self.expr.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprGroup {
-    fn clone(&self) -> Self {
-        ExprGroup {
-            attrs: self.attrs.clone(),
-            group_token: self.group_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprIf {
-    fn clone(&self) -> Self {
-        ExprIf {
-            attrs: self.attrs.clone(),
-            if_token: self.if_token.clone(),
-            cond: self.cond.clone(),
-            then_branch: self.then_branch.clone(),
-            else_branch: self.else_branch.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprIndex {
-    fn clone(&self) -> Self {
-        ExprIndex {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            bracket_token: self.bracket_token.clone(),
-            index: self.index.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLet {
-    fn clone(&self) -> Self {
-        ExprLet {
-            attrs: self.attrs.clone(),
-            let_token: self.let_token.clone(),
-            pat: self.pat.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLit {
-    fn clone(&self) -> Self {
-        ExprLit {
-            attrs: self.attrs.clone(),
-            lit: self.lit.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLoop {
-    fn clone(&self) -> Self {
-        ExprLoop {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            loop_token: self.loop_token.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMacro {
-    fn clone(&self) -> Self {
-        ExprMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMatch {
-    fn clone(&self) -> Self {
-        ExprMatch {
-            attrs: self.attrs.clone(),
-            match_token: self.match_token.clone(),
-            expr: self.expr.clone(),
-            brace_token: self.brace_token.clone(),
-            arms: self.arms.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMethodCall {
-    fn clone(&self) -> Self {
-        ExprMethodCall {
-            attrs: self.attrs.clone(),
-            receiver: self.receiver.clone(),
-            dot_token: self.dot_token.clone(),
-            method: self.method.clone(),
-            turbofish: self.turbofish.clone(),
-            paren_token: self.paren_token.clone(),
-            args: self.args.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprParen {
-    fn clone(&self) -> Self {
-        ExprParen {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprPath {
-    fn clone(&self) -> Self {
-        ExprPath {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprRange {
-    fn clone(&self) -> Self {
-        ExprRange {
-            attrs: self.attrs.clone(),
-            from: self.from.clone(),
-            limits: self.limits.clone(),
-            to: self.to.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprReference {
-    fn clone(&self) -> Self {
-        ExprReference {
-            attrs: self.attrs.clone(),
-            and_token: self.and_token.clone(),
-            raw: self.raw.clone(),
-            mutability: self.mutability.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprRepeat {
-    fn clone(&self) -> Self {
-        ExprRepeat {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-            len: self.len.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprReturn {
-    fn clone(&self) -> Self {
-        ExprReturn {
-            attrs: self.attrs.clone(),
-            return_token: self.return_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprStruct {
-    fn clone(&self) -> Self {
-        ExprStruct {
-            attrs: self.attrs.clone(),
-            path: self.path.clone(),
-            brace_token: self.brace_token.clone(),
-            fields: self.fields.clone(),
-            dot2_token: self.dot2_token.clone(),
-            rest: self.rest.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTry {
-    fn clone(&self) -> Self {
-        ExprTry {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            question_token: self.question_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTryBlock {
-    fn clone(&self) -> Self {
-        ExprTryBlock {
-            attrs: self.attrs.clone(),
-            try_token: self.try_token.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTuple {
-    fn clone(&self) -> Self {
-        ExprTuple {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprType {
-    fn clone(&self) -> Self {
-        ExprType {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprUnary {
-    fn clone(&self) -> Self {
-        ExprUnary {
-            attrs: self.attrs.clone(),
-            op: self.op.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprUnsafe {
-    fn clone(&self) -> Self {
-        ExprUnsafe {
-            attrs: self.attrs.clone(),
-            unsafe_token: self.unsafe_token.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprWhile {
-    fn clone(&self) -> Self {
-        ExprWhile {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            while_token: self.while_token.clone(),
-            cond: self.cond.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprYield {
-    fn clone(&self) -> Self {
-        ExprYield {
-            attrs: self.attrs.clone(),
-            yield_token: self.yield_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Field {
-    fn clone(&self) -> Self {
-        Field {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldPat {
-    fn clone(&self) -> Self {
-        FieldPat {
-            attrs: self.attrs.clone(),
-            member: self.member.clone(),
-            colon_token: self.colon_token.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldValue {
-    fn clone(&self) -> Self {
-        FieldValue {
-            attrs: self.attrs.clone(),
-            member: self.member.clone(),
-            colon_token: self.colon_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Fields {
-    fn clone(&self) -> Self {
-        match self {
-            Fields::Named(v0) => Fields::Named(v0.clone()),
-            Fields::Unnamed(v0) => Fields::Unnamed(v0.clone()),
-            Fields::Unit => Fields::Unit,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldsNamed {
-    fn clone(&self) -> Self {
-        FieldsNamed {
-            brace_token: self.brace_token.clone(),
-            named: self.named.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldsUnnamed {
-    fn clone(&self) -> Self {
-        FieldsUnnamed {
-            paren_token: self.paren_token.clone(),
-            unnamed: self.unnamed.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for File {
-    fn clone(&self) -> Self {
-        File {
-            shebang: self.shebang.clone(),
-            attrs: self.attrs.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FnArg {
-    fn clone(&self) -> Self {
-        match self {
-            FnArg::Receiver(v0) => FnArg::Receiver(v0.clone()),
-            FnArg::Typed(v0) => FnArg::Typed(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItem {
-    fn clone(&self) -> Self {
-        match self {
-            ForeignItem::Fn(v0) => ForeignItem::Fn(v0.clone()),
-            ForeignItem::Static(v0) => ForeignItem::Static(v0.clone()),
-            ForeignItem::Type(v0) => ForeignItem::Type(v0.clone()),
-            ForeignItem::Macro(v0) => ForeignItem::Macro(v0.clone()),
-            ForeignItem::Verbatim(v0) => ForeignItem::Verbatim(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemFn {
-    fn clone(&self) -> Self {
-        ForeignItemFn {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            sig: self.sig.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemMacro {
-    fn clone(&self) -> Self {
-        ForeignItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemStatic {
-    fn clone(&self) -> Self {
-        ForeignItemStatic {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            static_token: self.static_token.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemType {
-    fn clone(&self) -> Self {
-        ForeignItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for GenericArgument {
-    fn clone(&self) -> Self {
-        match self {
-            GenericArgument::Lifetime(v0) => GenericArgument::Lifetime(v0.clone()),
-            GenericArgument::Type(v0) => GenericArgument::Type(v0.clone()),
-            GenericArgument::Binding(v0) => GenericArgument::Binding(v0.clone()),
-            GenericArgument::Constraint(v0) => GenericArgument::Constraint(v0.clone()),
-            GenericArgument::Const(v0) => GenericArgument::Const(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for GenericMethodArgument {
-    fn clone(&self) -> Self {
-        match self {
-            GenericMethodArgument::Type(v0) => GenericMethodArgument::Type(v0.clone()),
-            GenericMethodArgument::Const(v0) => GenericMethodArgument::Const(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for GenericParam {
-    fn clone(&self) -> Self {
-        match self {
-            GenericParam::Type(v0) => GenericParam::Type(v0.clone()),
-            GenericParam::Lifetime(v0) => GenericParam::Lifetime(v0.clone()),
-            GenericParam::Const(v0) => GenericParam::Const(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Generics {
-    fn clone(&self) -> Self {
-        Generics {
-            lt_token: self.lt_token.clone(),
-            params: self.params.clone(),
-            gt_token: self.gt_token.clone(),
-            where_clause: self.where_clause.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItem {
-    fn clone(&self) -> Self {
-        match self {
-            ImplItem::Const(v0) => ImplItem::Const(v0.clone()),
-            ImplItem::Method(v0) => ImplItem::Method(v0.clone()),
-            ImplItem::Type(v0) => ImplItem::Type(v0.clone()),
-            ImplItem::Macro(v0) => ImplItem::Macro(v0.clone()),
-            ImplItem::Verbatim(v0) => ImplItem::Verbatim(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemConst {
-    fn clone(&self) -> Self {
-        ImplItemConst {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemMacro {
-    fn clone(&self) -> Self {
-        ImplItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemMethod {
-    fn clone(&self) -> Self {
-        ImplItemMethod {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            sig: self.sig.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemType {
-    fn clone(&self) -> Self {
-        ImplItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Index {
-    fn clone(&self) -> Self {
-        Index {
-            index: self.index.clone(),
-            span: self.span.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Item {
-    fn clone(&self) -> Self {
-        match self {
-            Item::Const(v0) => Item::Const(v0.clone()),
-            Item::Enum(v0) => Item::Enum(v0.clone()),
-            Item::ExternCrate(v0) => Item::ExternCrate(v0.clone()),
-            Item::Fn(v0) => Item::Fn(v0.clone()),
-            Item::ForeignMod(v0) => Item::ForeignMod(v0.clone()),
-            Item::Impl(v0) => Item::Impl(v0.clone()),
-            Item::Macro(v0) => Item::Macro(v0.clone()),
-            Item::Macro2(v0) => Item::Macro2(v0.clone()),
-            Item::Mod(v0) => Item::Mod(v0.clone()),
-            Item::Static(v0) => Item::Static(v0.clone()),
-            Item::Struct(v0) => Item::Struct(v0.clone()),
-            Item::Trait(v0) => Item::Trait(v0.clone()),
-            Item::TraitAlias(v0) => Item::TraitAlias(v0.clone()),
-            Item::Type(v0) => Item::Type(v0.clone()),
-            Item::Union(v0) => Item::Union(v0.clone()),
-            Item::Use(v0) => Item::Use(v0.clone()),
-            Item::Verbatim(v0) => Item::Verbatim(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemConst {
-    fn clone(&self) -> Self {
-        ItemConst {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemEnum {
-    fn clone(&self) -> Self {
-        ItemEnum {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            enum_token: self.enum_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            brace_token: self.brace_token.clone(),
-            variants: self.variants.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemExternCrate {
-    fn clone(&self) -> Self {
-        ItemExternCrate {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            extern_token: self.extern_token.clone(),
-            crate_token: self.crate_token.clone(),
-            ident: self.ident.clone(),
-            rename: self.rename.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemFn {
-    fn clone(&self) -> Self {
-        ItemFn {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            sig: self.sig.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemForeignMod {
-    fn clone(&self) -> Self {
-        ItemForeignMod {
-            attrs: self.attrs.clone(),
-            abi: self.abi.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemImpl {
-    fn clone(&self) -> Self {
-        ItemImpl {
-            attrs: self.attrs.clone(),
-            defaultness: self.defaultness.clone(),
-            unsafety: self.unsafety.clone(),
-            impl_token: self.impl_token.clone(),
-            generics: self.generics.clone(),
-            trait_: self.trait_.clone(),
-            self_ty: self.self_ty.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemMacro {
-    fn clone(&self) -> Self {
-        ItemMacro {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemMacro2 {
-    fn clone(&self) -> Self {
-        ItemMacro2 {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            macro_token: self.macro_token.clone(),
-            ident: self.ident.clone(),
-            rules: self.rules.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemMod {
-    fn clone(&self) -> Self {
-        ItemMod {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            mod_token: self.mod_token.clone(),
-            ident: self.ident.clone(),
-            content: self.content.clone(),
-            semi: self.semi.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemStatic {
-    fn clone(&self) -> Self {
-        ItemStatic {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            static_token: self.static_token.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemStruct {
-    fn clone(&self) -> Self {
-        ItemStruct {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            struct_token: self.struct_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            fields: self.fields.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemTrait {
-    fn clone(&self) -> Self {
-        ItemTrait {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            unsafety: self.unsafety.clone(),
-            auto_token: self.auto_token.clone(),
-            trait_token: self.trait_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            supertraits: self.supertraits.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemTraitAlias {
-    fn clone(&self) -> Self {
-        ItemTraitAlias {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            trait_token: self.trait_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            bounds: self.bounds.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemType {
-    fn clone(&self) -> Self {
-        ItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemUnion {
-    fn clone(&self) -> Self {
-        ItemUnion {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            union_token: self.union_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            fields: self.fields.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemUse {
-    fn clone(&self) -> Self {
-        ItemUse {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            use_token: self.use_token.clone(),
-            leading_colon: self.leading_colon.clone(),
-            tree: self.tree.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Label {
-    fn clone(&self) -> Self {
-        Label {
-            name: self.name.clone(),
-            colon_token: self.colon_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LifetimeDef {
-    fn clone(&self) -> Self {
-        LifetimeDef {
-            attrs: self.attrs.clone(),
-            lifetime: self.lifetime.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Lit {
-    fn clone(&self) -> Self {
-        match self {
-            Lit::Str(v0) => Lit::Str(v0.clone()),
-            Lit::ByteStr(v0) => Lit::ByteStr(v0.clone()),
-            Lit::Byte(v0) => Lit::Byte(v0.clone()),
-            Lit::Char(v0) => Lit::Char(v0.clone()),
-            Lit::Int(v0) => Lit::Int(v0.clone()),
-            Lit::Float(v0) => Lit::Float(v0.clone()),
-            Lit::Bool(v0) => Lit::Bool(v0.clone()),
-            Lit::Verbatim(v0) => Lit::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LitBool {
-    fn clone(&self) -> Self {
-        LitBool {
-            value: self.value.clone(),
-            span: self.span.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Local {
-    fn clone(&self) -> Self {
-        Local {
-            attrs: self.attrs.clone(),
-            let_token: self.let_token.clone(),
-            pat: self.pat.clone(),
-            init: self.init.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Macro {
-    fn clone(&self) -> Self {
-        Macro {
-            path: self.path.clone(),
-            bang_token: self.bang_token.clone(),
-            delimiter: self.delimiter.clone(),
-            tokens: self.tokens.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MacroDelimiter {
-    fn clone(&self) -> Self {
-        match self {
-            MacroDelimiter::Paren(v0) => MacroDelimiter::Paren(v0.clone()),
-            MacroDelimiter::Brace(v0) => MacroDelimiter::Brace(v0.clone()),
-            MacroDelimiter::Bracket(v0) => MacroDelimiter::Bracket(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Member {
-    fn clone(&self) -> Self {
-        match self {
-            Member::Named(v0) => Member::Named(v0.clone()),
-            Member::Unnamed(v0) => Member::Unnamed(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Meta {
-    fn clone(&self) -> Self {
-        match self {
-            Meta::Path(v0) => Meta::Path(v0.clone()),
-            Meta::List(v0) => Meta::List(v0.clone()),
-            Meta::NameValue(v0) => Meta::NameValue(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MetaList {
-    fn clone(&self) -> Self {
-        MetaList {
-            path: self.path.clone(),
-            paren_token: self.paren_token.clone(),
-            nested: self.nested.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MetaNameValue {
-    fn clone(&self) -> Self {
-        MetaNameValue {
-            path: self.path.clone(),
-            eq_token: self.eq_token.clone(),
-            lit: self.lit.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MethodTurbofish {
-    fn clone(&self) -> Self {
-        MethodTurbofish {
-            colon2_token: self.colon2_token.clone(),
-            lt_token: self.lt_token.clone(),
-            args: self.args.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for NestedMeta {
-    fn clone(&self) -> Self {
-        match self {
-            NestedMeta::Meta(v0) => NestedMeta::Meta(v0.clone()),
-            NestedMeta::Lit(v0) => NestedMeta::Lit(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ParenthesizedGenericArguments {
-    fn clone(&self) -> Self {
-        ParenthesizedGenericArguments {
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Pat {
-    fn clone(&self) -> Self {
-        match self {
-            Pat::Box(v0) => Pat::Box(v0.clone()),
-            Pat::Ident(v0) => Pat::Ident(v0.clone()),
-            Pat::Lit(v0) => Pat::Lit(v0.clone()),
-            Pat::Macro(v0) => Pat::Macro(v0.clone()),
-            Pat::Or(v0) => Pat::Or(v0.clone()),
-            Pat::Path(v0) => Pat::Path(v0.clone()),
-            Pat::Range(v0) => Pat::Range(v0.clone()),
-            Pat::Reference(v0) => Pat::Reference(v0.clone()),
-            Pat::Rest(v0) => Pat::Rest(v0.clone()),
-            Pat::Slice(v0) => Pat::Slice(v0.clone()),
-            Pat::Struct(v0) => Pat::Struct(v0.clone()),
-            Pat::Tuple(v0) => Pat::Tuple(v0.clone()),
-            Pat::TupleStruct(v0) => Pat::TupleStruct(v0.clone()),
-            Pat::Type(v0) => Pat::Type(v0.clone()),
-            Pat::Verbatim(v0) => Pat::Verbatim(v0.clone()),
-            Pat::Wild(v0) => Pat::Wild(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatBox {
-    fn clone(&self) -> Self {
-        PatBox {
-            attrs: self.attrs.clone(),
-            box_token: self.box_token.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatIdent {
-    fn clone(&self) -> Self {
-        PatIdent {
-            attrs: self.attrs.clone(),
-            by_ref: self.by_ref.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            subpat: self.subpat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatLit {
-    fn clone(&self) -> Self {
-        PatLit {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatMacro {
-    fn clone(&self) -> Self {
-        PatMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatOr {
-    fn clone(&self) -> Self {
-        PatOr {
-            attrs: self.attrs.clone(),
-            leading_vert: self.leading_vert.clone(),
-            cases: self.cases.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatPath {
-    fn clone(&self) -> Self {
-        PatPath {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatRange {
-    fn clone(&self) -> Self {
-        PatRange {
-            attrs: self.attrs.clone(),
-            lo: self.lo.clone(),
-            limits: self.limits.clone(),
-            hi: self.hi.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatReference {
-    fn clone(&self) -> Self {
-        PatReference {
-            attrs: self.attrs.clone(),
-            and_token: self.and_token.clone(),
-            mutability: self.mutability.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatRest {
-    fn clone(&self) -> Self {
-        PatRest {
-            attrs: self.attrs.clone(),
-            dot2_token: self.dot2_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatSlice {
-    fn clone(&self) -> Self {
-        PatSlice {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatStruct {
-    fn clone(&self) -> Self {
-        PatStruct {
-            attrs: self.attrs.clone(),
-            path: self.path.clone(),
-            brace_token: self.brace_token.clone(),
-            fields: self.fields.clone(),
-            dot2_token: self.dot2_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatTuple {
-    fn clone(&self) -> Self {
-        PatTuple {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatTupleStruct {
-    fn clone(&self) -> Self {
-        PatTupleStruct {
-            attrs: self.attrs.clone(),
-            path: self.path.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatType {
-    fn clone(&self) -> Self {
-        PatType {
-            attrs: self.attrs.clone(),
-            pat: self.pat.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatWild {
-    fn clone(&self) -> Self {
-        PatWild {
-            attrs: self.attrs.clone(),
-            underscore_token: self.underscore_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Path {
-    fn clone(&self) -> Self {
-        Path {
-            leading_colon: self.leading_colon.clone(),
-            segments: self.segments.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PathArguments {
-    fn clone(&self) -> Self {
-        match self {
-            PathArguments::None => PathArguments::None,
-            PathArguments::AngleBracketed(v0) => PathArguments::AngleBracketed(v0.clone()),
-            PathArguments::Parenthesized(v0) => PathArguments::Parenthesized(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PathSegment {
-    fn clone(&self) -> Self {
-        PathSegment {
-            ident: self.ident.clone(),
-            arguments: self.arguments.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PredicateEq {
-    fn clone(&self) -> Self {
-        PredicateEq {
-            lhs_ty: self.lhs_ty.clone(),
-            eq_token: self.eq_token.clone(),
-            rhs_ty: self.rhs_ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PredicateLifetime {
-    fn clone(&self) -> Self {
-        PredicateLifetime {
-            lifetime: self.lifetime.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PredicateType {
-    fn clone(&self) -> Self {
-        PredicateType {
-            lifetimes: self.lifetimes.clone(),
-            bounded_ty: self.bounded_ty.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for QSelf {
-    fn clone(&self) -> Self {
-        QSelf {
-            lt_token: self.lt_token.clone(),
-            ty: self.ty.clone(),
-            position: self.position.clone(),
-            as_token: self.as_token.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for RangeLimits {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for RangeLimits {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Receiver {
-    fn clone(&self) -> Self {
-        Receiver {
-            attrs: self.attrs.clone(),
-            reference: self.reference.clone(),
-            mutability: self.mutability.clone(),
-            self_token: self.self_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ReturnType {
-    fn clone(&self) -> Self {
-        match self {
-            ReturnType::Default => ReturnType::Default,
-            ReturnType::Type(v0, v1) => ReturnType::Type(v0.clone(), v1.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Signature {
-    fn clone(&self) -> Self {
-        Signature {
-            constness: self.constness.clone(),
-            asyncness: self.asyncness.clone(),
-            unsafety: self.unsafety.clone(),
-            abi: self.abi.clone(),
-            fn_token: self.fn_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            variadic: self.variadic.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Stmt {
-    fn clone(&self) -> Self {
-        match self {
-            Stmt::Local(v0) => Stmt::Local(v0.clone()),
-            Stmt::Item(v0) => Stmt::Item(v0.clone()),
-            Stmt::Expr(v0) => Stmt::Expr(v0.clone()),
-            Stmt::Semi(v0, v1) => Stmt::Semi(v0.clone(), v1.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitBound {
-    fn clone(&self) -> Self {
-        TraitBound {
-            paren_token: self.paren_token.clone(),
-            modifier: self.modifier.clone(),
-            lifetimes: self.lifetimes.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for TraitBoundModifier {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitBoundModifier {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItem {
-    fn clone(&self) -> Self {
-        match self {
-            TraitItem::Const(v0) => TraitItem::Const(v0.clone()),
-            TraitItem::Method(v0) => TraitItem::Method(v0.clone()),
-            TraitItem::Type(v0) => TraitItem::Type(v0.clone()),
-            TraitItem::Macro(v0) => TraitItem::Macro(v0.clone()),
-            TraitItem::Verbatim(v0) => TraitItem::Verbatim(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemConst {
-    fn clone(&self) -> Self {
-        TraitItemConst {
-            attrs: self.attrs.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemMacro {
-    fn clone(&self) -> Self {
-        TraitItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemMethod {
-    fn clone(&self) -> Self {
-        TraitItemMethod {
-            attrs: self.attrs.clone(),
-            sig: self.sig.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemType {
-    fn clone(&self) -> Self {
-        TraitItemType {
-            attrs: self.attrs.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Type {
-    fn clone(&self) -> Self {
-        match self {
-            Type::Array(v0) => Type::Array(v0.clone()),
-            Type::BareFn(v0) => Type::BareFn(v0.clone()),
-            Type::Group(v0) => Type::Group(v0.clone()),
-            Type::ImplTrait(v0) => Type::ImplTrait(v0.clone()),
-            Type::Infer(v0) => Type::Infer(v0.clone()),
-            Type::Macro(v0) => Type::Macro(v0.clone()),
-            Type::Never(v0) => Type::Never(v0.clone()),
-            Type::Paren(v0) => Type::Paren(v0.clone()),
-            Type::Path(v0) => Type::Path(v0.clone()),
-            Type::Ptr(v0) => Type::Ptr(v0.clone()),
-            Type::Reference(v0) => Type::Reference(v0.clone()),
-            Type::Slice(v0) => Type::Slice(v0.clone()),
-            Type::TraitObject(v0) => Type::TraitObject(v0.clone()),
-            Type::Tuple(v0) => Type::Tuple(v0.clone()),
-            Type::Verbatim(v0) => Type::Verbatim(v0.clone()),
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeArray {
-    fn clone(&self) -> Self {
-        TypeArray {
-            bracket_token: self.bracket_token.clone(),
-            elem: self.elem.clone(),
-            semi_token: self.semi_token.clone(),
-            len: self.len.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeBareFn {
-    fn clone(&self) -> Self {
-        TypeBareFn {
-            lifetimes: self.lifetimes.clone(),
-            unsafety: self.unsafety.clone(),
-            abi: self.abi.clone(),
-            fn_token: self.fn_token.clone(),
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            variadic: self.variadic.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeGroup {
-    fn clone(&self) -> Self {
-        TypeGroup {
-            group_token: self.group_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeImplTrait {
-    fn clone(&self) -> Self {
-        TypeImplTrait {
-            impl_token: self.impl_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeInfer {
-    fn clone(&self) -> Self {
-        TypeInfer {
-            underscore_token: self.underscore_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeMacro {
-    fn clone(&self) -> Self {
-        TypeMacro {
-            mac: self.mac.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeNever {
-    fn clone(&self) -> Self {
-        TypeNever {
-            bang_token: self.bang_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParam {
-    fn clone(&self) -> Self {
-        TypeParam {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-            eq_token: self.eq_token.clone(),
-            default: self.default.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParamBound {
-    fn clone(&self) -> Self {
-        match self {
-            TypeParamBound::Trait(v0) => TypeParamBound::Trait(v0.clone()),
-            TypeParamBound::Lifetime(v0) => TypeParamBound::Lifetime(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParen {
-    fn clone(&self) -> Self {
-        TypeParen {
-            paren_token: self.paren_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypePath {
-    fn clone(&self) -> Self {
-        TypePath {
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypePtr {
-    fn clone(&self) -> Self {
-        TypePtr {
-            star_token: self.star_token.clone(),
-            const_token: self.const_token.clone(),
-            mutability: self.mutability.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeReference {
-    fn clone(&self) -> Self {
-        TypeReference {
-            and_token: self.and_token.clone(),
-            lifetime: self.lifetime.clone(),
-            mutability: self.mutability.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeSlice {
-    fn clone(&self) -> Self {
-        TypeSlice {
-            bracket_token: self.bracket_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeTraitObject {
-    fn clone(&self) -> Self {
-        TypeTraitObject {
-            dyn_token: self.dyn_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeTuple {
-    fn clone(&self) -> Self {
-        TypeTuple {
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for UnOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UnOp {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseGlob {
-    fn clone(&self) -> Self {
-        UseGlob {
-            star_token: self.star_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseGroup {
-    fn clone(&self) -> Self {
-        UseGroup {
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseName {
-    fn clone(&self) -> Self {
-        UseName {
-            ident: self.ident.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UsePath {
-    fn clone(&self) -> Self {
-        UsePath {
-            ident: self.ident.clone(),
-            colon2_token: self.colon2_token.clone(),
-            tree: self.tree.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseRename {
-    fn clone(&self) -> Self {
-        UseRename {
-            ident: self.ident.clone(),
-            as_token: self.as_token.clone(),
-            rename: self.rename.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseTree {
-    fn clone(&self) -> Self {
-        match self {
-            UseTree::Path(v0) => UseTree::Path(v0.clone()),
-            UseTree::Name(v0) => UseTree::Name(v0.clone()),
-            UseTree::Rename(v0) => UseTree::Rename(v0.clone()),
-            UseTree::Glob(v0) => UseTree::Glob(v0.clone()),
-            UseTree::Group(v0) => UseTree::Group(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Variadic {
-    fn clone(&self) -> Self {
-        Variadic {
-            attrs: self.attrs.clone(),
-            dots: self.dots.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Variant {
-    fn clone(&self) -> Self {
-        Variant {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            fields: self.fields.clone(),
-            discriminant: self.discriminant.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for VisCrate {
-    fn clone(&self) -> Self {
-        VisCrate {
-            crate_token: self.crate_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for VisPublic {
-    fn clone(&self) -> Self {
-        VisPublic {
-            pub_token: self.pub_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for VisRestricted {
-    fn clone(&self) -> Self {
-        VisRestricted {
-            pub_token: self.pub_token.clone(),
-            paren_token: self.paren_token.clone(),
-            in_token: self.in_token.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Visibility {
-    fn clone(&self) -> Self {
-        match self {
-            Visibility::Public(v0) => Visibility::Public(v0.clone()),
-            Visibility::Crate(v0) => Visibility::Crate(v0.clone()),
-            Visibility::Restricted(v0) => Visibility::Restricted(v0.clone()),
-            Visibility::Inherited => Visibility::Inherited,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for WhereClause {
-    fn clone(&self) -> Self {
-        WhereClause {
-            where_token: self.where_token.clone(),
-            predicates: self.predicates.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for WherePredicate {
-    fn clone(&self) -> Self {
-        match self {
-            WherePredicate::Type(v0) => WherePredicate::Type(v0.clone()),
-            WherePredicate::Lifetime(v0) => WherePredicate::Lifetime(v0.clone()),
-            WherePredicate::Eq(v0) => WherePredicate::Eq(v0.clone()),
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/debug.rs b/vendor/syn/src/gen/debug.rs
deleted file mode 100644
index 3efa2788..00000000
--- a/vendor/syn/src/gen/debug.rs
+++ /dev/null
@@ -1,3035 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-use crate::*;
-use std::fmt::{self, Debug};
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Abi {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Abi");
-        formatter.field("extern_token", &self.extern_token);
-        formatter.field("name", &self.name);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for AngleBracketedGenericArguments {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
-        formatter.field("colon2_token", &self.colon2_token);
-        formatter.field("lt_token", &self.lt_token);
-        formatter.field("args", &self.args);
-        formatter.field("gt_token", &self.gt_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Arm {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Arm");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("pat", &self.pat);
-        formatter.field("guard", &self.guard);
-        formatter.field("fat_arrow_token", &self.fat_arrow_token);
-        formatter.field("body", &self.body);
-        formatter.field("comma", &self.comma);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for AttrStyle {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            AttrStyle::Outer => formatter.write_str("Outer"),
-            AttrStyle::Inner(v0) => {
-                let mut formatter = formatter.debug_tuple("Inner");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Attribute {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Attribute");
-        formatter.field("pound_token", &self.pound_token);
-        formatter.field("style", &self.style);
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("path", &self.path);
-        formatter.field("tokens", &self.tokens);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for BareFnArg {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("BareFnArg");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("name", &self.name);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for BinOp {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            BinOp::Add(v0) => {
-                let mut formatter = formatter.debug_tuple("Add");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Sub(v0) => {
-                let mut formatter = formatter.debug_tuple("Sub");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Mul(v0) => {
-                let mut formatter = formatter.debug_tuple("Mul");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Div(v0) => {
-                let mut formatter = formatter.debug_tuple("Div");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Rem(v0) => {
-                let mut formatter = formatter.debug_tuple("Rem");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::And(v0) => {
-                let mut formatter = formatter.debug_tuple("And");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Or(v0) => {
-                let mut formatter = formatter.debug_tuple("Or");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitXor(v0) => {
-                let mut formatter = formatter.debug_tuple("BitXor");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitAnd(v0) => {
-                let mut formatter = formatter.debug_tuple("BitAnd");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitOr(v0) => {
-                let mut formatter = formatter.debug_tuple("BitOr");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Shl(v0) => {
-                let mut formatter = formatter.debug_tuple("Shl");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Shr(v0) => {
-                let mut formatter = formatter.debug_tuple("Shr");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Eq(v0) => {
-                let mut formatter = formatter.debug_tuple("Eq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Lt(v0) => {
-                let mut formatter = formatter.debug_tuple("Lt");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Le(v0) => {
-                let mut formatter = formatter.debug_tuple("Le");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Ne(v0) => {
-                let mut formatter = formatter.debug_tuple("Ne");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Ge(v0) => {
-                let mut formatter = formatter.debug_tuple("Ge");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::Gt(v0) => {
-                let mut formatter = formatter.debug_tuple("Gt");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::AddEq(v0) => {
-                let mut formatter = formatter.debug_tuple("AddEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::SubEq(v0) => {
-                let mut formatter = formatter.debug_tuple("SubEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::MulEq(v0) => {
-                let mut formatter = formatter.debug_tuple("MulEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::DivEq(v0) => {
-                let mut formatter = formatter.debug_tuple("DivEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::RemEq(v0) => {
-                let mut formatter = formatter.debug_tuple("RemEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitXorEq(v0) => {
-                let mut formatter = formatter.debug_tuple("BitXorEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitAndEq(v0) => {
-                let mut formatter = formatter.debug_tuple("BitAndEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::BitOrEq(v0) => {
-                let mut formatter = formatter.debug_tuple("BitOrEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::ShlEq(v0) => {
-                let mut formatter = formatter.debug_tuple("ShlEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            BinOp::ShrEq(v0) => {
-                let mut formatter = formatter.debug_tuple("ShrEq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Binding {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Binding");
-        formatter.field("ident", &self.ident);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Block {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Block");
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("stmts", &self.stmts);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for BoundLifetimes {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("BoundLifetimes");
-        formatter.field("for_token", &self.for_token);
-        formatter.field("lt_token", &self.lt_token);
-        formatter.field("lifetimes", &self.lifetimes);
-        formatter.field("gt_token", &self.gt_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ConstParam {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ConstParam");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("const_token", &self.const_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("default", &self.default);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Constraint {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Constraint");
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Data {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Data::Struct(v0) => {
-                let mut formatter = formatter.debug_tuple("Struct");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Data::Enum(v0) => {
-                let mut formatter = formatter.debug_tuple("Enum");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Data::Union(v0) => {
-                let mut formatter = formatter.debug_tuple("Union");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for DataEnum {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("DataEnum");
-        formatter.field("enum_token", &self.enum_token);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("variants", &self.variants);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for DataStruct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("DataStruct");
-        formatter.field("struct_token", &self.struct_token);
-        formatter.field("fields", &self.fields);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for DataUnion {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("DataUnion");
-        formatter.field("union_token", &self.union_token);
-        formatter.field("fields", &self.fields);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for DeriveInput {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("DeriveInput");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("data", &self.data);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Expr {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            #[cfg(feature = "full")]
-            Expr::Array(v0) => {
-                let mut formatter = formatter.debug_tuple("Array");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Assign(v0) => {
-                let mut formatter = formatter.debug_tuple("Assign");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::AssignOp(v0) => {
-                let mut formatter = formatter.debug_tuple("AssignOp");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Async(v0) => {
-                let mut formatter = formatter.debug_tuple("Async");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Await(v0) => {
-                let mut formatter = formatter.debug_tuple("Await");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Binary(v0) => {
-                let mut formatter = formatter.debug_tuple("Binary");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Block(v0) => {
-                let mut formatter = formatter.debug_tuple("Block");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Box(v0) => {
-                let mut formatter = formatter.debug_tuple("Box");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Break(v0) => {
-                let mut formatter = formatter.debug_tuple("Break");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Call(v0) => {
-                let mut formatter = formatter.debug_tuple("Call");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Cast(v0) => {
-                let mut formatter = formatter.debug_tuple("Cast");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Closure(v0) => {
-                let mut formatter = formatter.debug_tuple("Closure");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Continue(v0) => {
-                let mut formatter = formatter.debug_tuple("Continue");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Field(v0) => {
-                let mut formatter = formatter.debug_tuple("Field");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::ForLoop(v0) => {
-                let mut formatter = formatter.debug_tuple("ForLoop");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Group(v0) => {
-                let mut formatter = formatter.debug_tuple("Group");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::If(v0) => {
-                let mut formatter = formatter.debug_tuple("If");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Index(v0) => {
-                let mut formatter = formatter.debug_tuple("Index");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Let(v0) => {
-                let mut formatter = formatter.debug_tuple("Let");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Lit(v0) => {
-                let mut formatter = formatter.debug_tuple("Lit");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Loop(v0) => {
-                let mut formatter = formatter.debug_tuple("Loop");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Match(v0) => {
-                let mut formatter = formatter.debug_tuple("Match");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::MethodCall(v0) => {
-                let mut formatter = formatter.debug_tuple("MethodCall");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Paren(v0) => {
-                let mut formatter = formatter.debug_tuple("Paren");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Path(v0) => {
-                let mut formatter = formatter.debug_tuple("Path");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Range(v0) => {
-                let mut formatter = formatter.debug_tuple("Range");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Reference(v0) => {
-                let mut formatter = formatter.debug_tuple("Reference");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Repeat(v0) => {
-                let mut formatter = formatter.debug_tuple("Repeat");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Return(v0) => {
-                let mut formatter = formatter.debug_tuple("Return");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Struct(v0) => {
-                let mut formatter = formatter.debug_tuple("Struct");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Try(v0) => {
-                let mut formatter = formatter.debug_tuple("Try");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::TryBlock(v0) => {
-                let mut formatter = formatter.debug_tuple("TryBlock");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Tuple(v0) => {
-                let mut formatter = formatter.debug_tuple("Tuple");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Unary(v0) => {
-                let mut formatter = formatter.debug_tuple("Unary");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Unsafe(v0) => {
-                let mut formatter = formatter.debug_tuple("Unsafe");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Expr::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::While(v0) => {
-                let mut formatter = formatter.debug_tuple("While");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            #[cfg(feature = "full")]
-            Expr::Yield(v0) => {
-                let mut formatter = formatter.debug_tuple("Yield");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprArray {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprArray");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("elems", &self.elems);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprAssign {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprAssign");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("left", &self.left);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("right", &self.right);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprAssignOp {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprAssignOp");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("left", &self.left);
-        formatter.field("op", &self.op);
-        formatter.field("right", &self.right);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprAsync {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprAsync");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("async_token", &self.async_token);
-        formatter.field("capture", &self.capture);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprAwait {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprAwait");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("base", &self.base);
-        formatter.field("dot_token", &self.dot_token);
-        formatter.field("await_token", &self.await_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprBinary {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprBinary");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("left", &self.left);
-        formatter.field("op", &self.op);
-        formatter.field("right", &self.right);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprBlock {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprBlock");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("label", &self.label);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprBox {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprBox");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("box_token", &self.box_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprBreak {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprBreak");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("break_token", &self.break_token);
-        formatter.field("label", &self.label);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprCall {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprCall");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("func", &self.func);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("args", &self.args);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprCast {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprCast");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("expr", &self.expr);
-        formatter.field("as_token", &self.as_token);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprClosure {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprClosure");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("asyncness", &self.asyncness);
-        formatter.field("movability", &self.movability);
-        formatter.field("capture", &self.capture);
-        formatter.field("or1_token", &self.or1_token);
-        formatter.field("inputs", &self.inputs);
-        formatter.field("or2_token", &self.or2_token);
-        formatter.field("output", &self.output);
-        formatter.field("body", &self.body);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprContinue {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprContinue");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("continue_token", &self.continue_token);
-        formatter.field("label", &self.label);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprField {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprField");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("base", &self.base);
-        formatter.field("dot_token", &self.dot_token);
-        formatter.field("member", &self.member);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprForLoop {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprForLoop");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("label", &self.label);
-        formatter.field("for_token", &self.for_token);
-        formatter.field("pat", &self.pat);
-        formatter.field("in_token", &self.in_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("body", &self.body);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprGroup {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprGroup");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("group_token", &self.group_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprIf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprIf");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("if_token", &self.if_token);
-        formatter.field("cond", &self.cond);
-        formatter.field("then_branch", &self.then_branch);
-        formatter.field("else_branch", &self.else_branch);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprIndex {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprIndex");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("expr", &self.expr);
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("index", &self.index);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprLet {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprLet");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("let_token", &self.let_token);
-        formatter.field("pat", &self.pat);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprLit {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprLit");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("lit", &self.lit);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprLoop {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprLoop");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("label", &self.label);
-        formatter.field("loop_token", &self.loop_token);
-        formatter.field("body", &self.body);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("mac", &self.mac);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprMatch {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprMatch");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("match_token", &self.match_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("arms", &self.arms);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprMethodCall {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprMethodCall");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("receiver", &self.receiver);
-        formatter.field("dot_token", &self.dot_token);
-        formatter.field("method", &self.method);
-        formatter.field("turbofish", &self.turbofish);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("args", &self.args);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprParen {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprParen");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprPath {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprPath");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("qself", &self.qself);
-        formatter.field("path", &self.path);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprRange {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprRange");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("from", &self.from);
-        formatter.field("limits", &self.limits);
-        formatter.field("to", &self.to);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprReference {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprReference");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("and_token", &self.and_token);
-        formatter.field("raw", &self.raw);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprRepeat {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprRepeat");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.field("len", &self.len);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprReturn {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprReturn");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("return_token", &self.return_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprStruct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprStruct");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("path", &self.path);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("fields", &self.fields);
-        formatter.field("dot2_token", &self.dot2_token);
-        formatter.field("rest", &self.rest);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprTry {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprTry");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("expr", &self.expr);
-        formatter.field("question_token", &self.question_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprTryBlock {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprTryBlock");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("try_token", &self.try_token);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprTuple {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprTuple");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("elems", &self.elems);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("expr", &self.expr);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprUnary {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprUnary");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("op", &self.op);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprUnsafe {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprUnsafe");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("unsafe_token", &self.unsafe_token);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprWhile {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprWhile");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("label", &self.label);
-        formatter.field("while_token", &self.while_token);
-        formatter.field("cond", &self.cond);
-        formatter.field("body", &self.body);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ExprYield {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ExprYield");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("yield_token", &self.yield_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Field {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Field");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for FieldPat {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("FieldPat");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("member", &self.member);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("pat", &self.pat);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for FieldValue {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("FieldValue");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("member", &self.member);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Fields {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Fields::Named(v0) => {
-                let mut formatter = formatter.debug_tuple("Named");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Fields::Unnamed(v0) => {
-                let mut formatter = formatter.debug_tuple("Unnamed");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Fields::Unit => formatter.write_str("Unit"),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for FieldsNamed {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("FieldsNamed");
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("named", &self.named);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for FieldsUnnamed {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("FieldsUnnamed");
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("unnamed", &self.unnamed);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for File {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("File");
-        formatter.field("shebang", &self.shebang);
-        formatter.field("attrs", &self.attrs);
-        formatter.field("items", &self.items);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for FnArg {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            FnArg::Receiver(v0) => {
-                let mut formatter = formatter.debug_tuple("Receiver");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            FnArg::Typed(v0) => {
-                let mut formatter = formatter.debug_tuple("Typed");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ForeignItem {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ForeignItem::Fn(v0) => {
-                let mut formatter = formatter.debug_tuple("Fn");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ForeignItem::Static(v0) => {
-                let mut formatter = formatter.debug_tuple("Static");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ForeignItem::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ForeignItem::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ForeignItem::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ForeignItemFn {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ForeignItemFn");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("sig", &self.sig);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ForeignItemMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ForeignItemMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("mac", &self.mac);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ForeignItemStatic {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ForeignItemStatic");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("static_token", &self.static_token);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ForeignItemType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ForeignItemType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("type_token", &self.type_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for GenericArgument {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GenericArgument::Lifetime(v0) => {
-                let mut formatter = formatter.debug_tuple("Lifetime");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericArgument::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericArgument::Binding(v0) => {
-                let mut formatter = formatter.debug_tuple("Binding");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericArgument::Constraint(v0) => {
-                let mut formatter = formatter.debug_tuple("Constraint");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericArgument::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for GenericMethodArgument {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GenericMethodArgument::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericMethodArgument::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for GenericParam {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GenericParam::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericParam::Lifetime(v0) => {
-                let mut formatter = formatter.debug_tuple("Lifetime");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            GenericParam::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Generics {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Generics");
-        formatter.field("lt_token", &self.lt_token);
-        formatter.field("params", &self.params);
-        formatter.field("gt_token", &self.gt_token);
-        formatter.field("where_clause", &self.where_clause);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ImplItem {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ImplItem::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ImplItem::Method(v0) => {
-                let mut formatter = formatter.debug_tuple("Method");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ImplItem::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ImplItem::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            ImplItem::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ImplItemConst {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ImplItemConst");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("defaultness", &self.defaultness);
-        formatter.field("const_token", &self.const_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ImplItemMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ImplItemMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("mac", &self.mac);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ImplItemMethod {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ImplItemMethod");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("defaultness", &self.defaultness);
-        formatter.field("sig", &self.sig);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ImplItemType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ImplItemType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("defaultness", &self.defaultness);
-        formatter.field("type_token", &self.type_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Index {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Index");
-        formatter.field("index", &self.index);
-        formatter.field("span", &self.span);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Item {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Item::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Enum(v0) => {
-                let mut formatter = formatter.debug_tuple("Enum");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::ExternCrate(v0) => {
-                let mut formatter = formatter.debug_tuple("ExternCrate");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Fn(v0) => {
-                let mut formatter = formatter.debug_tuple("Fn");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::ForeignMod(v0) => {
-                let mut formatter = formatter.debug_tuple("ForeignMod");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Impl(v0) => {
-                let mut formatter = formatter.debug_tuple("Impl");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Macro2(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro2");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Mod(v0) => {
-                let mut formatter = formatter.debug_tuple("Mod");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Static(v0) => {
-                let mut formatter = formatter.debug_tuple("Static");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Struct(v0) => {
-                let mut formatter = formatter.debug_tuple("Struct");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Trait(v0) => {
-                let mut formatter = formatter.debug_tuple("Trait");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::TraitAlias(v0) => {
-                let mut formatter = formatter.debug_tuple("TraitAlias");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Union(v0) => {
-                let mut formatter = formatter.debug_tuple("Union");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Use(v0) => {
-                let mut formatter = formatter.debug_tuple("Use");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Item::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemConst {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemConst");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("const_token", &self.const_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemEnum {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemEnum");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("enum_token", &self.enum_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("variants", &self.variants);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemExternCrate {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemExternCrate");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("extern_token", &self.extern_token);
-        formatter.field("crate_token", &self.crate_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("rename", &self.rename);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemFn {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemFn");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("sig", &self.sig);
-        formatter.field("block", &self.block);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemForeignMod {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemForeignMod");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("abi", &self.abi);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("items", &self.items);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemImpl {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemImpl");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("defaultness", &self.defaultness);
-        formatter.field("unsafety", &self.unsafety);
-        formatter.field("impl_token", &self.impl_token);
-        formatter.field("generics", &self.generics);
-        formatter.field("trait_", &self.trait_);
-        formatter.field("self_ty", &self.self_ty);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("items", &self.items);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("ident", &self.ident);
-        formatter.field("mac", &self.mac);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemMacro2 {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemMacro2");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("macro_token", &self.macro_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("rules", &self.rules);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemMod {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemMod");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("mod_token", &self.mod_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("content", &self.content);
-        formatter.field("semi", &self.semi);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemStatic {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemStatic");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("static_token", &self.static_token);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("expr", &self.expr);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemStruct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemStruct");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("struct_token", &self.struct_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("fields", &self.fields);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemTrait {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemTrait");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("unsafety", &self.unsafety);
-        formatter.field("auto_token", &self.auto_token);
-        formatter.field("trait_token", &self.trait_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("supertraits", &self.supertraits);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("items", &self.items);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemTraitAlias {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemTraitAlias");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("trait_token", &self.trait_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("type_token", &self.type_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemUnion {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemUnion");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("union_token", &self.union_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("fields", &self.fields);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ItemUse {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ItemUse");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("vis", &self.vis);
-        formatter.field("use_token", &self.use_token);
-        formatter.field("leading_colon", &self.leading_colon);
-        formatter.field("tree", &self.tree);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Label {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Label");
-        formatter.field("name", &self.name);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.finish()
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Lifetime {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Lifetime");
-        formatter.field("apostrophe", &self.apostrophe);
-        formatter.field("ident", &self.ident);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for LifetimeDef {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("LifetimeDef");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("lifetime", &self.lifetime);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Lit {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Lit::Str(v0) => {
-                let mut formatter = formatter.debug_tuple("Str");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::ByteStr(v0) => {
-                let mut formatter = formatter.debug_tuple("ByteStr");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Byte(v0) => {
-                let mut formatter = formatter.debug_tuple("Byte");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Char(v0) => {
-                let mut formatter = formatter.debug_tuple("Char");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Int(v0) => {
-                let mut formatter = formatter.debug_tuple("Int");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Float(v0) => {
-                let mut formatter = formatter.debug_tuple("Float");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Bool(v0) => {
-                let mut formatter = formatter.debug_tuple("Bool");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Lit::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Local {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Local");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("let_token", &self.let_token);
-        formatter.field("pat", &self.pat);
-        formatter.field("init", &self.init);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Macro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Macro");
-        formatter.field("path", &self.path);
-        formatter.field("bang_token", &self.bang_token);
-        formatter.field("delimiter", &self.delimiter);
-        formatter.field("tokens", &self.tokens);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for MacroDelimiter {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            MacroDelimiter::Paren(v0) => {
-                let mut formatter = formatter.debug_tuple("Paren");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            MacroDelimiter::Brace(v0) => {
-                let mut formatter = formatter.debug_tuple("Brace");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            MacroDelimiter::Bracket(v0) => {
-                let mut formatter = formatter.debug_tuple("Bracket");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Member {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Member::Named(v0) => {
-                let mut formatter = formatter.debug_tuple("Named");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Member::Unnamed(v0) => {
-                let mut formatter = formatter.debug_tuple("Unnamed");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Meta {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Meta::Path(v0) => {
-                let mut formatter = formatter.debug_tuple("Path");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Meta::List(v0) => {
-                let mut formatter = formatter.debug_tuple("List");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Meta::NameValue(v0) => {
-                let mut formatter = formatter.debug_tuple("NameValue");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for MetaList {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("MetaList");
-        formatter.field("path", &self.path);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("nested", &self.nested);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for MetaNameValue {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("MetaNameValue");
-        formatter.field("path", &self.path);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("lit", &self.lit);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for MethodTurbofish {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("MethodTurbofish");
-        formatter.field("colon2_token", &self.colon2_token);
-        formatter.field("lt_token", &self.lt_token);
-        formatter.field("args", &self.args);
-        formatter.field("gt_token", &self.gt_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for NestedMeta {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            NestedMeta::Meta(v0) => {
-                let mut formatter = formatter.debug_tuple("Meta");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            NestedMeta::Lit(v0) => {
-                let mut formatter = formatter.debug_tuple("Lit");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ParenthesizedGenericArguments {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("inputs", &self.inputs);
-        formatter.field("output", &self.output);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Pat {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Pat::Box(v0) => {
-                let mut formatter = formatter.debug_tuple("Box");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Ident(v0) => {
-                let mut formatter = formatter.debug_tuple("Ident");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Lit(v0) => {
-                let mut formatter = formatter.debug_tuple("Lit");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Or(v0) => {
-                let mut formatter = formatter.debug_tuple("Or");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Path(v0) => {
-                let mut formatter = formatter.debug_tuple("Path");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Range(v0) => {
-                let mut formatter = formatter.debug_tuple("Range");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Reference(v0) => {
-                let mut formatter = formatter.debug_tuple("Reference");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Rest(v0) => {
-                let mut formatter = formatter.debug_tuple("Rest");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Slice(v0) => {
-                let mut formatter = formatter.debug_tuple("Slice");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Struct(v0) => {
-                let mut formatter = formatter.debug_tuple("Struct");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Tuple(v0) => {
-                let mut formatter = formatter.debug_tuple("Tuple");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::TupleStruct(v0) => {
-                let mut formatter = formatter.debug_tuple("TupleStruct");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Pat::Wild(v0) => {
-                let mut formatter = formatter.debug_tuple("Wild");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatBox {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatBox");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("box_token", &self.box_token);
-        formatter.field("pat", &self.pat);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatIdent {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatIdent");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("by_ref", &self.by_ref);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("ident", &self.ident);
-        formatter.field("subpat", &self.subpat);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatLit {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatLit");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("expr", &self.expr);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("mac", &self.mac);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatOr {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatOr");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("leading_vert", &self.leading_vert);
-        formatter.field("cases", &self.cases);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatPath {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatPath");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("qself", &self.qself);
-        formatter.field("path", &self.path);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatRange {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatRange");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("lo", &self.lo);
-        formatter.field("limits", &self.limits);
-        formatter.field("hi", &self.hi);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatReference {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatReference");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("and_token", &self.and_token);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("pat", &self.pat);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatRest {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatRest");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("dot2_token", &self.dot2_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatSlice {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatSlice");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("elems", &self.elems);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatStruct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatStruct");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("path", &self.path);
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("fields", &self.fields);
-        formatter.field("dot2_token", &self.dot2_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatTuple {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatTuple");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("elems", &self.elems);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatTupleStruct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatTupleStruct");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("path", &self.path);
-        formatter.field("pat", &self.pat);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("pat", &self.pat);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PatWild {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PatWild");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("underscore_token", &self.underscore_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Path {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Path");
-        formatter.field("leading_colon", &self.leading_colon);
-        formatter.field("segments", &self.segments);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PathArguments {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            PathArguments::None => formatter.write_str("None"),
-            PathArguments::AngleBracketed(v0) => {
-                let mut formatter = formatter.debug_tuple("AngleBracketed");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            PathArguments::Parenthesized(v0) => {
-                let mut formatter = formatter.debug_tuple("Parenthesized");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PathSegment {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PathSegment");
-        formatter.field("ident", &self.ident);
-        formatter.field("arguments", &self.arguments);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PredicateEq {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PredicateEq");
-        formatter.field("lhs_ty", &self.lhs_ty);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("rhs_ty", &self.rhs_ty);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PredicateLifetime {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PredicateLifetime");
-        formatter.field("lifetime", &self.lifetime);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for PredicateType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("PredicateType");
-        formatter.field("lifetimes", &self.lifetimes);
-        formatter.field("bounded_ty", &self.bounded_ty);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for QSelf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("QSelf");
-        formatter.field("lt_token", &self.lt_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("position", &self.position);
-        formatter.field("as_token", &self.as_token);
-        formatter.field("gt_token", &self.gt_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for RangeLimits {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            RangeLimits::HalfOpen(v0) => {
-                let mut formatter = formatter.debug_tuple("HalfOpen");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            RangeLimits::Closed(v0) => {
-                let mut formatter = formatter.debug_tuple("Closed");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Receiver {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Receiver");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("reference", &self.reference);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("self_token", &self.self_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for ReturnType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ReturnType::Default => formatter.write_str("Default"),
-            ReturnType::Type(v0, v1) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.field(v1);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Signature {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Signature");
-        formatter.field("constness", &self.constness);
-        formatter.field("asyncness", &self.asyncness);
-        formatter.field("unsafety", &self.unsafety);
-        formatter.field("abi", &self.abi);
-        formatter.field("fn_token", &self.fn_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("inputs", &self.inputs);
-        formatter.field("variadic", &self.variadic);
-        formatter.field("output", &self.output);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Stmt {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Stmt::Local(v0) => {
-                let mut formatter = formatter.debug_tuple("Local");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Stmt::Item(v0) => {
-                let mut formatter = formatter.debug_tuple("Item");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Stmt::Expr(v0) => {
-                let mut formatter = formatter.debug_tuple("Expr");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Stmt::Semi(v0, v1) => {
-                let mut formatter = formatter.debug_tuple("Semi");
-                formatter.field(v0);
-                formatter.field(v1);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitBound {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TraitBound");
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("modifier", &self.modifier);
-        formatter.field("lifetimes", &self.lifetimes);
-        formatter.field("path", &self.path);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitBoundModifier {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TraitBoundModifier::None => formatter.write_str("None"),
-            TraitBoundModifier::Maybe(v0) => {
-                let mut formatter = formatter.debug_tuple("Maybe");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitItem {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TraitItem::Const(v0) => {
-                let mut formatter = formatter.debug_tuple("Const");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            TraitItem::Method(v0) => {
-                let mut formatter = formatter.debug_tuple("Method");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            TraitItem::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            TraitItem::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            TraitItem::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitItemConst {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TraitItemConst");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("const_token", &self.const_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("ty", &self.ty);
-        formatter.field("default", &self.default);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitItemMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TraitItemMacro");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("mac", &self.mac);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitItemMethod {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TraitItemMethod");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("sig", &self.sig);
-        formatter.field("default", &self.default);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TraitItemType {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TraitItemType");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("type_token", &self.type_token);
-        formatter.field("ident", &self.ident);
-        formatter.field("generics", &self.generics);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.field("default", &self.default);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Type {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Type::Array(v0) => {
-                let mut formatter = formatter.debug_tuple("Array");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::BareFn(v0) => {
-                let mut formatter = formatter.debug_tuple("BareFn");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Group(v0) => {
-                let mut formatter = formatter.debug_tuple("Group");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::ImplTrait(v0) => {
-                let mut formatter = formatter.debug_tuple("ImplTrait");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Infer(v0) => {
-                let mut formatter = formatter.debug_tuple("Infer");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Macro(v0) => {
-                let mut formatter = formatter.debug_tuple("Macro");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Never(v0) => {
-                let mut formatter = formatter.debug_tuple("Never");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Paren(v0) => {
-                let mut formatter = formatter.debug_tuple("Paren");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Path(v0) => {
-                let mut formatter = formatter.debug_tuple("Path");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Ptr(v0) => {
-                let mut formatter = formatter.debug_tuple("Ptr");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Reference(v0) => {
-                let mut formatter = formatter.debug_tuple("Reference");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Slice(v0) => {
-                let mut formatter = formatter.debug_tuple("Slice");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::TraitObject(v0) => {
-                let mut formatter = formatter.debug_tuple("TraitObject");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Tuple(v0) => {
-                let mut formatter = formatter.debug_tuple("Tuple");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Type::Verbatim(v0) => {
-                let mut formatter = formatter.debug_tuple("Verbatim");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeArray {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeArray");
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("elem", &self.elem);
-        formatter.field("semi_token", &self.semi_token);
-        formatter.field("len", &self.len);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeBareFn {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeBareFn");
-        formatter.field("lifetimes", &self.lifetimes);
-        formatter.field("unsafety", &self.unsafety);
-        formatter.field("abi", &self.abi);
-        formatter.field("fn_token", &self.fn_token);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("inputs", &self.inputs);
-        formatter.field("variadic", &self.variadic);
-        formatter.field("output", &self.output);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeGroup {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeGroup");
-        formatter.field("group_token", &self.group_token);
-        formatter.field("elem", &self.elem);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeImplTrait {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeImplTrait");
-        formatter.field("impl_token", &self.impl_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeInfer {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeInfer");
-        formatter.field("underscore_token", &self.underscore_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeMacro {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeMacro");
-        formatter.field("mac", &self.mac);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeNever {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeNever");
-        formatter.field("bang_token", &self.bang_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeParam {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeParam");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("ident", &self.ident);
-        formatter.field("colon_token", &self.colon_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.field("eq_token", &self.eq_token);
-        formatter.field("default", &self.default);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeParamBound {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TypeParamBound::Trait(v0) => {
-                let mut formatter = formatter.debug_tuple("Trait");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            TypeParamBound::Lifetime(v0) => {
-                let mut formatter = formatter.debug_tuple("Lifetime");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeParen {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeParen");
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("elem", &self.elem);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypePath {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypePath");
-        formatter.field("qself", &self.qself);
-        formatter.field("path", &self.path);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypePtr {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypePtr");
-        formatter.field("star_token", &self.star_token);
-        formatter.field("const_token", &self.const_token);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("elem", &self.elem);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeReference {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeReference");
-        formatter.field("and_token", &self.and_token);
-        formatter.field("lifetime", &self.lifetime);
-        formatter.field("mutability", &self.mutability);
-        formatter.field("elem", &self.elem);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeSlice {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeSlice");
-        formatter.field("bracket_token", &self.bracket_token);
-        formatter.field("elem", &self.elem);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeTraitObject {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeTraitObject");
-        formatter.field("dyn_token", &self.dyn_token);
-        formatter.field("bounds", &self.bounds);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for TypeTuple {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("TypeTuple");
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("elems", &self.elems);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UnOp {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            UnOp::Deref(v0) => {
-                let mut formatter = formatter.debug_tuple("Deref");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UnOp::Not(v0) => {
-                let mut formatter = formatter.debug_tuple("Not");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UnOp::Neg(v0) => {
-                let mut formatter = formatter.debug_tuple("Neg");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UseGlob {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("UseGlob");
-        formatter.field("star_token", &self.star_token);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UseGroup {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("UseGroup");
-        formatter.field("brace_token", &self.brace_token);
-        formatter.field("items", &self.items);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UseName {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("UseName");
-        formatter.field("ident", &self.ident);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UsePath {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("UsePath");
-        formatter.field("ident", &self.ident);
-        formatter.field("colon2_token", &self.colon2_token);
-        formatter.field("tree", &self.tree);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UseRename {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("UseRename");
-        formatter.field("ident", &self.ident);
-        formatter.field("as_token", &self.as_token);
-        formatter.field("rename", &self.rename);
-        formatter.finish()
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for UseTree {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            UseTree::Path(v0) => {
-                let mut formatter = formatter.debug_tuple("Path");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UseTree::Name(v0) => {
-                let mut formatter = formatter.debug_tuple("Name");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UseTree::Rename(v0) => {
-                let mut formatter = formatter.debug_tuple("Rename");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UseTree::Glob(v0) => {
-                let mut formatter = formatter.debug_tuple("Glob");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            UseTree::Group(v0) => {
-                let mut formatter = formatter.debug_tuple("Group");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Variadic {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Variadic");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("dots", &self.dots);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Variant {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("Variant");
-        formatter.field("attrs", &self.attrs);
-        formatter.field("ident", &self.ident);
-        formatter.field("fields", &self.fields);
-        formatter.field("discriminant", &self.discriminant);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for VisCrate {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("VisCrate");
-        formatter.field("crate_token", &self.crate_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for VisPublic {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("VisPublic");
-        formatter.field("pub_token", &self.pub_token);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for VisRestricted {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("VisRestricted");
-        formatter.field("pub_token", &self.pub_token);
-        formatter.field("paren_token", &self.paren_token);
-        formatter.field("in_token", &self.in_token);
-        formatter.field("path", &self.path);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Visibility {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Visibility::Public(v0) => {
-                let mut formatter = formatter.debug_tuple("Public");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Visibility::Crate(v0) => {
-                let mut formatter = formatter.debug_tuple("Crate");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Visibility::Restricted(v0) => {
-                let mut formatter = formatter.debug_tuple("Restricted");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            Visibility::Inherited => formatter.write_str("Inherited"),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for WhereClause {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut formatter = formatter.debug_struct("WhereClause");
-        formatter.field("where_token", &self.where_token);
-        formatter.field("predicates", &self.predicates);
-        formatter.finish()
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for WherePredicate {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            WherePredicate::Type(v0) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            WherePredicate::Lifetime(v0) => {
-                let mut formatter = formatter.debug_tuple("Lifetime");
-                formatter.field(v0);
-                formatter.finish()
-            }
-            WherePredicate::Eq(v0) => {
-                let mut formatter = formatter.debug_tuple("Eq");
-                formatter.field(v0);
-                formatter.finish()
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/eq.rs b/vendor/syn/src/gen/eq.rs
deleted file mode 100644
index e6e85323..00000000
--- a/vendor/syn/src/gen/eq.rs
+++ /dev/null
@@ -1,2288 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#[cfg(any(feature = "derive", feature = "full"))]
-use crate::tt::TokenStreamHelper;
-use crate::*;
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Abi {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Abi {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for AngleBracketedGenericArguments {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for AngleBracketedGenericArguments {
-    fn eq(&self, other: &Self) -> bool {
-        self.colon2_token == other.colon2_token && self.args == other.args
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Arm {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Arm {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.pat == other.pat
-            && self.guard == other.guard
-            && self.body == other.body
-            && self.comma == other.comma
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for AttrStyle {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for AttrStyle {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (AttrStyle::Outer, AttrStyle::Outer) => true,
-            (AttrStyle::Inner(_), AttrStyle::Inner(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Attribute {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Attribute {
-    fn eq(&self, other: &Self) -> bool {
-        self.style == other.style
-            && self.path == other.path
-            && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for BareFnArg {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for BareFnArg {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.name == other.name && self.ty == other.ty
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for BinOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for BinOp {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (BinOp::Add(_), BinOp::Add(_)) => true,
-            (BinOp::Sub(_), BinOp::Sub(_)) => true,
-            (BinOp::Mul(_), BinOp::Mul(_)) => true,
-            (BinOp::Div(_), BinOp::Div(_)) => true,
-            (BinOp::Rem(_), BinOp::Rem(_)) => true,
-            (BinOp::And(_), BinOp::And(_)) => true,
-            (BinOp::Or(_), BinOp::Or(_)) => true,
-            (BinOp::BitXor(_), BinOp::BitXor(_)) => true,
-            (BinOp::BitAnd(_), BinOp::BitAnd(_)) => true,
-            (BinOp::BitOr(_), BinOp::BitOr(_)) => true,
-            (BinOp::Shl(_), BinOp::Shl(_)) => true,
-            (BinOp::Shr(_), BinOp::Shr(_)) => true,
-            (BinOp::Eq(_), BinOp::Eq(_)) => true,
-            (BinOp::Lt(_), BinOp::Lt(_)) => true,
-            (BinOp::Le(_), BinOp::Le(_)) => true,
-            (BinOp::Ne(_), BinOp::Ne(_)) => true,
-            (BinOp::Ge(_), BinOp::Ge(_)) => true,
-            (BinOp::Gt(_), BinOp::Gt(_)) => true,
-            (BinOp::AddEq(_), BinOp::AddEq(_)) => true,
-            (BinOp::SubEq(_), BinOp::SubEq(_)) => true,
-            (BinOp::MulEq(_), BinOp::MulEq(_)) => true,
-            (BinOp::DivEq(_), BinOp::DivEq(_)) => true,
-            (BinOp::RemEq(_), BinOp::RemEq(_)) => true,
-            (BinOp::BitXorEq(_), BinOp::BitXorEq(_)) => true,
-            (BinOp::BitAndEq(_), BinOp::BitAndEq(_)) => true,
-            (BinOp::BitOrEq(_), BinOp::BitOrEq(_)) => true,
-            (BinOp::ShlEq(_), BinOp::ShlEq(_)) => true,
-            (BinOp::ShrEq(_), BinOp::ShrEq(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Binding {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Binding {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Block {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Block {
-    fn eq(&self, other: &Self) -> bool {
-        self.stmts == other.stmts
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for BoundLifetimes {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for BoundLifetimes {
-    fn eq(&self, other: &Self) -> bool {
-        self.lifetimes == other.lifetimes
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ConstParam {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ConstParam {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.ty == other.ty
-            && self.eq_token == other.eq_token
-            && self.default == other.default
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Constraint {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Constraint {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident && self.bounds == other.bounds
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Data {}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Data {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Data::Struct(self0), Data::Struct(other0)) => self0 == other0,
-            (Data::Enum(self0), Data::Enum(other0)) => self0 == other0,
-            (Data::Union(self0), Data::Union(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for DataEnum {}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for DataEnum {
-    fn eq(&self, other: &Self) -> bool {
-        self.variants == other.variants
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for DataStruct {}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for DataStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.fields == other.fields && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for DataUnion {}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for DataUnion {
-    fn eq(&self, other: &Self) -> bool {
-        self.fields == other.fields
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for DeriveInput {}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for DeriveInput {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.data == other.data
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Expr {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Expr {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            #[cfg(feature = "full")]
-            (Expr::Array(self0), Expr::Array(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Assign(self0), Expr::Assign(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::AssignOp(self0), Expr::AssignOp(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Async(self0), Expr::Async(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Await(self0), Expr::Await(other0)) => self0 == other0,
-            (Expr::Binary(self0), Expr::Binary(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Block(self0), Expr::Block(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Box(self0), Expr::Box(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Break(self0), Expr::Break(other0)) => self0 == other0,
-            (Expr::Call(self0), Expr::Call(other0)) => self0 == other0,
-            (Expr::Cast(self0), Expr::Cast(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Closure(self0), Expr::Closure(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Continue(self0), Expr::Continue(other0)) => self0 == other0,
-            (Expr::Field(self0), Expr::Field(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::ForLoop(self0), Expr::ForLoop(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Group(self0), Expr::Group(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::If(self0), Expr::If(other0)) => self0 == other0,
-            (Expr::Index(self0), Expr::Index(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Let(self0), Expr::Let(other0)) => self0 == other0,
-            (Expr::Lit(self0), Expr::Lit(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Loop(self0), Expr::Loop(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Macro(self0), Expr::Macro(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Match(self0), Expr::Match(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::MethodCall(self0), Expr::MethodCall(other0)) => self0 == other0,
-            (Expr::Paren(self0), Expr::Paren(other0)) => self0 == other0,
-            (Expr::Path(self0), Expr::Path(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Range(self0), Expr::Range(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Reference(self0), Expr::Reference(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Repeat(self0), Expr::Repeat(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Return(self0), Expr::Return(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Struct(self0), Expr::Struct(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Try(self0), Expr::Try(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::TryBlock(self0), Expr::TryBlock(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Tuple(self0), Expr::Tuple(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Type(self0), Expr::Type(other0)) => self0 == other0,
-            (Expr::Unary(self0), Expr::Unary(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Unsafe(self0), Expr::Unsafe(other0)) => self0 == other0,
-            (Expr::Verbatim(self0), Expr::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            #[cfg(feature = "full")]
-            (Expr::While(self0), Expr::While(other0)) => self0 == other0,
-            #[cfg(feature = "full")]
-            (Expr::Yield(self0), Expr::Yield(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprArray {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprArray {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.elems == other.elems
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprAssign {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprAssign {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.left == other.left && self.right == other.right
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprAssignOp {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprAssignOp {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.left == other.left
-            && self.op == other.op
-            && self.right == other.right
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprAsync {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprAsync {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.capture == other.capture && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprAwait {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprAwait {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.base == other.base
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprBinary {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprBinary {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.left == other.left
-            && self.op == other.op
-            && self.right == other.right
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprBlock {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprBlock {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.label == other.label && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprBox {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprBox {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprBreak {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprBreak {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.label == other.label && self.expr == other.expr
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprCall {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprCall {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.func == other.func && self.args == other.args
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprCast {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprCast {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprClosure {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprClosure {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.asyncness == other.asyncness
-            && self.movability == other.movability
-            && self.capture == other.capture
-            && self.inputs == other.inputs
-            && self.output == other.output
-            && self.body == other.body
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprContinue {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprContinue {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.label == other.label
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprField {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprField {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.base == other.base && self.member == other.member
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprForLoop {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprForLoop {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.label == other.label
-            && self.pat == other.pat
-            && self.expr == other.expr
-            && self.body == other.body
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprGroup {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprGroup {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprIf {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprIf {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.cond == other.cond
-            && self.then_branch == other.then_branch
-            && self.else_branch == other.else_branch
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprIndex {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprIndex {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr && self.index == other.index
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprLet {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprLet {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.pat == other.pat && self.expr == other.expr
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprLit {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprLit {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.lit == other.lit
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprLoop {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprLoop {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.label == other.label && self.body == other.body
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mac == other.mac
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprMatch {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprMatch {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr && self.arms == other.arms
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprMethodCall {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprMethodCall {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.receiver == other.receiver
-            && self.method == other.method
-            && self.turbofish == other.turbofish
-            && self.args == other.args
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprParen {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprParen {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprPath {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprPath {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprRange {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprRange {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.from == other.from
-            && self.limits == other.limits
-            && self.to == other.to
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprReference {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprReference {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mutability == other.mutability && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprRepeat {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprRepeat {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr && self.len == other.len
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprReturn {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprReturn {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprStruct {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.path == other.path
-            && self.fields == other.fields
-            && self.dot2_token == other.dot2_token
-            && self.rest == other.rest
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprTry {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprTry {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprTryBlock {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprTryBlock {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprTuple {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprTuple {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.elems == other.elems
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr && self.ty == other.ty
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprUnary {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprUnary {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.op == other.op && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprUnsafe {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprUnsafe {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprWhile {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprWhile {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.label == other.label
-            && self.cond == other.cond
-            && self.body == other.body
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ExprYield {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ExprYield {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Field {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Field {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.colon_token == other.colon_token
-            && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for FieldPat {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for FieldPat {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.member == other.member
-            && self.colon_token == other.colon_token
-            && self.pat == other.pat
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for FieldValue {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for FieldValue {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.member == other.member
-            && self.colon_token == other.colon_token
-            && self.expr == other.expr
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Fields {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Fields {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Fields::Named(self0), Fields::Named(other0)) => self0 == other0,
-            (Fields::Unnamed(self0), Fields::Unnamed(other0)) => self0 == other0,
-            (Fields::Unit, Fields::Unit) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for FieldsNamed {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for FieldsNamed {
-    fn eq(&self, other: &Self) -> bool {
-        self.named == other.named
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for FieldsUnnamed {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for FieldsUnnamed {
-    fn eq(&self, other: &Self) -> bool {
-        self.unnamed == other.unnamed
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for File {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for File {
-    fn eq(&self, other: &Self) -> bool {
-        self.shebang == other.shebang && self.attrs == other.attrs && self.items == other.items
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for FnArg {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for FnArg {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (FnArg::Receiver(self0), FnArg::Receiver(other0)) => self0 == other0,
-            (FnArg::Typed(self0), FnArg::Typed(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ForeignItem {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ForeignItem {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (ForeignItem::Fn(self0), ForeignItem::Fn(other0)) => self0 == other0,
-            (ForeignItem::Static(self0), ForeignItem::Static(other0)) => self0 == other0,
-            (ForeignItem::Type(self0), ForeignItem::Type(other0)) => self0 == other0,
-            (ForeignItem::Macro(self0), ForeignItem::Macro(other0)) => self0 == other0,
-            (ForeignItem::Verbatim(self0), ForeignItem::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ForeignItemFn {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ForeignItemFn {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.vis == other.vis && self.sig == other.sig
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ForeignItemMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ForeignItemMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mac == other.mac && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ForeignItemStatic {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ForeignItemStatic {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.mutability == other.mutability
-            && self.ident == other.ident
-            && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ForeignItemType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ForeignItemType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for GenericArgument {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for GenericArgument {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (GenericArgument::Lifetime(self0), GenericArgument::Lifetime(other0)) => {
-                self0 == other0
-            }
-            (GenericArgument::Type(self0), GenericArgument::Type(other0)) => self0 == other0,
-            (GenericArgument::Binding(self0), GenericArgument::Binding(other0)) => self0 == other0,
-            (GenericArgument::Constraint(self0), GenericArgument::Constraint(other0)) => {
-                self0 == other0
-            }
-            (GenericArgument::Const(self0), GenericArgument::Const(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for GenericMethodArgument {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for GenericMethodArgument {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (GenericMethodArgument::Type(self0), GenericMethodArgument::Type(other0)) => {
-                self0 == other0
-            }
-            (GenericMethodArgument::Const(self0), GenericMethodArgument::Const(other0)) => {
-                self0 == other0
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for GenericParam {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for GenericParam {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (GenericParam::Type(self0), GenericParam::Type(other0)) => self0 == other0,
-            (GenericParam::Lifetime(self0), GenericParam::Lifetime(other0)) => self0 == other0,
-            (GenericParam::Const(self0), GenericParam::Const(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Generics {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Generics {
-    fn eq(&self, other: &Self) -> bool {
-        self.lt_token == other.lt_token
-            && self.params == other.params
-            && self.gt_token == other.gt_token
-            && self.where_clause == other.where_clause
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ImplItem {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ImplItem {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (ImplItem::Const(self0), ImplItem::Const(other0)) => self0 == other0,
-            (ImplItem::Method(self0), ImplItem::Method(other0)) => self0 == other0,
-            (ImplItem::Type(self0), ImplItem::Type(other0)) => self0 == other0,
-            (ImplItem::Macro(self0), ImplItem::Macro(other0)) => self0 == other0,
-            (ImplItem::Verbatim(self0), ImplItem::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ImplItemConst {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ImplItemConst {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.defaultness == other.defaultness
-            && self.ident == other.ident
-            && self.ty == other.ty
-            && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ImplItemMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ImplItemMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mac == other.mac && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ImplItemMethod {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ImplItemMethod {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.defaultness == other.defaultness
-            && self.sig == other.sig
-            && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ImplItemType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ImplItemType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.defaultness == other.defaultness
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Item {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Item {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Item::Const(self0), Item::Const(other0)) => self0 == other0,
-            (Item::Enum(self0), Item::Enum(other0)) => self0 == other0,
-            (Item::ExternCrate(self0), Item::ExternCrate(other0)) => self0 == other0,
-            (Item::Fn(self0), Item::Fn(other0)) => self0 == other0,
-            (Item::ForeignMod(self0), Item::ForeignMod(other0)) => self0 == other0,
-            (Item::Impl(self0), Item::Impl(other0)) => self0 == other0,
-            (Item::Macro(self0), Item::Macro(other0)) => self0 == other0,
-            (Item::Macro2(self0), Item::Macro2(other0)) => self0 == other0,
-            (Item::Mod(self0), Item::Mod(other0)) => self0 == other0,
-            (Item::Static(self0), Item::Static(other0)) => self0 == other0,
-            (Item::Struct(self0), Item::Struct(other0)) => self0 == other0,
-            (Item::Trait(self0), Item::Trait(other0)) => self0 == other0,
-            (Item::TraitAlias(self0), Item::TraitAlias(other0)) => self0 == other0,
-            (Item::Type(self0), Item::Type(other0)) => self0 == other0,
-            (Item::Union(self0), Item::Union(other0)) => self0 == other0,
-            (Item::Use(self0), Item::Use(other0)) => self0 == other0,
-            (Item::Verbatim(self0), Item::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemConst {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemConst {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.ty == other.ty
-            && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemEnum {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemEnum {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.variants == other.variants
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemExternCrate {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemExternCrate {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.rename == other.rename
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemFn {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemFn {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.sig == other.sig
-            && self.block == other.block
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemForeignMod {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemForeignMod {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.abi == other.abi && self.items == other.items
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemImpl {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemImpl {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.defaultness == other.defaultness
-            && self.unsafety == other.unsafety
-            && self.generics == other.generics
-            && self.trait_ == other.trait_
-            && self.self_ty == other.self_ty
-            && self.items == other.items
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.mac == other.mac
-            && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemMacro2 {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemMacro2 {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && TokenStreamHelper(&self.rules) == TokenStreamHelper(&other.rules)
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemMod {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemMod {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.content == other.content
-            && self.semi == other.semi
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemStatic {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemStatic {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.mutability == other.mutability
-            && self.ident == other.ident
-            && self.ty == other.ty
-            && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemStruct {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.fields == other.fields
-            && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemTrait {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemTrait {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.unsafety == other.unsafety
-            && self.auto_token == other.auto_token
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.colon_token == other.colon_token
-            && self.supertraits == other.supertraits
-            && self.items == other.items
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemTraitAlias {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemTraitAlias {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.bounds == other.bounds
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemUnion {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemUnion {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.fields == other.fields
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ItemUse {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ItemUse {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.vis == other.vis
-            && self.leading_colon == other.leading_colon
-            && self.tree == other.tree
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Label {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Label {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LifetimeDef {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for LifetimeDef {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.lifetime == other.lifetime
-            && self.colon_token == other.colon_token
-            && self.bounds == other.bounds
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Lit {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Lit {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Lit::Str(self0), Lit::Str(other0)) => self0 == other0,
-            (Lit::ByteStr(self0), Lit::ByteStr(other0)) => self0 == other0,
-            (Lit::Byte(self0), Lit::Byte(other0)) => self0 == other0,
-            (Lit::Char(self0), Lit::Char(other0)) => self0 == other0,
-            (Lit::Int(self0), Lit::Int(other0)) => self0 == other0,
-            (Lit::Float(self0), Lit::Float(other0)) => self0 == other0,
-            (Lit::Bool(self0), Lit::Bool(other0)) => self0 == other0,
-            (Lit::Verbatim(self0), Lit::Verbatim(other0)) => {
-                self0.to_string() == other0.to_string()
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitBool {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for LitBool {
-    fn eq(&self, other: &Self) -> bool {
-        self.value == other.value
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitByte {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitByteStr {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitChar {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitFloat {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitInt {}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for LitStr {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Local {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Local {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.pat == other.pat && self.init == other.init
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Macro {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Macro {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path
-            && self.delimiter == other.delimiter
-            && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for MacroDelimiter {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for MacroDelimiter {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (MacroDelimiter::Paren(_), MacroDelimiter::Paren(_)) => true,
-            (MacroDelimiter::Brace(_), MacroDelimiter::Brace(_)) => true,
-            (MacroDelimiter::Bracket(_), MacroDelimiter::Bracket(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Meta {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Meta {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Meta::Path(self0), Meta::Path(other0)) => self0 == other0,
-            (Meta::List(self0), Meta::List(other0)) => self0 == other0,
-            (Meta::NameValue(self0), Meta::NameValue(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for MetaList {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for MetaList {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path && self.nested == other.nested
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for MetaNameValue {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for MetaNameValue {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path && self.lit == other.lit
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for MethodTurbofish {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for MethodTurbofish {
-    fn eq(&self, other: &Self) -> bool {
-        self.args == other.args
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for NestedMeta {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for NestedMeta {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (NestedMeta::Meta(self0), NestedMeta::Meta(other0)) => self0 == other0,
-            (NestedMeta::Lit(self0), NestedMeta::Lit(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ParenthesizedGenericArguments {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ParenthesizedGenericArguments {
-    fn eq(&self, other: &Self) -> bool {
-        self.inputs == other.inputs && self.output == other.output
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Pat {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Pat {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Pat::Box(self0), Pat::Box(other0)) => self0 == other0,
-            (Pat::Ident(self0), Pat::Ident(other0)) => self0 == other0,
-            (Pat::Lit(self0), Pat::Lit(other0)) => self0 == other0,
-            (Pat::Macro(self0), Pat::Macro(other0)) => self0 == other0,
-            (Pat::Or(self0), Pat::Or(other0)) => self0 == other0,
-            (Pat::Path(self0), Pat::Path(other0)) => self0 == other0,
-            (Pat::Range(self0), Pat::Range(other0)) => self0 == other0,
-            (Pat::Reference(self0), Pat::Reference(other0)) => self0 == other0,
-            (Pat::Rest(self0), Pat::Rest(other0)) => self0 == other0,
-            (Pat::Slice(self0), Pat::Slice(other0)) => self0 == other0,
-            (Pat::Struct(self0), Pat::Struct(other0)) => self0 == other0,
-            (Pat::Tuple(self0), Pat::Tuple(other0)) => self0 == other0,
-            (Pat::TupleStruct(self0), Pat::TupleStruct(other0)) => self0 == other0,
-            (Pat::Type(self0), Pat::Type(other0)) => self0 == other0,
-            (Pat::Verbatim(self0), Pat::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            (Pat::Wild(self0), Pat::Wild(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatBox {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatBox {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.pat == other.pat
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatIdent {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatIdent {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.by_ref == other.by_ref
-            && self.mutability == other.mutability
-            && self.ident == other.ident
-            && self.subpat == other.subpat
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatLit {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatLit {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.expr == other.expr
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mac == other.mac
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatOr {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatOr {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.leading_vert == other.leading_vert
-            && self.cases == other.cases
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatPath {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatPath {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatRange {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatRange {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.lo == other.lo
-            && self.limits == other.limits
-            && self.hi == other.hi
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatReference {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatReference {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mutability == other.mutability && self.pat == other.pat
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatRest {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatRest {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatSlice {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatSlice {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.elems == other.elems
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatStruct {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.path == other.path
-            && self.fields == other.fields
-            && self.dot2_token == other.dot2_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatTuple {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatTuple {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.elems == other.elems
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatTupleStruct {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatTupleStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.path == other.path && self.pat == other.pat
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.pat == other.pat && self.ty == other.ty
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PatWild {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PatWild {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Path {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Path {
-    fn eq(&self, other: &Self) -> bool {
-        self.leading_colon == other.leading_colon && self.segments == other.segments
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PathArguments {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PathArguments {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (PathArguments::None, PathArguments::None) => true,
-            (PathArguments::AngleBracketed(self0), PathArguments::AngleBracketed(other0)) => {
-                self0 == other0
-            }
-            (PathArguments::Parenthesized(self0), PathArguments::Parenthesized(other0)) => {
-                self0 == other0
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PathSegment {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PathSegment {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident && self.arguments == other.arguments
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PredicateEq {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PredicateEq {
-    fn eq(&self, other: &Self) -> bool {
-        self.lhs_ty == other.lhs_ty && self.rhs_ty == other.rhs_ty
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PredicateLifetime {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PredicateLifetime {
-    fn eq(&self, other: &Self) -> bool {
-        self.lifetime == other.lifetime && self.bounds == other.bounds
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for PredicateType {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for PredicateType {
-    fn eq(&self, other: &Self) -> bool {
-        self.lifetimes == other.lifetimes
-            && self.bounded_ty == other.bounded_ty
-            && self.bounds == other.bounds
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for QSelf {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for QSelf {
-    fn eq(&self, other: &Self) -> bool {
-        self.ty == other.ty && self.position == other.position && self.as_token == other.as_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for RangeLimits {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for RangeLimits {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (RangeLimits::HalfOpen(_), RangeLimits::HalfOpen(_)) => true,
-            (RangeLimits::Closed(_), RangeLimits::Closed(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Receiver {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Receiver {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.reference == other.reference
-            && self.mutability == other.mutability
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for ReturnType {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for ReturnType {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (ReturnType::Default, ReturnType::Default) => true,
-            (ReturnType::Type(_, self1), ReturnType::Type(_, other1)) => self1 == other1,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Signature {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Signature {
-    fn eq(&self, other: &Self) -> bool {
-        self.constness == other.constness
-            && self.asyncness == other.asyncness
-            && self.unsafety == other.unsafety
-            && self.abi == other.abi
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.inputs == other.inputs
-            && self.variadic == other.variadic
-            && self.output == other.output
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Stmt {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Stmt {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Stmt::Local(self0), Stmt::Local(other0)) => self0 == other0,
-            (Stmt::Item(self0), Stmt::Item(other0)) => self0 == other0,
-            (Stmt::Expr(self0), Stmt::Expr(other0)) => self0 == other0,
-            (Stmt::Semi(self0, _), Stmt::Semi(other0, _)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitBound {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitBound {
-    fn eq(&self, other: &Self) -> bool {
-        self.paren_token == other.paren_token
-            && self.modifier == other.modifier
-            && self.lifetimes == other.lifetimes
-            && self.path == other.path
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitBoundModifier {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitBoundModifier {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (TraitBoundModifier::None, TraitBoundModifier::None) => true,
-            (TraitBoundModifier::Maybe(_), TraitBoundModifier::Maybe(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitItem {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitItem {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (TraitItem::Const(self0), TraitItem::Const(other0)) => self0 == other0,
-            (TraitItem::Method(self0), TraitItem::Method(other0)) => self0 == other0,
-            (TraitItem::Type(self0), TraitItem::Type(other0)) => self0 == other0,
-            (TraitItem::Macro(self0), TraitItem::Macro(other0)) => self0 == other0,
-            (TraitItem::Verbatim(self0), TraitItem::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitItemConst {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitItemConst {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.ty == other.ty
-            && self.default == other.default
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitItemMacro {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitItemMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs && self.mac == other.mac && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitItemMethod {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitItemMethod {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.sig == other.sig
-            && self.default == other.default
-            && self.semi_token == other.semi_token
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TraitItemType {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TraitItemType {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.generics == other.generics
-            && self.colon_token == other.colon_token
-            && self.bounds == other.bounds
-            && self.default == other.default
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Type {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Type {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Type::Array(self0), Type::Array(other0)) => self0 == other0,
-            (Type::BareFn(self0), Type::BareFn(other0)) => self0 == other0,
-            (Type::Group(self0), Type::Group(other0)) => self0 == other0,
-            (Type::ImplTrait(self0), Type::ImplTrait(other0)) => self0 == other0,
-            (Type::Infer(self0), Type::Infer(other0)) => self0 == other0,
-            (Type::Macro(self0), Type::Macro(other0)) => self0 == other0,
-            (Type::Never(self0), Type::Never(other0)) => self0 == other0,
-            (Type::Paren(self0), Type::Paren(other0)) => self0 == other0,
-            (Type::Path(self0), Type::Path(other0)) => self0 == other0,
-            (Type::Ptr(self0), Type::Ptr(other0)) => self0 == other0,
-            (Type::Reference(self0), Type::Reference(other0)) => self0 == other0,
-            (Type::Slice(self0), Type::Slice(other0)) => self0 == other0,
-            (Type::TraitObject(self0), Type::TraitObject(other0)) => self0 == other0,
-            (Type::Tuple(self0), Type::Tuple(other0)) => self0 == other0,
-            (Type::Verbatim(self0), Type::Verbatim(other0)) => {
-                TokenStreamHelper(self0) == TokenStreamHelper(other0)
-            }
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeArray {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeArray {
-    fn eq(&self, other: &Self) -> bool {
-        self.elem == other.elem && self.len == other.len
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeBareFn {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeBareFn {
-    fn eq(&self, other: &Self) -> bool {
-        self.lifetimes == other.lifetimes
-            && self.unsafety == other.unsafety
-            && self.abi == other.abi
-            && self.inputs == other.inputs
-            && self.variadic == other.variadic
-            && self.output == other.output
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeGroup {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeGroup {
-    fn eq(&self, other: &Self) -> bool {
-        self.elem == other.elem
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeImplTrait {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeImplTrait {
-    fn eq(&self, other: &Self) -> bool {
-        self.bounds == other.bounds
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeInfer {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeInfer {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeMacro {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeMacro {
-    fn eq(&self, other: &Self) -> bool {
-        self.mac == other.mac
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeNever {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeNever {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeParam {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeParam {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.colon_token == other.colon_token
-            && self.bounds == other.bounds
-            && self.eq_token == other.eq_token
-            && self.default == other.default
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeParamBound {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeParamBound {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (TypeParamBound::Trait(self0), TypeParamBound::Trait(other0)) => self0 == other0,
-            (TypeParamBound::Lifetime(self0), TypeParamBound::Lifetime(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeParen {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeParen {
-    fn eq(&self, other: &Self) -> bool {
-        self.elem == other.elem
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypePath {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypePath {
-    fn eq(&self, other: &Self) -> bool {
-        self.qself == other.qself && self.path == other.path
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypePtr {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypePtr {
-    fn eq(&self, other: &Self) -> bool {
-        self.const_token == other.const_token
-            && self.mutability == other.mutability
-            && self.elem == other.elem
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeReference {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeReference {
-    fn eq(&self, other: &Self) -> bool {
-        self.lifetime == other.lifetime
-            && self.mutability == other.mutability
-            && self.elem == other.elem
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeSlice {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeSlice {
-    fn eq(&self, other: &Self) -> bool {
-        self.elem == other.elem
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeTraitObject {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeTraitObject {
-    fn eq(&self, other: &Self) -> bool {
-        self.dyn_token == other.dyn_token && self.bounds == other.bounds
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for TypeTuple {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for TypeTuple {
-    fn eq(&self, other: &Self) -> bool {
-        self.elems == other.elems
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UnOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UnOp {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (UnOp::Deref(_), UnOp::Deref(_)) => true,
-            (UnOp::Not(_), UnOp::Not(_)) => true,
-            (UnOp::Neg(_), UnOp::Neg(_)) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UseGlob {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UseGlob {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UseGroup {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UseGroup {
-    fn eq(&self, other: &Self) -> bool {
-        self.items == other.items
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UseName {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UseName {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UsePath {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UsePath {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident && self.tree == other.tree
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UseRename {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UseRename {
-    fn eq(&self, other: &Self) -> bool {
-        self.ident == other.ident && self.rename == other.rename
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for UseTree {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for UseTree {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (UseTree::Path(self0), UseTree::Path(other0)) => self0 == other0,
-            (UseTree::Name(self0), UseTree::Name(other0)) => self0 == other0,
-            (UseTree::Rename(self0), UseTree::Rename(other0)) => self0 == other0,
-            (UseTree::Glob(self0), UseTree::Glob(other0)) => self0 == other0,
-            (UseTree::Group(self0), UseTree::Group(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Variadic {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Variadic {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Variant {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Variant {
-    fn eq(&self, other: &Self) -> bool {
-        self.attrs == other.attrs
-            && self.ident == other.ident
-            && self.fields == other.fields
-            && self.discriminant == other.discriminant
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for VisCrate {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for VisCrate {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for VisPublic {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for VisPublic {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for VisRestricted {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for VisRestricted {
-    fn eq(&self, other: &Self) -> bool {
-        self.in_token == other.in_token && self.path == other.path
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for Visibility {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for Visibility {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Visibility::Public(self0), Visibility::Public(other0)) => self0 == other0,
-            (Visibility::Crate(self0), Visibility::Crate(other0)) => self0 == other0,
-            (Visibility::Restricted(self0), Visibility::Restricted(other0)) => self0 == other0,
-            (Visibility::Inherited, Visibility::Inherited) => true,
-            _ => false,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for WhereClause {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for WhereClause {
-    fn eq(&self, other: &Self) -> bool {
-        self.predicates == other.predicates
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Eq for WherePredicate {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl PartialEq for WherePredicate {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (WherePredicate::Type(self0), WherePredicate::Type(other0)) => self0 == other0,
-            (WherePredicate::Lifetime(self0), WherePredicate::Lifetime(other0)) => self0 == other0,
-            (WherePredicate::Eq(self0), WherePredicate::Eq(other0)) => self0 == other0,
-            _ => false,
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/fold.rs b/vendor/syn/src/gen/fold.rs
deleted file mode 100644
index d9dd32a4..00000000
--- a/vendor/syn/src/gen/fold.rs
+++ /dev/null
@@ -1,3209 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#![allow(unreachable_code, unused_variables)]
-#![allow(clippy::match_wildcard_for_single_variants)]
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::gen::helper::fold::*;
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::token::{Brace, Bracket, Group, Paren};
-use crate::*;
-use proc_macro2::Span;
-#[cfg(feature = "full")]
-macro_rules! full {
-    ($e:expr) => {
-        $e
-    };
-}
-#[cfg(all(feature = "derive", not(feature = "full")))]
-macro_rules! full {
-    ($e:expr) => {
-        unreachable!()
-    };
-}
-/// Syntax tree traversal to transform the nodes of an owned syntax tree.
-///
-/// See the [module documentation] for details.
-///
-/// [module documentation]: self
-///
-/// *This trait is available only if Syn is built with the `"fold"` feature.*
-pub trait Fold {
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_abi(&mut self, i: Abi) -> Abi {
-        fold_abi(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_angle_bracketed_generic_arguments(
-        &mut self,
-        i: AngleBracketedGenericArguments,
-    ) -> AngleBracketedGenericArguments {
-        fold_angle_bracketed_generic_arguments(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_arm(&mut self, i: Arm) -> Arm {
-        fold_arm(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle {
-        fold_attr_style(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_attribute(&mut self, i: Attribute) -> Attribute {
-        fold_attribute(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg {
-        fold_bare_fn_arg(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_bin_op(&mut self, i: BinOp) -> BinOp {
-        fold_bin_op(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_binding(&mut self, i: Binding) -> Binding {
-        fold_binding(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_block(&mut self, i: Block) -> Block {
-        fold_block(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes {
-        fold_bound_lifetimes(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_const_param(&mut self, i: ConstParam) -> ConstParam {
-        fold_const_param(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_constraint(&mut self, i: Constraint) -> Constraint {
-        fold_constraint(self, i)
-    }
-    #[cfg(feature = "derive")]
-    fn fold_data(&mut self, i: Data) -> Data {
-        fold_data(self, i)
-    }
-    #[cfg(feature = "derive")]
-    fn fold_data_enum(&mut self, i: DataEnum) -> DataEnum {
-        fold_data_enum(self, i)
-    }
-    #[cfg(feature = "derive")]
-    fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct {
-        fold_data_struct(self, i)
-    }
-    #[cfg(feature = "derive")]
-    fn fold_data_union(&mut self, i: DataUnion) -> DataUnion {
-        fold_data_union(self, i)
-    }
-    #[cfg(feature = "derive")]
-    fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput {
-        fold_derive_input(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr(&mut self, i: Expr) -> Expr {
-        fold_expr(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray {
-        fold_expr_array(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign {
-        fold_expr_assign(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp {
-        fold_expr_assign_op(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync {
-        fold_expr_async(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_await(&mut self, i: ExprAwait) -> ExprAwait {
-        fold_expr_await(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary {
-        fold_expr_binary(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock {
-        fold_expr_block(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox {
-        fold_expr_box(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak {
-        fold_expr_break(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall {
-        fold_expr_call(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast {
-        fold_expr_cast(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure {
-        fold_expr_closure(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue {
-        fold_expr_continue(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_field(&mut self, i: ExprField) -> ExprField {
-        fold_expr_field(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop {
-        fold_expr_for_loop(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup {
-        fold_expr_group(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf {
-        fold_expr_if(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex {
-        fold_expr_index(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet {
-        fold_expr_let(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit {
-        fold_expr_lit(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop {
-        fold_expr_loop(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro {
-        fold_expr_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch {
-        fold_expr_match(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall {
-        fold_expr_method_call(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen {
-        fold_expr_paren(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath {
-        fold_expr_path(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange {
-        fold_expr_range(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference {
-        fold_expr_reference(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat {
-        fold_expr_repeat(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn {
-        fold_expr_return(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct {
-        fold_expr_struct(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry {
-        fold_expr_try(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock {
-        fold_expr_try_block(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple {
-        fold_expr_tuple(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_type(&mut self, i: ExprType) -> ExprType {
-        fold_expr_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary {
-        fold_expr_unary(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe {
-        fold_expr_unsafe(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile {
-        fold_expr_while(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield {
-        fold_expr_yield(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_field(&mut self, i: Field) -> Field {
-        fold_field(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat {
-        fold_field_pat(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_field_value(&mut self, i: FieldValue) -> FieldValue {
-        fold_field_value(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_fields(&mut self, i: Fields) -> Fields {
-        fold_fields(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed {
-        fold_fields_named(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed {
-        fold_fields_unnamed(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_file(&mut self, i: File) -> File {
-        fold_file(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_fn_arg(&mut self, i: FnArg) -> FnArg {
-        fold_fn_arg(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem {
-        fold_foreign_item(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn {
-        fold_foreign_item_fn(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_foreign_item_macro(&mut self, i: ForeignItemMacro) -> ForeignItemMacro {
-        fold_foreign_item_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic {
-        fold_foreign_item_static(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType {
-        fold_foreign_item_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument {
-        fold_generic_argument(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_generic_method_argument(&mut self, i: GenericMethodArgument) -> GenericMethodArgument {
-        fold_generic_method_argument(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam {
-        fold_generic_param(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_generics(&mut self, i: Generics) -> Generics {
-        fold_generics(self, i)
-    }
-    fn fold_ident(&mut self, i: Ident) -> Ident {
-        fold_ident(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem {
-        fold_impl_item(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst {
-        fold_impl_item_const(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro {
-        fold_impl_item_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod {
-        fold_impl_item_method(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType {
-        fold_impl_item_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_index(&mut self, i: Index) -> Index {
-        fold_index(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item(&mut self, i: Item) -> Item {
-        fold_item(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_const(&mut self, i: ItemConst) -> ItemConst {
-        fold_item_const(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum {
-        fold_item_enum(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate {
-        fold_item_extern_crate(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn {
-        fold_item_fn(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod {
-        fold_item_foreign_mod(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl {
-        fold_item_impl(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro {
-        fold_item_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_macro2(&mut self, i: ItemMacro2) -> ItemMacro2 {
-        fold_item_macro2(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod {
-        fold_item_mod(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic {
-        fold_item_static(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct {
-        fold_item_struct(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait {
-        fold_item_trait(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias {
-        fold_item_trait_alias(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_type(&mut self, i: ItemType) -> ItemType {
-        fold_item_type(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion {
-        fold_item_union(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_item_use(&mut self, i: ItemUse) -> ItemUse {
-        fold_item_use(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_label(&mut self, i: Label) -> Label {
-        fold_label(self, i)
-    }
-    fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime {
-        fold_lifetime(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef {
-        fold_lifetime_def(self, i)
-    }
-    fn fold_lit(&mut self, i: Lit) -> Lit {
-        fold_lit(self, i)
-    }
-    fn fold_lit_bool(&mut self, i: LitBool) -> LitBool {
-        fold_lit_bool(self, i)
-    }
-    fn fold_lit_byte(&mut self, i: LitByte) -> LitByte {
-        fold_lit_byte(self, i)
-    }
-    fn fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr {
-        fold_lit_byte_str(self, i)
-    }
-    fn fold_lit_char(&mut self, i: LitChar) -> LitChar {
-        fold_lit_char(self, i)
-    }
-    fn fold_lit_float(&mut self, i: LitFloat) -> LitFloat {
-        fold_lit_float(self, i)
-    }
-    fn fold_lit_int(&mut self, i: LitInt) -> LitInt {
-        fold_lit_int(self, i)
-    }
-    fn fold_lit_str(&mut self, i: LitStr) -> LitStr {
-        fold_lit_str(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_local(&mut self, i: Local) -> Local {
-        fold_local(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_macro(&mut self, i: Macro) -> Macro {
-        fold_macro(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter {
-        fold_macro_delimiter(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_member(&mut self, i: Member) -> Member {
-        fold_member(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_meta(&mut self, i: Meta) -> Meta {
-        fold_meta(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_meta_list(&mut self, i: MetaList) -> MetaList {
-        fold_meta_list(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue {
-        fold_meta_name_value(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish {
-        fold_method_turbofish(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta {
-        fold_nested_meta(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_parenthesized_generic_arguments(
-        &mut self,
-        i: ParenthesizedGenericArguments,
-    ) -> ParenthesizedGenericArguments {
-        fold_parenthesized_generic_arguments(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat(&mut self, i: Pat) -> Pat {
-        fold_pat(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_box(&mut self, i: PatBox) -> PatBox {
-        fold_pat_box(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent {
-        fold_pat_ident(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_lit(&mut self, i: PatLit) -> PatLit {
-        fold_pat_lit(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_macro(&mut self, i: PatMacro) -> PatMacro {
-        fold_pat_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_or(&mut self, i: PatOr) -> PatOr {
-        fold_pat_or(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_path(&mut self, i: PatPath) -> PatPath {
-        fold_pat_path(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_range(&mut self, i: PatRange) -> PatRange {
-        fold_pat_range(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_reference(&mut self, i: PatReference) -> PatReference {
-        fold_pat_reference(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_rest(&mut self, i: PatRest) -> PatRest {
-        fold_pat_rest(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice {
-        fold_pat_slice(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct {
-        fold_pat_struct(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple {
-        fold_pat_tuple(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct {
-        fold_pat_tuple_struct(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_type(&mut self, i: PatType) -> PatType {
-        fold_pat_type(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_pat_wild(&mut self, i: PatWild) -> PatWild {
-        fold_pat_wild(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_path(&mut self, i: Path) -> Path {
-        fold_path(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments {
-        fold_path_arguments(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment {
-        fold_path_segment(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq {
-        fold_predicate_eq(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime {
-        fold_predicate_lifetime(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType {
-        fold_predicate_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_qself(&mut self, i: QSelf) -> QSelf {
-        fold_qself(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits {
-        fold_range_limits(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_receiver(&mut self, i: Receiver) -> Receiver {
-        fold_receiver(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_return_type(&mut self, i: ReturnType) -> ReturnType {
-        fold_return_type(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_signature(&mut self, i: Signature) -> Signature {
-        fold_signature(self, i)
-    }
-    fn fold_span(&mut self, i: Span) -> Span {
-        fold_span(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_stmt(&mut self, i: Stmt) -> Stmt {
-        fold_stmt(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound {
-        fold_trait_bound(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier {
-        fold_trait_bound_modifier(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem {
-        fold_trait_item(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst {
-        fold_trait_item_const(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro {
-        fold_trait_item_macro(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod {
-        fold_trait_item_method(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType {
-        fold_trait_item_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type(&mut self, i: Type) -> Type {
-        fold_type(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_array(&mut self, i: TypeArray) -> TypeArray {
-        fold_type_array(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn {
-        fold_type_bare_fn(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup {
-        fold_type_group(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait {
-        fold_type_impl_trait(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer {
-        fold_type_infer(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro {
-        fold_type_macro(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_never(&mut self, i: TypeNever) -> TypeNever {
-        fold_type_never(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_param(&mut self, i: TypeParam) -> TypeParam {
-        fold_type_param(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound {
-        fold_type_param_bound(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen {
-        fold_type_paren(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_path(&mut self, i: TypePath) -> TypePath {
-        fold_type_path(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr {
-        fold_type_ptr(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference {
-        fold_type_reference(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice {
-        fold_type_slice(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject {
-        fold_type_trait_object(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple {
-        fold_type_tuple(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_un_op(&mut self, i: UnOp) -> UnOp {
-        fold_un_op(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob {
-        fold_use_glob(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_group(&mut self, i: UseGroup) -> UseGroup {
-        fold_use_group(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_name(&mut self, i: UseName) -> UseName {
-        fold_use_name(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_path(&mut self, i: UsePath) -> UsePath {
-        fold_use_path(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_rename(&mut self, i: UseRename) -> UseRename {
-        fold_use_rename(self, i)
-    }
-    #[cfg(feature = "full")]
-    fn fold_use_tree(&mut self, i: UseTree) -> UseTree {
-        fold_use_tree(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_variadic(&mut self, i: Variadic) -> Variadic {
-        fold_variadic(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_variant(&mut self, i: Variant) -> Variant {
-        fold_variant(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate {
-        fold_vis_crate(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic {
-        fold_vis_public(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted {
-        fold_vis_restricted(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_visibility(&mut self, i: Visibility) -> Visibility {
-        fold_visibility(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause {
-        fold_where_clause(self, i)
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate {
-        fold_where_predicate(self, i)
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_abi<F>(f: &mut F, node: Abi) -> Abi
-where
-    F: Fold + ?Sized,
-{
-    Abi {
-        extern_token: Token![extern](tokens_helper(f, &node.extern_token.span)),
-        name: (node.name).map(|it| f.fold_lit_str(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_angle_bracketed_generic_arguments<F>(
-    f: &mut F,
-    node: AngleBracketedGenericArguments,
-) -> AngleBracketedGenericArguments
-where
-    F: Fold + ?Sized,
-{
-    AngleBracketedGenericArguments {
-        colon2_token: (node.colon2_token).map(|it| Token ! [::](tokens_helper(f, &it.spans))),
-        lt_token: Token ! [<](tokens_helper(f, &node.lt_token.spans)),
-        args: FoldHelper::lift(node.args, |it| f.fold_generic_argument(it)),
-        gt_token: Token ! [>](tokens_helper(f, &node.gt_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_arm<F>(f: &mut F, node: Arm) -> Arm
-where
-    F: Fold + ?Sized,
-{
-    Arm {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        pat: f.fold_pat(node.pat),
-        guard: (node.guard).map(|it| {
-            (
-                Token![if](tokens_helper(f, &(it).0.span)),
-                Box::new(f.fold_expr(*(it).1)),
-            )
-        }),
-        fat_arrow_token: Token ! [=>](tokens_helper(f, &node.fat_arrow_token.spans)),
-        body: Box::new(f.fold_expr(*node.body)),
-        comma: (node.comma).map(|it| Token ! [,](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_attr_style<F>(f: &mut F, node: AttrStyle) -> AttrStyle
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        AttrStyle::Outer => AttrStyle::Outer,
-        AttrStyle::Inner(_binding_0) => {
-            AttrStyle::Inner(Token![!](tokens_helper(f, &_binding_0.spans)))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_attribute<F>(f: &mut F, node: Attribute) -> Attribute
-where
-    F: Fold + ?Sized,
-{
-    Attribute {
-        pound_token: Token ! [#](tokens_helper(f, &node.pound_token.spans)),
-        style: f.fold_attr_style(node.style),
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        path: f.fold_path(node.path),
-        tokens: node.tokens,
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_bare_fn_arg<F>(f: &mut F, node: BareFnArg) -> BareFnArg
-where
-    F: Fold + ?Sized,
-{
-    BareFnArg {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        name: (node.name).map(|it| {
-            (
-                f.fold_ident((it).0),
-                Token ! [:](tokens_helper(f, &(it).1.spans)),
-            )
-        }),
-        ty: f.fold_type(node.ty),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_bin_op<F>(f: &mut F, node: BinOp) -> BinOp
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        BinOp::Add(_binding_0) => BinOp::Add(Token ! [+](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Sub(_binding_0) => BinOp::Sub(Token ! [-](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Mul(_binding_0) => BinOp::Mul(Token ! [*](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Div(_binding_0) => BinOp::Div(Token ! [/](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Rem(_binding_0) => BinOp::Rem(Token ! [%](tokens_helper(f, &_binding_0.spans))),
-        BinOp::And(_binding_0) => BinOp::And(Token ! [&&](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Or(_binding_0) => BinOp::Or(Token ! [||](tokens_helper(f, &_binding_0.spans))),
-        BinOp::BitXor(_binding_0) => {
-            BinOp::BitXor(Token ! [^](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::BitAnd(_binding_0) => {
-            BinOp::BitAnd(Token ! [&](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::BitOr(_binding_0) => BinOp::BitOr(Token ! [|](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Shl(_binding_0) => BinOp::Shl(Token ! [<<](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Shr(_binding_0) => BinOp::Shr(Token ! [>>](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Eq(_binding_0) => BinOp::Eq(Token ! [==](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Lt(_binding_0) => BinOp::Lt(Token ! [<](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Le(_binding_0) => BinOp::Le(Token ! [<=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Ne(_binding_0) => BinOp::Ne(Token ! [!=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Ge(_binding_0) => BinOp::Ge(Token ! [>=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::Gt(_binding_0) => BinOp::Gt(Token ! [>](tokens_helper(f, &_binding_0.spans))),
-        BinOp::AddEq(_binding_0) => BinOp::AddEq(Token ! [+=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::SubEq(_binding_0) => BinOp::SubEq(Token ! [-=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::MulEq(_binding_0) => BinOp::MulEq(Token ! [*=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::DivEq(_binding_0) => BinOp::DivEq(Token ! [/=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::RemEq(_binding_0) => BinOp::RemEq(Token ! [%=](tokens_helper(f, &_binding_0.spans))),
-        BinOp::BitXorEq(_binding_0) => {
-            BinOp::BitXorEq(Token ! [^=](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::BitAndEq(_binding_0) => {
-            BinOp::BitAndEq(Token ! [&=](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::BitOrEq(_binding_0) => {
-            BinOp::BitOrEq(Token ! [|=](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::ShlEq(_binding_0) => {
-            BinOp::ShlEq(Token ! [<<=](tokens_helper(f, &_binding_0.spans)))
-        }
-        BinOp::ShrEq(_binding_0) => {
-            BinOp::ShrEq(Token ! [>>=](tokens_helper(f, &_binding_0.spans)))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_binding<F>(f: &mut F, node: Binding) -> Binding
-where
-    F: Fold + ?Sized,
-{
-    Binding {
-        ident: f.fold_ident(node.ident),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        ty: f.fold_type(node.ty),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_block<F>(f: &mut F, node: Block) -> Block
-where
-    F: Fold + ?Sized,
-{
-    Block {
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        stmts: FoldHelper::lift(node.stmts, |it| f.fold_stmt(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_bound_lifetimes<F>(f: &mut F, node: BoundLifetimes) -> BoundLifetimes
-where
-    F: Fold + ?Sized,
-{
-    BoundLifetimes {
-        for_token: Token![for](tokens_helper(f, &node.for_token.span)),
-        lt_token: Token ! [<](tokens_helper(f, &node.lt_token.spans)),
-        lifetimes: FoldHelper::lift(node.lifetimes, |it| f.fold_lifetime_def(it)),
-        gt_token: Token ! [>](tokens_helper(f, &node.gt_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_const_param<F>(f: &mut F, node: ConstParam) -> ConstParam
-where
-    F: Fold + ?Sized,
-{
-    ConstParam {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        const_token: Token![const](tokens_helper(f, &node.const_token.span)),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: f.fold_type(node.ty),
-        eq_token: (node.eq_token).map(|it| Token ! [=](tokens_helper(f, &it.spans))),
-        default: (node.default).map(|it| f.fold_expr(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_constraint<F>(f: &mut F, node: Constraint) -> Constraint
-where
-    F: Fold + ?Sized,
-{
-    Constraint {
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-    }
-}
-#[cfg(feature = "derive")]
-pub fn fold_data<F>(f: &mut F, node: Data) -> Data
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Data::Struct(_binding_0) => Data::Struct(f.fold_data_struct(_binding_0)),
-        Data::Enum(_binding_0) => Data::Enum(f.fold_data_enum(_binding_0)),
-        Data::Union(_binding_0) => Data::Union(f.fold_data_union(_binding_0)),
-    }
-}
-#[cfg(feature = "derive")]
-pub fn fold_data_enum<F>(f: &mut F, node: DataEnum) -> DataEnum
-where
-    F: Fold + ?Sized,
-{
-    DataEnum {
-        enum_token: Token![enum](tokens_helper(f, &node.enum_token.span)),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        variants: FoldHelper::lift(node.variants, |it| f.fold_variant(it)),
-    }
-}
-#[cfg(feature = "derive")]
-pub fn fold_data_struct<F>(f: &mut F, node: DataStruct) -> DataStruct
-where
-    F: Fold + ?Sized,
-{
-    DataStruct {
-        struct_token: Token![struct](tokens_helper(f, &node.struct_token.span)),
-        fields: f.fold_fields(node.fields),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "derive")]
-pub fn fold_data_union<F>(f: &mut F, node: DataUnion) -> DataUnion
-where
-    F: Fold + ?Sized,
-{
-    DataUnion {
-        union_token: Token![union](tokens_helper(f, &node.union_token.span)),
-        fields: f.fold_fields_named(node.fields),
-    }
-}
-#[cfg(feature = "derive")]
-pub fn fold_derive_input<F>(f: &mut F, node: DeriveInput) -> DeriveInput
-where
-    F: Fold + ?Sized,
-{
-    DeriveInput {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        data: f.fold_data(node.data),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr<F>(f: &mut F, node: Expr) -> Expr
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Expr::Array(_binding_0) => Expr::Array(full!(f.fold_expr_array(_binding_0))),
-        Expr::Assign(_binding_0) => Expr::Assign(full!(f.fold_expr_assign(_binding_0))),
-        Expr::AssignOp(_binding_0) => Expr::AssignOp(full!(f.fold_expr_assign_op(_binding_0))),
-        Expr::Async(_binding_0) => Expr::Async(full!(f.fold_expr_async(_binding_0))),
-        Expr::Await(_binding_0) => Expr::Await(full!(f.fold_expr_await(_binding_0))),
-        Expr::Binary(_binding_0) => Expr::Binary(f.fold_expr_binary(_binding_0)),
-        Expr::Block(_binding_0) => Expr::Block(full!(f.fold_expr_block(_binding_0))),
-        Expr::Box(_binding_0) => Expr::Box(full!(f.fold_expr_box(_binding_0))),
-        Expr::Break(_binding_0) => Expr::Break(full!(f.fold_expr_break(_binding_0))),
-        Expr::Call(_binding_0) => Expr::Call(f.fold_expr_call(_binding_0)),
-        Expr::Cast(_binding_0) => Expr::Cast(f.fold_expr_cast(_binding_0)),
-        Expr::Closure(_binding_0) => Expr::Closure(full!(f.fold_expr_closure(_binding_0))),
-        Expr::Continue(_binding_0) => Expr::Continue(full!(f.fold_expr_continue(_binding_0))),
-        Expr::Field(_binding_0) => Expr::Field(f.fold_expr_field(_binding_0)),
-        Expr::ForLoop(_binding_0) => Expr::ForLoop(full!(f.fold_expr_for_loop(_binding_0))),
-        Expr::Group(_binding_0) => Expr::Group(full!(f.fold_expr_group(_binding_0))),
-        Expr::If(_binding_0) => Expr::If(full!(f.fold_expr_if(_binding_0))),
-        Expr::Index(_binding_0) => Expr::Index(f.fold_expr_index(_binding_0)),
-        Expr::Let(_binding_0) => Expr::Let(full!(f.fold_expr_let(_binding_0))),
-        Expr::Lit(_binding_0) => Expr::Lit(f.fold_expr_lit(_binding_0)),
-        Expr::Loop(_binding_0) => Expr::Loop(full!(f.fold_expr_loop(_binding_0))),
-        Expr::Macro(_binding_0) => Expr::Macro(full!(f.fold_expr_macro(_binding_0))),
-        Expr::Match(_binding_0) => Expr::Match(full!(f.fold_expr_match(_binding_0))),
-        Expr::MethodCall(_binding_0) => {
-            Expr::MethodCall(full!(f.fold_expr_method_call(_binding_0)))
-        }
-        Expr::Paren(_binding_0) => Expr::Paren(f.fold_expr_paren(_binding_0)),
-        Expr::Path(_binding_0) => Expr::Path(f.fold_expr_path(_binding_0)),
-        Expr::Range(_binding_0) => Expr::Range(full!(f.fold_expr_range(_binding_0))),
-        Expr::Reference(_binding_0) => Expr::Reference(full!(f.fold_expr_reference(_binding_0))),
-        Expr::Repeat(_binding_0) => Expr::Repeat(full!(f.fold_expr_repeat(_binding_0))),
-        Expr::Return(_binding_0) => Expr::Return(full!(f.fold_expr_return(_binding_0))),
-        Expr::Struct(_binding_0) => Expr::Struct(full!(f.fold_expr_struct(_binding_0))),
-        Expr::Try(_binding_0) => Expr::Try(full!(f.fold_expr_try(_binding_0))),
-        Expr::TryBlock(_binding_0) => Expr::TryBlock(full!(f.fold_expr_try_block(_binding_0))),
-        Expr::Tuple(_binding_0) => Expr::Tuple(full!(f.fold_expr_tuple(_binding_0))),
-        Expr::Type(_binding_0) => Expr::Type(full!(f.fold_expr_type(_binding_0))),
-        Expr::Unary(_binding_0) => Expr::Unary(f.fold_expr_unary(_binding_0)),
-        Expr::Unsafe(_binding_0) => Expr::Unsafe(full!(f.fold_expr_unsafe(_binding_0))),
-        Expr::Verbatim(_binding_0) => Expr::Verbatim(_binding_0),
-        Expr::While(_binding_0) => Expr::While(full!(f.fold_expr_while(_binding_0))),
-        Expr::Yield(_binding_0) => Expr::Yield(full!(f.fold_expr_yield(_binding_0))),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_array<F>(f: &mut F, node: ExprArray) -> ExprArray
-where
-    F: Fold + ?Sized,
-{
-    ExprArray {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        elems: FoldHelper::lift(node.elems, |it| f.fold_expr(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_assign<F>(f: &mut F, node: ExprAssign) -> ExprAssign
-where
-    F: Fold + ?Sized,
-{
-    ExprAssign {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        left: Box::new(f.fold_expr(*node.left)),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        right: Box::new(f.fold_expr(*node.right)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_assign_op<F>(f: &mut F, node: ExprAssignOp) -> ExprAssignOp
-where
-    F: Fold + ?Sized,
-{
-    ExprAssignOp {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        left: Box::new(f.fold_expr(*node.left)),
-        op: f.fold_bin_op(node.op),
-        right: Box::new(f.fold_expr(*node.right)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_async<F>(f: &mut F, node: ExprAsync) -> ExprAsync
-where
-    F: Fold + ?Sized,
-{
-    ExprAsync {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        async_token: Token![async](tokens_helper(f, &node.async_token.span)),
-        capture: (node.capture).map(|it| Token![move](tokens_helper(f, &it.span))),
-        block: f.fold_block(node.block),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_await<F>(f: &mut F, node: ExprAwait) -> ExprAwait
-where
-    F: Fold + ?Sized,
-{
-    ExprAwait {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        base: Box::new(f.fold_expr(*node.base)),
-        dot_token: Token ! [.](tokens_helper(f, &node.dot_token.spans)),
-        await_token: crate::token::Await(tokens_helper(f, &node.await_token.span)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_binary<F>(f: &mut F, node: ExprBinary) -> ExprBinary
-where
-    F: Fold + ?Sized,
-{
-    ExprBinary {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        left: Box::new(f.fold_expr(*node.left)),
-        op: f.fold_bin_op(node.op),
-        right: Box::new(f.fold_expr(*node.right)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_block<F>(f: &mut F, node: ExprBlock) -> ExprBlock
-where
-    F: Fold + ?Sized,
-{
-    ExprBlock {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        label: (node.label).map(|it| f.fold_label(it)),
-        block: f.fold_block(node.block),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_box<F>(f: &mut F, node: ExprBox) -> ExprBox
-where
-    F: Fold + ?Sized,
-{
-    ExprBox {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        box_token: Token![box](tokens_helper(f, &node.box_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_break<F>(f: &mut F, node: ExprBreak) -> ExprBreak
-where
-    F: Fold + ?Sized,
-{
-    ExprBreak {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        break_token: Token![break](tokens_helper(f, &node.break_token.span)),
-        label: (node.label).map(|it| f.fold_lifetime(it)),
-        expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_call<F>(f: &mut F, node: ExprCall) -> ExprCall
-where
-    F: Fold + ?Sized,
-{
-    ExprCall {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        func: Box::new(f.fold_expr(*node.func)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        args: FoldHelper::lift(node.args, |it| f.fold_expr(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_cast<F>(f: &mut F, node: ExprCast) -> ExprCast
-where
-    F: Fold + ?Sized,
-{
-    ExprCast {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        as_token: Token![as](tokens_helper(f, &node.as_token.span)),
-        ty: Box::new(f.fold_type(*node.ty)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_closure<F>(f: &mut F, node: ExprClosure) -> ExprClosure
-where
-    F: Fold + ?Sized,
-{
-    ExprClosure {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        asyncness: (node.asyncness).map(|it| Token![async](tokens_helper(f, &it.span))),
-        movability: (node.movability).map(|it| Token![static](tokens_helper(f, &it.span))),
-        capture: (node.capture).map(|it| Token![move](tokens_helper(f, &it.span))),
-        or1_token: Token ! [|](tokens_helper(f, &node.or1_token.spans)),
-        inputs: FoldHelper::lift(node.inputs, |it| f.fold_pat(it)),
-        or2_token: Token ! [|](tokens_helper(f, &node.or2_token.spans)),
-        output: f.fold_return_type(node.output),
-        body: Box::new(f.fold_expr(*node.body)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_continue<F>(f: &mut F, node: ExprContinue) -> ExprContinue
-where
-    F: Fold + ?Sized,
-{
-    ExprContinue {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        continue_token: Token![continue](tokens_helper(f, &node.continue_token.span)),
-        label: (node.label).map(|it| f.fold_lifetime(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_field<F>(f: &mut F, node: ExprField) -> ExprField
-where
-    F: Fold + ?Sized,
-{
-    ExprField {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        base: Box::new(f.fold_expr(*node.base)),
-        dot_token: Token ! [.](tokens_helper(f, &node.dot_token.spans)),
-        member: f.fold_member(node.member),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_for_loop<F>(f: &mut F, node: ExprForLoop) -> ExprForLoop
-where
-    F: Fold + ?Sized,
-{
-    ExprForLoop {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        label: (node.label).map(|it| f.fold_label(it)),
-        for_token: Token![for](tokens_helper(f, &node.for_token.span)),
-        pat: f.fold_pat(node.pat),
-        in_token: Token![in](tokens_helper(f, &node.in_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        body: f.fold_block(node.body),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_group<F>(f: &mut F, node: ExprGroup) -> ExprGroup
-where
-    F: Fold + ?Sized,
-{
-    ExprGroup {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        group_token: Group(tokens_helper(f, &node.group_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_if<F>(f: &mut F, node: ExprIf) -> ExprIf
-where
-    F: Fold + ?Sized,
-{
-    ExprIf {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        if_token: Token![if](tokens_helper(f, &node.if_token.span)),
-        cond: Box::new(f.fold_expr(*node.cond)),
-        then_branch: f.fold_block(node.then_branch),
-        else_branch: (node.else_branch).map(|it| {
-            (
-                Token![else](tokens_helper(f, &(it).0.span)),
-                Box::new(f.fold_expr(*(it).1)),
-            )
-        }),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_index<F>(f: &mut F, node: ExprIndex) -> ExprIndex
-where
-    F: Fold + ?Sized,
-{
-    ExprIndex {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        index: Box::new(f.fold_expr(*node.index)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_let<F>(f: &mut F, node: ExprLet) -> ExprLet
-where
-    F: Fold + ?Sized,
-{
-    ExprLet {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        let_token: Token![let](tokens_helper(f, &node.let_token.span)),
-        pat: f.fold_pat(node.pat),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_lit<F>(f: &mut F, node: ExprLit) -> ExprLit
-where
-    F: Fold + ?Sized,
-{
-    ExprLit {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        lit: f.fold_lit(node.lit),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_loop<F>(f: &mut F, node: ExprLoop) -> ExprLoop
-where
-    F: Fold + ?Sized,
-{
-    ExprLoop {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        label: (node.label).map(|it| f.fold_label(it)),
-        loop_token: Token![loop](tokens_helper(f, &node.loop_token.span)),
-        body: f.fold_block(node.body),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_macro<F>(f: &mut F, node: ExprMacro) -> ExprMacro
-where
-    F: Fold + ?Sized,
-{
-    ExprMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        mac: f.fold_macro(node.mac),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_match<F>(f: &mut F, node: ExprMatch) -> ExprMatch
-where
-    F: Fold + ?Sized,
-{
-    ExprMatch {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        match_token: Token![match](tokens_helper(f, &node.match_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        arms: FoldHelper::lift(node.arms, |it| f.fold_arm(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_method_call<F>(f: &mut F, node: ExprMethodCall) -> ExprMethodCall
-where
-    F: Fold + ?Sized,
-{
-    ExprMethodCall {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        receiver: Box::new(f.fold_expr(*node.receiver)),
-        dot_token: Token ! [.](tokens_helper(f, &node.dot_token.spans)),
-        method: f.fold_ident(node.method),
-        turbofish: (node.turbofish).map(|it| f.fold_method_turbofish(it)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        args: FoldHelper::lift(node.args, |it| f.fold_expr(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_paren<F>(f: &mut F, node: ExprParen) -> ExprParen
-where
-    F: Fold + ?Sized,
-{
-    ExprParen {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_path<F>(f: &mut F, node: ExprPath) -> ExprPath
-where
-    F: Fold + ?Sized,
-{
-    ExprPath {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        qself: (node.qself).map(|it| f.fold_qself(it)),
-        path: f.fold_path(node.path),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_range<F>(f: &mut F, node: ExprRange) -> ExprRange
-where
-    F: Fold + ?Sized,
-{
-    ExprRange {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        from: (node.from).map(|it| Box::new(f.fold_expr(*it))),
-        limits: f.fold_range_limits(node.limits),
-        to: (node.to).map(|it| Box::new(f.fold_expr(*it))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_reference<F>(f: &mut F, node: ExprReference) -> ExprReference
-where
-    F: Fold + ?Sized,
-{
-    ExprReference {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        and_token: Token ! [&](tokens_helper(f, &node.and_token.spans)),
-        raw: node.raw,
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_repeat<F>(f: &mut F, node: ExprRepeat) -> ExprRepeat
-where
-    F: Fold + ?Sized,
-{
-    ExprRepeat {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-        len: Box::new(f.fold_expr(*node.len)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_return<F>(f: &mut F, node: ExprReturn) -> ExprReturn
-where
-    F: Fold + ?Sized,
-{
-    ExprReturn {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        return_token: Token![return](tokens_helper(f, &node.return_token.span)),
-        expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_struct<F>(f: &mut F, node: ExprStruct) -> ExprStruct
-where
-    F: Fold + ?Sized,
-{
-    ExprStruct {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        path: f.fold_path(node.path),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        fields: FoldHelper::lift(node.fields, |it| f.fold_field_value(it)),
-        dot2_token: (node.dot2_token).map(|it| Token![..](tokens_helper(f, &it.spans))),
-        rest: (node.rest).map(|it| Box::new(f.fold_expr(*it))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_try<F>(f: &mut F, node: ExprTry) -> ExprTry
-where
-    F: Fold + ?Sized,
-{
-    ExprTry {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        question_token: Token ! [?](tokens_helper(f, &node.question_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_try_block<F>(f: &mut F, node: ExprTryBlock) -> ExprTryBlock
-where
-    F: Fold + ?Sized,
-{
-    ExprTryBlock {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        try_token: Token![try](tokens_helper(f, &node.try_token.span)),
-        block: f.fold_block(node.block),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_tuple<F>(f: &mut F, node: ExprTuple) -> ExprTuple
-where
-    F: Fold + ?Sized,
-{
-    ExprTuple {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        elems: FoldHelper::lift(node.elems, |it| f.fold_expr(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_type<F>(f: &mut F, node: ExprType) -> ExprType
-where
-    F: Fold + ?Sized,
-{
-    ExprType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_expr_unary<F>(f: &mut F, node: ExprUnary) -> ExprUnary
-where
-    F: Fold + ?Sized,
-{
-    ExprUnary {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        op: f.fold_un_op(node.op),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_unsafe<F>(f: &mut F, node: ExprUnsafe) -> ExprUnsafe
-where
-    F: Fold + ?Sized,
-{
-    ExprUnsafe {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        unsafe_token: Token![unsafe](tokens_helper(f, &node.unsafe_token.span)),
-        block: f.fold_block(node.block),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_while<F>(f: &mut F, node: ExprWhile) -> ExprWhile
-where
-    F: Fold + ?Sized,
-{
-    ExprWhile {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        label: (node.label).map(|it| f.fold_label(it)),
-        while_token: Token![while](tokens_helper(f, &node.while_token.span)),
-        cond: Box::new(f.fold_expr(*node.cond)),
-        body: f.fold_block(node.body),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_expr_yield<F>(f: &mut F, node: ExprYield) -> ExprYield
-where
-    F: Fold + ?Sized,
-{
-    ExprYield {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        yield_token: Token![yield](tokens_helper(f, &node.yield_token.span)),
-        expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_field<F>(f: &mut F, node: Field) -> Field
-where
-    F: Fold + ?Sized,
-{
-    Field {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        ident: (node.ident).map(|it| f.fold_ident(it)),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        ty: f.fold_type(node.ty),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_field_pat<F>(f: &mut F, node: FieldPat) -> FieldPat
-where
-    F: Fold + ?Sized,
-{
-    FieldPat {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        member: f.fold_member(node.member),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        pat: Box::new(f.fold_pat(*node.pat)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_field_value<F>(f: &mut F, node: FieldValue) -> FieldValue
-where
-    F: Fold + ?Sized,
-{
-    FieldValue {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        member: f.fold_member(node.member),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        expr: f.fold_expr(node.expr),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_fields<F>(f: &mut F, node: Fields) -> Fields
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Fields::Named(_binding_0) => Fields::Named(f.fold_fields_named(_binding_0)),
-        Fields::Unnamed(_binding_0) => Fields::Unnamed(f.fold_fields_unnamed(_binding_0)),
-        Fields::Unit => Fields::Unit,
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_fields_named<F>(f: &mut F, node: FieldsNamed) -> FieldsNamed
-where
-    F: Fold + ?Sized,
-{
-    FieldsNamed {
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        named: FoldHelper::lift(node.named, |it| f.fold_field(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_fields_unnamed<F>(f: &mut F, node: FieldsUnnamed) -> FieldsUnnamed
-where
-    F: Fold + ?Sized,
-{
-    FieldsUnnamed {
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        unnamed: FoldHelper::lift(node.unnamed, |it| f.fold_field(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_file<F>(f: &mut F, node: File) -> File
-where
-    F: Fold + ?Sized,
-{
-    File {
-        shebang: node.shebang,
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        items: FoldHelper::lift(node.items, |it| f.fold_item(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_fn_arg<F>(f: &mut F, node: FnArg) -> FnArg
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        FnArg::Receiver(_binding_0) => FnArg::Receiver(f.fold_receiver(_binding_0)),
-        FnArg::Typed(_binding_0) => FnArg::Typed(f.fold_pat_type(_binding_0)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_foreign_item<F>(f: &mut F, node: ForeignItem) -> ForeignItem
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        ForeignItem::Fn(_binding_0) => ForeignItem::Fn(f.fold_foreign_item_fn(_binding_0)),
-        ForeignItem::Static(_binding_0) => {
-            ForeignItem::Static(f.fold_foreign_item_static(_binding_0))
-        }
-        ForeignItem::Type(_binding_0) => ForeignItem::Type(f.fold_foreign_item_type(_binding_0)),
-        ForeignItem::Macro(_binding_0) => ForeignItem::Macro(f.fold_foreign_item_macro(_binding_0)),
-        ForeignItem::Verbatim(_binding_0) => ForeignItem::Verbatim(_binding_0),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_foreign_item_fn<F>(f: &mut F, node: ForeignItemFn) -> ForeignItemFn
-where
-    F: Fold + ?Sized,
-{
-    ForeignItemFn {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        sig: f.fold_signature(node.sig),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_foreign_item_macro<F>(f: &mut F, node: ForeignItemMacro) -> ForeignItemMacro
-where
-    F: Fold + ?Sized,
-{
-    ForeignItemMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        mac: f.fold_macro(node.mac),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_foreign_item_static<F>(f: &mut F, node: ForeignItemStatic) -> ForeignItemStatic
-where
-    F: Fold + ?Sized,
-{
-    ForeignItemStatic {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        static_token: Token![static](tokens_helper(f, &node.static_token.span)),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_foreign_item_type<F>(f: &mut F, node: ForeignItemType) -> ForeignItemType
-where
-    F: Fold + ?Sized,
-{
-    ForeignItemType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        type_token: Token![type](tokens_helper(f, &node.type_token.span)),
-        ident: f.fold_ident(node.ident),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_generic_argument<F>(f: &mut F, node: GenericArgument) -> GenericArgument
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        GenericArgument::Lifetime(_binding_0) => {
-            GenericArgument::Lifetime(f.fold_lifetime(_binding_0))
-        }
-        GenericArgument::Type(_binding_0) => GenericArgument::Type(f.fold_type(_binding_0)),
-        GenericArgument::Binding(_binding_0) => {
-            GenericArgument::Binding(f.fold_binding(_binding_0))
-        }
-        GenericArgument::Constraint(_binding_0) => {
-            GenericArgument::Constraint(f.fold_constraint(_binding_0))
-        }
-        GenericArgument::Const(_binding_0) => GenericArgument::Const(f.fold_expr(_binding_0)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_generic_method_argument<F>(
-    f: &mut F,
-    node: GenericMethodArgument,
-) -> GenericMethodArgument
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        GenericMethodArgument::Type(_binding_0) => {
-            GenericMethodArgument::Type(f.fold_type(_binding_0))
-        }
-        GenericMethodArgument::Const(_binding_0) => {
-            GenericMethodArgument::Const(f.fold_expr(_binding_0))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_generic_param<F>(f: &mut F, node: GenericParam) -> GenericParam
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        GenericParam::Type(_binding_0) => GenericParam::Type(f.fold_type_param(_binding_0)),
-        GenericParam::Lifetime(_binding_0) => {
-            GenericParam::Lifetime(f.fold_lifetime_def(_binding_0))
-        }
-        GenericParam::Const(_binding_0) => GenericParam::Const(f.fold_const_param(_binding_0)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_generics<F>(f: &mut F, node: Generics) -> Generics
-where
-    F: Fold + ?Sized,
-{
-    Generics {
-        lt_token: (node.lt_token).map(|it| Token ! [<](tokens_helper(f, &it.spans))),
-        params: FoldHelper::lift(node.params, |it| f.fold_generic_param(it)),
-        gt_token: (node.gt_token).map(|it| Token ! [>](tokens_helper(f, &it.spans))),
-        where_clause: (node.where_clause).map(|it| f.fold_where_clause(it)),
-    }
-}
-pub fn fold_ident<F>(f: &mut F, node: Ident) -> Ident
-where
-    F: Fold + ?Sized,
-{
-    let mut node = node;
-    let span = f.fold_span(node.span());
-    node.set_span(span);
-    node
-}
-#[cfg(feature = "full")]
-pub fn fold_impl_item<F>(f: &mut F, node: ImplItem) -> ImplItem
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        ImplItem::Const(_binding_0) => ImplItem::Const(f.fold_impl_item_const(_binding_0)),
-        ImplItem::Method(_binding_0) => ImplItem::Method(f.fold_impl_item_method(_binding_0)),
-        ImplItem::Type(_binding_0) => ImplItem::Type(f.fold_impl_item_type(_binding_0)),
-        ImplItem::Macro(_binding_0) => ImplItem::Macro(f.fold_impl_item_macro(_binding_0)),
-        ImplItem::Verbatim(_binding_0) => ImplItem::Verbatim(_binding_0),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_impl_item_const<F>(f: &mut F, node: ImplItemConst) -> ImplItemConst
-where
-    F: Fold + ?Sized,
-{
-    ImplItemConst {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
-        const_token: Token![const](tokens_helper(f, &node.const_token.span)),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: f.fold_type(node.ty),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        expr: f.fold_expr(node.expr),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_impl_item_macro<F>(f: &mut F, node: ImplItemMacro) -> ImplItemMacro
-where
-    F: Fold + ?Sized,
-{
-    ImplItemMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        mac: f.fold_macro(node.mac),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_impl_item_method<F>(f: &mut F, node: ImplItemMethod) -> ImplItemMethod
-where
-    F: Fold + ?Sized,
-{
-    ImplItemMethod {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
-        sig: f.fold_signature(node.sig),
-        block: f.fold_block(node.block),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_impl_item_type<F>(f: &mut F, node: ImplItemType) -> ImplItemType
-where
-    F: Fold + ?Sized,
-{
-    ImplItemType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
-        type_token: Token![type](tokens_helper(f, &node.type_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        ty: f.fold_type(node.ty),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_index<F>(f: &mut F, node: Index) -> Index
-where
-    F: Fold + ?Sized,
-{
-    Index {
-        index: node.index,
-        span: f.fold_span(node.span),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item<F>(f: &mut F, node: Item) -> Item
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Item::Const(_binding_0) => Item::Const(f.fold_item_const(_binding_0)),
-        Item::Enum(_binding_0) => Item::Enum(f.fold_item_enum(_binding_0)),
-        Item::ExternCrate(_binding_0) => Item::ExternCrate(f.fold_item_extern_crate(_binding_0)),
-        Item::Fn(_binding_0) => Item::Fn(f.fold_item_fn(_binding_0)),
-        Item::ForeignMod(_binding_0) => Item::ForeignMod(f.fold_item_foreign_mod(_binding_0)),
-        Item::Impl(_binding_0) => Item::Impl(f.fold_item_impl(_binding_0)),
-        Item::Macro(_binding_0) => Item::Macro(f.fold_item_macro(_binding_0)),
-        Item::Macro2(_binding_0) => Item::Macro2(f.fold_item_macro2(_binding_0)),
-        Item::Mod(_binding_0) => Item::Mod(f.fold_item_mod(_binding_0)),
-        Item::Static(_binding_0) => Item::Static(f.fold_item_static(_binding_0)),
-        Item::Struct(_binding_0) => Item::Struct(f.fold_item_struct(_binding_0)),
-        Item::Trait(_binding_0) => Item::Trait(f.fold_item_trait(_binding_0)),
-        Item::TraitAlias(_binding_0) => Item::TraitAlias(f.fold_item_trait_alias(_binding_0)),
-        Item::Type(_binding_0) => Item::Type(f.fold_item_type(_binding_0)),
-        Item::Union(_binding_0) => Item::Union(f.fold_item_union(_binding_0)),
-        Item::Use(_binding_0) => Item::Use(f.fold_item_use(_binding_0)),
-        Item::Verbatim(_binding_0) => Item::Verbatim(_binding_0),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_const<F>(f: &mut F, node: ItemConst) -> ItemConst
-where
-    F: Fold + ?Sized,
-{
-    ItemConst {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        const_token: Token![const](tokens_helper(f, &node.const_token.span)),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_enum<F>(f: &mut F, node: ItemEnum) -> ItemEnum
-where
-    F: Fold + ?Sized,
-{
-    ItemEnum {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        enum_token: Token![enum](tokens_helper(f, &node.enum_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        variants: FoldHelper::lift(node.variants, |it| f.fold_variant(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_extern_crate<F>(f: &mut F, node: ItemExternCrate) -> ItemExternCrate
-where
-    F: Fold + ?Sized,
-{
-    ItemExternCrate {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        extern_token: Token![extern](tokens_helper(f, &node.extern_token.span)),
-        crate_token: Token![crate](tokens_helper(f, &node.crate_token.span)),
-        ident: f.fold_ident(node.ident),
-        rename: (node.rename).map(|it| {
-            (
-                Token![as](tokens_helper(f, &(it).0.span)),
-                f.fold_ident((it).1),
-            )
-        }),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_fn<F>(f: &mut F, node: ItemFn) -> ItemFn
-where
-    F: Fold + ?Sized,
-{
-    ItemFn {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        sig: f.fold_signature(node.sig),
-        block: Box::new(f.fold_block(*node.block)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_foreign_mod<F>(f: &mut F, node: ItemForeignMod) -> ItemForeignMod
-where
-    F: Fold + ?Sized,
-{
-    ItemForeignMod {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        abi: f.fold_abi(node.abi),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        items: FoldHelper::lift(node.items, |it| f.fold_foreign_item(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_impl<F>(f: &mut F, node: ItemImpl) -> ItemImpl
-where
-    F: Fold + ?Sized,
-{
-    ItemImpl {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
-        unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
-        impl_token: Token![impl](tokens_helper(f, &node.impl_token.span)),
-        generics: f.fold_generics(node.generics),
-        trait_: (node.trait_).map(|it| {
-            (
-                ((it).0).map(|it| Token![!](tokens_helper(f, &it.spans))),
-                f.fold_path((it).1),
-                Token![for](tokens_helper(f, &(it).2.span)),
-            )
-        }),
-        self_ty: Box::new(f.fold_type(*node.self_ty)),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        items: FoldHelper::lift(node.items, |it| f.fold_impl_item(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_macro<F>(f: &mut F, node: ItemMacro) -> ItemMacro
-where
-    F: Fold + ?Sized,
-{
-    ItemMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        ident: (node.ident).map(|it| f.fold_ident(it)),
-        mac: f.fold_macro(node.mac),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_macro2<F>(f: &mut F, node: ItemMacro2) -> ItemMacro2
-where
-    F: Fold + ?Sized,
-{
-    ItemMacro2 {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        macro_token: Token![macro](tokens_helper(f, &node.macro_token.span)),
-        ident: f.fold_ident(node.ident),
-        rules: node.rules,
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_mod<F>(f: &mut F, node: ItemMod) -> ItemMod
-where
-    F: Fold + ?Sized,
-{
-    ItemMod {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        mod_token: Token![mod](tokens_helper(f, &node.mod_token.span)),
-        ident: f.fold_ident(node.ident),
-        content: (node.content).map(|it| {
-            (
-                Brace(tokens_helper(f, &(it).0.span)),
-                FoldHelper::lift((it).1, |it| f.fold_item(it)),
-            )
-        }),
-        semi: (node.semi).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_static<F>(f: &mut F, node: ItemStatic) -> ItemStatic
-where
-    F: Fold + ?Sized,
-{
-    ItemStatic {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        static_token: Token![static](tokens_helper(f, &node.static_token.span)),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_struct<F>(f: &mut F, node: ItemStruct) -> ItemStruct
-where
-    F: Fold + ?Sized,
-{
-    ItemStruct {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        struct_token: Token![struct](tokens_helper(f, &node.struct_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        fields: f.fold_fields(node.fields),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_trait<F>(f: &mut F, node: ItemTrait) -> ItemTrait
-where
-    F: Fold + ?Sized,
-{
-    ItemTrait {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
-        auto_token: (node.auto_token).map(|it| Token![auto](tokens_helper(f, &it.span))),
-        trait_token: Token![trait](tokens_helper(f, &node.trait_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        supertraits: FoldHelper::lift(node.supertraits, |it| f.fold_type_param_bound(it)),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        items: FoldHelper::lift(node.items, |it| f.fold_trait_item(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_trait_alias<F>(f: &mut F, node: ItemTraitAlias) -> ItemTraitAlias
-where
-    F: Fold + ?Sized,
-{
-    ItemTraitAlias {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        trait_token: Token![trait](tokens_helper(f, &node.trait_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_type<F>(f: &mut F, node: ItemType) -> ItemType
-where
-    F: Fold + ?Sized,
-{
-    ItemType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        type_token: Token![type](tokens_helper(f, &node.type_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_union<F>(f: &mut F, node: ItemUnion) -> ItemUnion
-where
-    F: Fold + ?Sized,
-{
-    ItemUnion {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        union_token: Token![union](tokens_helper(f, &node.union_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        fields: f.fold_fields_named(node.fields),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_item_use<F>(f: &mut F, node: ItemUse) -> ItemUse
-where
-    F: Fold + ?Sized,
-{
-    ItemUse {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        vis: f.fold_visibility(node.vis),
-        use_token: Token![use](tokens_helper(f, &node.use_token.span)),
-        leading_colon: (node.leading_colon).map(|it| Token ! [::](tokens_helper(f, &it.spans))),
-        tree: f.fold_use_tree(node.tree),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_label<F>(f: &mut F, node: Label) -> Label
-where
-    F: Fold + ?Sized,
-{
-    Label {
-        name: f.fold_lifetime(node.name),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-    }
-}
-pub fn fold_lifetime<F>(f: &mut F, node: Lifetime) -> Lifetime
-where
-    F: Fold + ?Sized,
-{
-    Lifetime {
-        apostrophe: f.fold_span(node.apostrophe),
-        ident: f.fold_ident(node.ident),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_lifetime_def<F>(f: &mut F, node: LifetimeDef) -> LifetimeDef
-where
-    F: Fold + ?Sized,
-{
-    LifetimeDef {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        lifetime: f.fold_lifetime(node.lifetime),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_lifetime(it)),
-    }
-}
-pub fn fold_lit<F>(f: &mut F, node: Lit) -> Lit
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Lit::Str(_binding_0) => Lit::Str(f.fold_lit_str(_binding_0)),
-        Lit::ByteStr(_binding_0) => Lit::ByteStr(f.fold_lit_byte_str(_binding_0)),
-        Lit::Byte(_binding_0) => Lit::Byte(f.fold_lit_byte(_binding_0)),
-        Lit::Char(_binding_0) => Lit::Char(f.fold_lit_char(_binding_0)),
-        Lit::Int(_binding_0) => Lit::Int(f.fold_lit_int(_binding_0)),
-        Lit::Float(_binding_0) => Lit::Float(f.fold_lit_float(_binding_0)),
-        Lit::Bool(_binding_0) => Lit::Bool(f.fold_lit_bool(_binding_0)),
-        Lit::Verbatim(_binding_0) => Lit::Verbatim(_binding_0),
-    }
-}
-pub fn fold_lit_bool<F>(f: &mut F, node: LitBool) -> LitBool
-where
-    F: Fold + ?Sized,
-{
-    LitBool {
-        value: node.value,
-        span: f.fold_span(node.span),
-    }
-}
-pub fn fold_lit_byte<F>(f: &mut F, node: LitByte) -> LitByte
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-pub fn fold_lit_byte_str<F>(f: &mut F, node: LitByteStr) -> LitByteStr
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-pub fn fold_lit_char<F>(f: &mut F, node: LitChar) -> LitChar
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-pub fn fold_lit_float<F>(f: &mut F, node: LitFloat) -> LitFloat
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-pub fn fold_lit_int<F>(f: &mut F, node: LitInt) -> LitInt
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-pub fn fold_lit_str<F>(f: &mut F, node: LitStr) -> LitStr
-where
-    F: Fold + ?Sized,
-{
-    let span = f.fold_span(node.span());
-    let mut node = node;
-    node.set_span(span);
-    node
-}
-#[cfg(feature = "full")]
-pub fn fold_local<F>(f: &mut F, node: Local) -> Local
-where
-    F: Fold + ?Sized,
-{
-    Local {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        let_token: Token![let](tokens_helper(f, &node.let_token.span)),
-        pat: f.fold_pat(node.pat),
-        init: (node.init).map(|it| {
-            (
-                Token ! [=](tokens_helper(f, &(it).0.spans)),
-                Box::new(f.fold_expr(*(it).1)),
-            )
-        }),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_macro<F>(f: &mut F, node: Macro) -> Macro
-where
-    F: Fold + ?Sized,
-{
-    Macro {
-        path: f.fold_path(node.path),
-        bang_token: Token![!](tokens_helper(f, &node.bang_token.spans)),
-        delimiter: f.fold_macro_delimiter(node.delimiter),
-        tokens: node.tokens,
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_macro_delimiter<F>(f: &mut F, node: MacroDelimiter) -> MacroDelimiter
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        MacroDelimiter::Paren(_binding_0) => {
-            MacroDelimiter::Paren(Paren(tokens_helper(f, &_binding_0.span)))
-        }
-        MacroDelimiter::Brace(_binding_0) => {
-            MacroDelimiter::Brace(Brace(tokens_helper(f, &_binding_0.span)))
-        }
-        MacroDelimiter::Bracket(_binding_0) => {
-            MacroDelimiter::Bracket(Bracket(tokens_helper(f, &_binding_0.span)))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_member<F>(f: &mut F, node: Member) -> Member
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Member::Named(_binding_0) => Member::Named(f.fold_ident(_binding_0)),
-        Member::Unnamed(_binding_0) => Member::Unnamed(f.fold_index(_binding_0)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_meta<F>(f: &mut F, node: Meta) -> Meta
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Meta::Path(_binding_0) => Meta::Path(f.fold_path(_binding_0)),
-        Meta::List(_binding_0) => Meta::List(f.fold_meta_list(_binding_0)),
-        Meta::NameValue(_binding_0) => Meta::NameValue(f.fold_meta_name_value(_binding_0)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_meta_list<F>(f: &mut F, node: MetaList) -> MetaList
-where
-    F: Fold + ?Sized,
-{
-    MetaList {
-        path: f.fold_path(node.path),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        nested: FoldHelper::lift(node.nested, |it| f.fold_nested_meta(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_meta_name_value<F>(f: &mut F, node: MetaNameValue) -> MetaNameValue
-where
-    F: Fold + ?Sized,
-{
-    MetaNameValue {
-        path: f.fold_path(node.path),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        lit: f.fold_lit(node.lit),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_method_turbofish<F>(f: &mut F, node: MethodTurbofish) -> MethodTurbofish
-where
-    F: Fold + ?Sized,
-{
-    MethodTurbofish {
-        colon2_token: Token ! [::](tokens_helper(f, &node.colon2_token.spans)),
-        lt_token: Token ! [<](tokens_helper(f, &node.lt_token.spans)),
-        args: FoldHelper::lift(node.args, |it| f.fold_generic_method_argument(it)),
-        gt_token: Token ! [>](tokens_helper(f, &node.gt_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_nested_meta<F>(f: &mut F, node: NestedMeta) -> NestedMeta
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        NestedMeta::Meta(_binding_0) => NestedMeta::Meta(f.fold_meta(_binding_0)),
-        NestedMeta::Lit(_binding_0) => NestedMeta::Lit(f.fold_lit(_binding_0)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_parenthesized_generic_arguments<F>(
-    f: &mut F,
-    node: ParenthesizedGenericArguments,
-) -> ParenthesizedGenericArguments
-where
-    F: Fold + ?Sized,
-{
-    ParenthesizedGenericArguments {
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        inputs: FoldHelper::lift(node.inputs, |it| f.fold_type(it)),
-        output: f.fold_return_type(node.output),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat<F>(f: &mut F, node: Pat) -> Pat
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Pat::Box(_binding_0) => Pat::Box(f.fold_pat_box(_binding_0)),
-        Pat::Ident(_binding_0) => Pat::Ident(f.fold_pat_ident(_binding_0)),
-        Pat::Lit(_binding_0) => Pat::Lit(f.fold_pat_lit(_binding_0)),
-        Pat::Macro(_binding_0) => Pat::Macro(f.fold_pat_macro(_binding_0)),
-        Pat::Or(_binding_0) => Pat::Or(f.fold_pat_or(_binding_0)),
-        Pat::Path(_binding_0) => Pat::Path(f.fold_pat_path(_binding_0)),
-        Pat::Range(_binding_0) => Pat::Range(f.fold_pat_range(_binding_0)),
-        Pat::Reference(_binding_0) => Pat::Reference(f.fold_pat_reference(_binding_0)),
-        Pat::Rest(_binding_0) => Pat::Rest(f.fold_pat_rest(_binding_0)),
-        Pat::Slice(_binding_0) => Pat::Slice(f.fold_pat_slice(_binding_0)),
-        Pat::Struct(_binding_0) => Pat::Struct(f.fold_pat_struct(_binding_0)),
-        Pat::Tuple(_binding_0) => Pat::Tuple(f.fold_pat_tuple(_binding_0)),
-        Pat::TupleStruct(_binding_0) => Pat::TupleStruct(f.fold_pat_tuple_struct(_binding_0)),
-        Pat::Type(_binding_0) => Pat::Type(f.fold_pat_type(_binding_0)),
-        Pat::Verbatim(_binding_0) => Pat::Verbatim(_binding_0),
-        Pat::Wild(_binding_0) => Pat::Wild(f.fold_pat_wild(_binding_0)),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_box<F>(f: &mut F, node: PatBox) -> PatBox
-where
-    F: Fold + ?Sized,
-{
-    PatBox {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        box_token: Token![box](tokens_helper(f, &node.box_token.span)),
-        pat: Box::new(f.fold_pat(*node.pat)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_ident<F>(f: &mut F, node: PatIdent) -> PatIdent
-where
-    F: Fold + ?Sized,
-{
-    PatIdent {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        by_ref: (node.by_ref).map(|it| Token![ref](tokens_helper(f, &it.span))),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        ident: f.fold_ident(node.ident),
-        subpat: (node.subpat).map(|it| {
-            (
-                Token ! [@](tokens_helper(f, &(it).0.spans)),
-                Box::new(f.fold_pat(*(it).1)),
-            )
-        }),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_lit<F>(f: &mut F, node: PatLit) -> PatLit
-where
-    F: Fold + ?Sized,
-{
-    PatLit {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        expr: Box::new(f.fold_expr(*node.expr)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_macro<F>(f: &mut F, node: PatMacro) -> PatMacro
-where
-    F: Fold + ?Sized,
-{
-    PatMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        mac: f.fold_macro(node.mac),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_or<F>(f: &mut F, node: PatOr) -> PatOr
-where
-    F: Fold + ?Sized,
-{
-    PatOr {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        leading_vert: (node.leading_vert).map(|it| Token ! [|](tokens_helper(f, &it.spans))),
-        cases: FoldHelper::lift(node.cases, |it| f.fold_pat(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_path<F>(f: &mut F, node: PatPath) -> PatPath
-where
-    F: Fold + ?Sized,
-{
-    PatPath {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        qself: (node.qself).map(|it| f.fold_qself(it)),
-        path: f.fold_path(node.path),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_range<F>(f: &mut F, node: PatRange) -> PatRange
-where
-    F: Fold + ?Sized,
-{
-    PatRange {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        lo: Box::new(f.fold_expr(*node.lo)),
-        limits: f.fold_range_limits(node.limits),
-        hi: Box::new(f.fold_expr(*node.hi)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_reference<F>(f: &mut F, node: PatReference) -> PatReference
-where
-    F: Fold + ?Sized,
-{
-    PatReference {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        and_token: Token ! [&](tokens_helper(f, &node.and_token.spans)),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        pat: Box::new(f.fold_pat(*node.pat)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_rest<F>(f: &mut F, node: PatRest) -> PatRest
-where
-    F: Fold + ?Sized,
-{
-    PatRest {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        dot2_token: Token![..](tokens_helper(f, &node.dot2_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_slice<F>(f: &mut F, node: PatSlice) -> PatSlice
-where
-    F: Fold + ?Sized,
-{
-    PatSlice {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        elems: FoldHelper::lift(node.elems, |it| f.fold_pat(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_struct<F>(f: &mut F, node: PatStruct) -> PatStruct
-where
-    F: Fold + ?Sized,
-{
-    PatStruct {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        path: f.fold_path(node.path),
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        fields: FoldHelper::lift(node.fields, |it| f.fold_field_pat(it)),
-        dot2_token: (node.dot2_token).map(|it| Token![..](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_tuple<F>(f: &mut F, node: PatTuple) -> PatTuple
-where
-    F: Fold + ?Sized,
-{
-    PatTuple {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        elems: FoldHelper::lift(node.elems, |it| f.fold_pat(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_tuple_struct<F>(f: &mut F, node: PatTupleStruct) -> PatTupleStruct
-where
-    F: Fold + ?Sized,
-{
-    PatTupleStruct {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        path: f.fold_path(node.path),
-        pat: f.fold_pat_tuple(node.pat),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_type<F>(f: &mut F, node: PatType) -> PatType
-where
-    F: Fold + ?Sized,
-{
-    PatType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        pat: Box::new(f.fold_pat(*node.pat)),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_pat_wild<F>(f: &mut F, node: PatWild) -> PatWild
-where
-    F: Fold + ?Sized,
-{
-    PatWild {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        underscore_token: Token![_](tokens_helper(f, &node.underscore_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_path<F>(f: &mut F, node: Path) -> Path
-where
-    F: Fold + ?Sized,
-{
-    Path {
-        leading_colon: (node.leading_colon).map(|it| Token ! [::](tokens_helper(f, &it.spans))),
-        segments: FoldHelper::lift(node.segments, |it| f.fold_path_segment(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_path_arguments<F>(f: &mut F, node: PathArguments) -> PathArguments
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        PathArguments::None => PathArguments::None,
-        PathArguments::AngleBracketed(_binding_0) => {
-            PathArguments::AngleBracketed(f.fold_angle_bracketed_generic_arguments(_binding_0))
-        }
-        PathArguments::Parenthesized(_binding_0) => {
-            PathArguments::Parenthesized(f.fold_parenthesized_generic_arguments(_binding_0))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_path_segment<F>(f: &mut F, node: PathSegment) -> PathSegment
-where
-    F: Fold + ?Sized,
-{
-    PathSegment {
-        ident: f.fold_ident(node.ident),
-        arguments: f.fold_path_arguments(node.arguments),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_predicate_eq<F>(f: &mut F, node: PredicateEq) -> PredicateEq
-where
-    F: Fold + ?Sized,
-{
-    PredicateEq {
-        lhs_ty: f.fold_type(node.lhs_ty),
-        eq_token: Token ! [=](tokens_helper(f, &node.eq_token.spans)),
-        rhs_ty: f.fold_type(node.rhs_ty),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_predicate_lifetime<F>(f: &mut F, node: PredicateLifetime) -> PredicateLifetime
-where
-    F: Fold + ?Sized,
-{
-    PredicateLifetime {
-        lifetime: f.fold_lifetime(node.lifetime),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_lifetime(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_predicate_type<F>(f: &mut F, node: PredicateType) -> PredicateType
-where
-    F: Fold + ?Sized,
-{
-    PredicateType {
-        lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
-        bounded_ty: f.fold_type(node.bounded_ty),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_qself<F>(f: &mut F, node: QSelf) -> QSelf
-where
-    F: Fold + ?Sized,
-{
-    QSelf {
-        lt_token: Token ! [<](tokens_helper(f, &node.lt_token.spans)),
-        ty: Box::new(f.fold_type(*node.ty)),
-        position: node.position,
-        as_token: (node.as_token).map(|it| Token![as](tokens_helper(f, &it.span))),
-        gt_token: Token ! [>](tokens_helper(f, &node.gt_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_range_limits<F>(f: &mut F, node: RangeLimits) -> RangeLimits
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        RangeLimits::HalfOpen(_binding_0) => {
-            RangeLimits::HalfOpen(Token![..](tokens_helper(f, &_binding_0.spans)))
-        }
-        RangeLimits::Closed(_binding_0) => {
-            RangeLimits::Closed(Token ! [..=](tokens_helper(f, &_binding_0.spans)))
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_receiver<F>(f: &mut F, node: Receiver) -> Receiver
-where
-    F: Fold + ?Sized,
-{
-    Receiver {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        reference: (node.reference).map(|it| {
-            (
-                Token ! [&](tokens_helper(f, &(it).0.spans)),
-                ((it).1).map(|it| f.fold_lifetime(it)),
-            )
-        }),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        self_token: Token![self](tokens_helper(f, &node.self_token.span)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_return_type<F>(f: &mut F, node: ReturnType) -> ReturnType
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        ReturnType::Default => ReturnType::Default,
-        ReturnType::Type(_binding_0, _binding_1) => ReturnType::Type(
-            Token ! [->](tokens_helper(f, &_binding_0.spans)),
-            Box::new(f.fold_type(*_binding_1)),
-        ),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_signature<F>(f: &mut F, node: Signature) -> Signature
-where
-    F: Fold + ?Sized,
-{
-    Signature {
-        constness: (node.constness).map(|it| Token![const](tokens_helper(f, &it.span))),
-        asyncness: (node.asyncness).map(|it| Token![async](tokens_helper(f, &it.span))),
-        unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
-        abi: (node.abi).map(|it| f.fold_abi(it)),
-        fn_token: Token![fn](tokens_helper(f, &node.fn_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        inputs: FoldHelper::lift(node.inputs, |it| f.fold_fn_arg(it)),
-        variadic: (node.variadic).map(|it| f.fold_variadic(it)),
-        output: f.fold_return_type(node.output),
-    }
-}
-pub fn fold_span<F>(f: &mut F, node: Span) -> Span
-where
-    F: Fold + ?Sized,
-{
-    node
-}
-#[cfg(feature = "full")]
-pub fn fold_stmt<F>(f: &mut F, node: Stmt) -> Stmt
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Stmt::Local(_binding_0) => Stmt::Local(f.fold_local(_binding_0)),
-        Stmt::Item(_binding_0) => Stmt::Item(f.fold_item(_binding_0)),
-        Stmt::Expr(_binding_0) => Stmt::Expr(f.fold_expr(_binding_0)),
-        Stmt::Semi(_binding_0, _binding_1) => Stmt::Semi(
-            f.fold_expr(_binding_0),
-            Token ! [;](tokens_helper(f, &_binding_1.spans)),
-        ),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_trait_bound<F>(f: &mut F, node: TraitBound) -> TraitBound
-where
-    F: Fold + ?Sized,
-{
-    TraitBound {
-        paren_token: (node.paren_token).map(|it| Paren(tokens_helper(f, &it.span))),
-        modifier: f.fold_trait_bound_modifier(node.modifier),
-        lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
-        path: f.fold_path(node.path),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_trait_bound_modifier<F>(f: &mut F, node: TraitBoundModifier) -> TraitBoundModifier
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        TraitBoundModifier::None => TraitBoundModifier::None,
-        TraitBoundModifier::Maybe(_binding_0) => {
-            TraitBoundModifier::Maybe(Token ! [?](tokens_helper(f, &_binding_0.spans)))
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_trait_item<F>(f: &mut F, node: TraitItem) -> TraitItem
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        TraitItem::Const(_binding_0) => TraitItem::Const(f.fold_trait_item_const(_binding_0)),
-        TraitItem::Method(_binding_0) => TraitItem::Method(f.fold_trait_item_method(_binding_0)),
-        TraitItem::Type(_binding_0) => TraitItem::Type(f.fold_trait_item_type(_binding_0)),
-        TraitItem::Macro(_binding_0) => TraitItem::Macro(f.fold_trait_item_macro(_binding_0)),
-        TraitItem::Verbatim(_binding_0) => TraitItem::Verbatim(_binding_0),
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_trait_item_const<F>(f: &mut F, node: TraitItemConst) -> TraitItemConst
-where
-    F: Fold + ?Sized,
-{
-    TraitItemConst {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        const_token: Token![const](tokens_helper(f, &node.const_token.span)),
-        ident: f.fold_ident(node.ident),
-        colon_token: Token ! [:](tokens_helper(f, &node.colon_token.spans)),
-        ty: f.fold_type(node.ty),
-        default: (node.default).map(|it| {
-            (
-                Token ! [=](tokens_helper(f, &(it).0.spans)),
-                f.fold_expr((it).1),
-            )
-        }),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_trait_item_macro<F>(f: &mut F, node: TraitItemMacro) -> TraitItemMacro
-where
-    F: Fold + ?Sized,
-{
-    TraitItemMacro {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        mac: f.fold_macro(node.mac),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_trait_item_method<F>(f: &mut F, node: TraitItemMethod) -> TraitItemMethod
-where
-    F: Fold + ?Sized,
-{
-    TraitItemMethod {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        sig: f.fold_signature(node.sig),
-        default: (node.default).map(|it| f.fold_block(it)),
-        semi_token: (node.semi_token).map(|it| Token ! [;](tokens_helper(f, &it.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_trait_item_type<F>(f: &mut F, node: TraitItemType) -> TraitItemType
-where
-    F: Fold + ?Sized,
-{
-    TraitItemType {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        type_token: Token![type](tokens_helper(f, &node.type_token.span)),
-        ident: f.fold_ident(node.ident),
-        generics: f.fold_generics(node.generics),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-        default: (node.default).map(|it| {
-            (
-                Token ! [=](tokens_helper(f, &(it).0.spans)),
-                f.fold_type((it).1),
-            )
-        }),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type<F>(f: &mut F, node: Type) -> Type
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Type::Array(_binding_0) => Type::Array(f.fold_type_array(_binding_0)),
-        Type::BareFn(_binding_0) => Type::BareFn(f.fold_type_bare_fn(_binding_0)),
-        Type::Group(_binding_0) => Type::Group(f.fold_type_group(_binding_0)),
-        Type::ImplTrait(_binding_0) => Type::ImplTrait(f.fold_type_impl_trait(_binding_0)),
-        Type::Infer(_binding_0) => Type::Infer(f.fold_type_infer(_binding_0)),
-        Type::Macro(_binding_0) => Type::Macro(f.fold_type_macro(_binding_0)),
-        Type::Never(_binding_0) => Type::Never(f.fold_type_never(_binding_0)),
-        Type::Paren(_binding_0) => Type::Paren(f.fold_type_paren(_binding_0)),
-        Type::Path(_binding_0) => Type::Path(f.fold_type_path(_binding_0)),
-        Type::Ptr(_binding_0) => Type::Ptr(f.fold_type_ptr(_binding_0)),
-        Type::Reference(_binding_0) => Type::Reference(f.fold_type_reference(_binding_0)),
-        Type::Slice(_binding_0) => Type::Slice(f.fold_type_slice(_binding_0)),
-        Type::TraitObject(_binding_0) => Type::TraitObject(f.fold_type_trait_object(_binding_0)),
-        Type::Tuple(_binding_0) => Type::Tuple(f.fold_type_tuple(_binding_0)),
-        Type::Verbatim(_binding_0) => Type::Verbatim(_binding_0),
-        _ => unreachable!(),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_array<F>(f: &mut F, node: TypeArray) -> TypeArray
-where
-    F: Fold + ?Sized,
-{
-    TypeArray {
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        elem: Box::new(f.fold_type(*node.elem)),
-        semi_token: Token ! [;](tokens_helper(f, &node.semi_token.spans)),
-        len: f.fold_expr(node.len),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_bare_fn<F>(f: &mut F, node: TypeBareFn) -> TypeBareFn
-where
-    F: Fold + ?Sized,
-{
-    TypeBareFn {
-        lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
-        unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
-        abi: (node.abi).map(|it| f.fold_abi(it)),
-        fn_token: Token![fn](tokens_helper(f, &node.fn_token.span)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        inputs: FoldHelper::lift(node.inputs, |it| f.fold_bare_fn_arg(it)),
-        variadic: (node.variadic).map(|it| f.fold_variadic(it)),
-        output: f.fold_return_type(node.output),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_group<F>(f: &mut F, node: TypeGroup) -> TypeGroup
-where
-    F: Fold + ?Sized,
-{
-    TypeGroup {
-        group_token: Group(tokens_helper(f, &node.group_token.span)),
-        elem: Box::new(f.fold_type(*node.elem)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_impl_trait<F>(f: &mut F, node: TypeImplTrait) -> TypeImplTrait
-where
-    F: Fold + ?Sized,
-{
-    TypeImplTrait {
-        impl_token: Token![impl](tokens_helper(f, &node.impl_token.span)),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_infer<F>(f: &mut F, node: TypeInfer) -> TypeInfer
-where
-    F: Fold + ?Sized,
-{
-    TypeInfer {
-        underscore_token: Token![_](tokens_helper(f, &node.underscore_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_macro<F>(f: &mut F, node: TypeMacro) -> TypeMacro
-where
-    F: Fold + ?Sized,
-{
-    TypeMacro {
-        mac: f.fold_macro(node.mac),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_never<F>(f: &mut F, node: TypeNever) -> TypeNever
-where
-    F: Fold + ?Sized,
-{
-    TypeNever {
-        bang_token: Token![!](tokens_helper(f, &node.bang_token.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_param<F>(f: &mut F, node: TypeParam) -> TypeParam
-where
-    F: Fold + ?Sized,
-{
-    TypeParam {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        ident: f.fold_ident(node.ident),
-        colon_token: (node.colon_token).map(|it| Token ! [:](tokens_helper(f, &it.spans))),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-        eq_token: (node.eq_token).map(|it| Token ! [=](tokens_helper(f, &it.spans))),
-        default: (node.default).map(|it| f.fold_type(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_param_bound<F>(f: &mut F, node: TypeParamBound) -> TypeParamBound
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        TypeParamBound::Trait(_binding_0) => TypeParamBound::Trait(f.fold_trait_bound(_binding_0)),
-        TypeParamBound::Lifetime(_binding_0) => {
-            TypeParamBound::Lifetime(f.fold_lifetime(_binding_0))
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_paren<F>(f: &mut F, node: TypeParen) -> TypeParen
-where
-    F: Fold + ?Sized,
-{
-    TypeParen {
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        elem: Box::new(f.fold_type(*node.elem)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_path<F>(f: &mut F, node: TypePath) -> TypePath
-where
-    F: Fold + ?Sized,
-{
-    TypePath {
-        qself: (node.qself).map(|it| f.fold_qself(it)),
-        path: f.fold_path(node.path),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_ptr<F>(f: &mut F, node: TypePtr) -> TypePtr
-where
-    F: Fold + ?Sized,
-{
-    TypePtr {
-        star_token: Token ! [*](tokens_helper(f, &node.star_token.spans)),
-        const_token: (node.const_token).map(|it| Token![const](tokens_helper(f, &it.span))),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        elem: Box::new(f.fold_type(*node.elem)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_reference<F>(f: &mut F, node: TypeReference) -> TypeReference
-where
-    F: Fold + ?Sized,
-{
-    TypeReference {
-        and_token: Token ! [&](tokens_helper(f, &node.and_token.spans)),
-        lifetime: (node.lifetime).map(|it| f.fold_lifetime(it)),
-        mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
-        elem: Box::new(f.fold_type(*node.elem)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_slice<F>(f: &mut F, node: TypeSlice) -> TypeSlice
-where
-    F: Fold + ?Sized,
-{
-    TypeSlice {
-        bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
-        elem: Box::new(f.fold_type(*node.elem)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_trait_object<F>(f: &mut F, node: TypeTraitObject) -> TypeTraitObject
-where
-    F: Fold + ?Sized,
-{
-    TypeTraitObject {
-        dyn_token: (node.dyn_token).map(|it| Token![dyn](tokens_helper(f, &it.span))),
-        bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_type_tuple<F>(f: &mut F, node: TypeTuple) -> TypeTuple
-where
-    F: Fold + ?Sized,
-{
-    TypeTuple {
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        elems: FoldHelper::lift(node.elems, |it| f.fold_type(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_un_op<F>(f: &mut F, node: UnOp) -> UnOp
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        UnOp::Deref(_binding_0) => UnOp::Deref(Token ! [*](tokens_helper(f, &_binding_0.spans))),
-        UnOp::Not(_binding_0) => UnOp::Not(Token![!](tokens_helper(f, &_binding_0.spans))),
-        UnOp::Neg(_binding_0) => UnOp::Neg(Token ! [-](tokens_helper(f, &_binding_0.spans))),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_glob<F>(f: &mut F, node: UseGlob) -> UseGlob
-where
-    F: Fold + ?Sized,
-{
-    UseGlob {
-        star_token: Token ! [*](tokens_helper(f, &node.star_token.spans)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_group<F>(f: &mut F, node: UseGroup) -> UseGroup
-where
-    F: Fold + ?Sized,
-{
-    UseGroup {
-        brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
-        items: FoldHelper::lift(node.items, |it| f.fold_use_tree(it)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_name<F>(f: &mut F, node: UseName) -> UseName
-where
-    F: Fold + ?Sized,
-{
-    UseName {
-        ident: f.fold_ident(node.ident),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_path<F>(f: &mut F, node: UsePath) -> UsePath
-where
-    F: Fold + ?Sized,
-{
-    UsePath {
-        ident: f.fold_ident(node.ident),
-        colon2_token: Token ! [::](tokens_helper(f, &node.colon2_token.spans)),
-        tree: Box::new(f.fold_use_tree(*node.tree)),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_rename<F>(f: &mut F, node: UseRename) -> UseRename
-where
-    F: Fold + ?Sized,
-{
-    UseRename {
-        ident: f.fold_ident(node.ident),
-        as_token: Token![as](tokens_helper(f, &node.as_token.span)),
-        rename: f.fold_ident(node.rename),
-    }
-}
-#[cfg(feature = "full")]
-pub fn fold_use_tree<F>(f: &mut F, node: UseTree) -> UseTree
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        UseTree::Path(_binding_0) => UseTree::Path(f.fold_use_path(_binding_0)),
-        UseTree::Name(_binding_0) => UseTree::Name(f.fold_use_name(_binding_0)),
-        UseTree::Rename(_binding_0) => UseTree::Rename(f.fold_use_rename(_binding_0)),
-        UseTree::Glob(_binding_0) => UseTree::Glob(f.fold_use_glob(_binding_0)),
-        UseTree::Group(_binding_0) => UseTree::Group(f.fold_use_group(_binding_0)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_variadic<F>(f: &mut F, node: Variadic) -> Variadic
-where
-    F: Fold + ?Sized,
-{
-    Variadic {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        dots: Token ! [...](tokens_helper(f, &node.dots.spans)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_variant<F>(f: &mut F, node: Variant) -> Variant
-where
-    F: Fold + ?Sized,
-{
-    Variant {
-        attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
-        ident: f.fold_ident(node.ident),
-        fields: f.fold_fields(node.fields),
-        discriminant: (node.discriminant).map(|it| {
-            (
-                Token ! [=](tokens_helper(f, &(it).0.spans)),
-                f.fold_expr((it).1),
-            )
-        }),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_vis_crate<F>(f: &mut F, node: VisCrate) -> VisCrate
-where
-    F: Fold + ?Sized,
-{
-    VisCrate {
-        crate_token: Token![crate](tokens_helper(f, &node.crate_token.span)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_vis_public<F>(f: &mut F, node: VisPublic) -> VisPublic
-where
-    F: Fold + ?Sized,
-{
-    VisPublic {
-        pub_token: Token![pub](tokens_helper(f, &node.pub_token.span)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_vis_restricted<F>(f: &mut F, node: VisRestricted) -> VisRestricted
-where
-    F: Fold + ?Sized,
-{
-    VisRestricted {
-        pub_token: Token![pub](tokens_helper(f, &node.pub_token.span)),
-        paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
-        in_token: (node.in_token).map(|it| Token![in](tokens_helper(f, &it.span))),
-        path: Box::new(f.fold_path(*node.path)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_visibility<F>(f: &mut F, node: Visibility) -> Visibility
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        Visibility::Public(_binding_0) => Visibility::Public(f.fold_vis_public(_binding_0)),
-        Visibility::Crate(_binding_0) => Visibility::Crate(f.fold_vis_crate(_binding_0)),
-        Visibility::Restricted(_binding_0) => {
-            Visibility::Restricted(f.fold_vis_restricted(_binding_0))
-        }
-        Visibility::Inherited => Visibility::Inherited,
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_where_clause<F>(f: &mut F, node: WhereClause) -> WhereClause
-where
-    F: Fold + ?Sized,
-{
-    WhereClause {
-        where_token: Token![where](tokens_helper(f, &node.where_token.span)),
-        predicates: FoldHelper::lift(node.predicates, |it| f.fold_where_predicate(it)),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn fold_where_predicate<F>(f: &mut F, node: WherePredicate) -> WherePredicate
-where
-    F: Fold + ?Sized,
-{
-    match node {
-        WherePredicate::Type(_binding_0) => WherePredicate::Type(f.fold_predicate_type(_binding_0)),
-        WherePredicate::Lifetime(_binding_0) => {
-            WherePredicate::Lifetime(f.fold_predicate_lifetime(_binding_0))
-        }
-        WherePredicate::Eq(_binding_0) => WherePredicate::Eq(f.fold_predicate_eq(_binding_0)),
-    }
-}
diff --git a/vendor/syn/src/gen/hash.rs b/vendor/syn/src/gen/hash.rs
deleted file mode 100644
index 7247174a..00000000
--- a/vendor/syn/src/gen/hash.rs
+++ /dev/null
@@ -1,2867 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#[cfg(any(feature = "derive", feature = "full"))]
-use crate::tt::TokenStreamHelper;
-use crate::*;
-use std::hash::{Hash, Hasher};
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Abi {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.name.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for AngleBracketedGenericArguments {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.colon2_token.hash(state);
-        self.args.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Arm {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.pat.hash(state);
-        self.guard.hash(state);
-        self.body.hash(state);
-        self.comma.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for AttrStyle {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            AttrStyle::Outer => {
-                state.write_u8(0u8);
-            }
-            AttrStyle::Inner(_) => {
-                state.write_u8(1u8);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Attribute {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.style.hash(state);
-        self.path.hash(state);
-        TokenStreamHelper(&self.tokens).hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for BareFnArg {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.name.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for BinOp {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            BinOp::Add(_) => {
-                state.write_u8(0u8);
-            }
-            BinOp::Sub(_) => {
-                state.write_u8(1u8);
-            }
-            BinOp::Mul(_) => {
-                state.write_u8(2u8);
-            }
-            BinOp::Div(_) => {
-                state.write_u8(3u8);
-            }
-            BinOp::Rem(_) => {
-                state.write_u8(4u8);
-            }
-            BinOp::And(_) => {
-                state.write_u8(5u8);
-            }
-            BinOp::Or(_) => {
-                state.write_u8(6u8);
-            }
-            BinOp::BitXor(_) => {
-                state.write_u8(7u8);
-            }
-            BinOp::BitAnd(_) => {
-                state.write_u8(8u8);
-            }
-            BinOp::BitOr(_) => {
-                state.write_u8(9u8);
-            }
-            BinOp::Shl(_) => {
-                state.write_u8(10u8);
-            }
-            BinOp::Shr(_) => {
-                state.write_u8(11u8);
-            }
-            BinOp::Eq(_) => {
-                state.write_u8(12u8);
-            }
-            BinOp::Lt(_) => {
-                state.write_u8(13u8);
-            }
-            BinOp::Le(_) => {
-                state.write_u8(14u8);
-            }
-            BinOp::Ne(_) => {
-                state.write_u8(15u8);
-            }
-            BinOp::Ge(_) => {
-                state.write_u8(16u8);
-            }
-            BinOp::Gt(_) => {
-                state.write_u8(17u8);
-            }
-            BinOp::AddEq(_) => {
-                state.write_u8(18u8);
-            }
-            BinOp::SubEq(_) => {
-                state.write_u8(19u8);
-            }
-            BinOp::MulEq(_) => {
-                state.write_u8(20u8);
-            }
-            BinOp::DivEq(_) => {
-                state.write_u8(21u8);
-            }
-            BinOp::RemEq(_) => {
-                state.write_u8(22u8);
-            }
-            BinOp::BitXorEq(_) => {
-                state.write_u8(23u8);
-            }
-            BinOp::BitAndEq(_) => {
-                state.write_u8(24u8);
-            }
-            BinOp::BitOrEq(_) => {
-                state.write_u8(25u8);
-            }
-            BinOp::ShlEq(_) => {
-                state.write_u8(26u8);
-            }
-            BinOp::ShrEq(_) => {
-                state.write_u8(27u8);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Binding {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Block {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.stmts.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for BoundLifetimes {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lifetimes.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ConstParam {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-        self.eq_token.hash(state);
-        self.default.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Constraint {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Data {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Data::Struct(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Data::Enum(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Data::Union(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for DataEnum {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.variants.hash(state);
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for DataStruct {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.fields.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for DataUnion {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.fields.hash(state);
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for DeriveInput {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.data.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Expr {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            #[cfg(feature = "full")]
-            Expr::Array(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Assign(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::AssignOp(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Async(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Await(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-            Expr::Binary(v0) => {
-                state.write_u8(5u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Block(v0) => {
-                state.write_u8(6u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Box(v0) => {
-                state.write_u8(7u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Break(v0) => {
-                state.write_u8(8u8);
-                v0.hash(state);
-            }
-            Expr::Call(v0) => {
-                state.write_u8(9u8);
-                v0.hash(state);
-            }
-            Expr::Cast(v0) => {
-                state.write_u8(10u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Closure(v0) => {
-                state.write_u8(11u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Continue(v0) => {
-                state.write_u8(12u8);
-                v0.hash(state);
-            }
-            Expr::Field(v0) => {
-                state.write_u8(13u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::ForLoop(v0) => {
-                state.write_u8(14u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Group(v0) => {
-                state.write_u8(15u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::If(v0) => {
-                state.write_u8(16u8);
-                v0.hash(state);
-            }
-            Expr::Index(v0) => {
-                state.write_u8(17u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Let(v0) => {
-                state.write_u8(18u8);
-                v0.hash(state);
-            }
-            Expr::Lit(v0) => {
-                state.write_u8(19u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Loop(v0) => {
-                state.write_u8(20u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Macro(v0) => {
-                state.write_u8(21u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Match(v0) => {
-                state.write_u8(22u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::MethodCall(v0) => {
-                state.write_u8(23u8);
-                v0.hash(state);
-            }
-            Expr::Paren(v0) => {
-                state.write_u8(24u8);
-                v0.hash(state);
-            }
-            Expr::Path(v0) => {
-                state.write_u8(25u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Range(v0) => {
-                state.write_u8(26u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Reference(v0) => {
-                state.write_u8(27u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Repeat(v0) => {
-                state.write_u8(28u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Return(v0) => {
-                state.write_u8(29u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Struct(v0) => {
-                state.write_u8(30u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Try(v0) => {
-                state.write_u8(31u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::TryBlock(v0) => {
-                state.write_u8(32u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Tuple(v0) => {
-                state.write_u8(33u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Type(v0) => {
-                state.write_u8(34u8);
-                v0.hash(state);
-            }
-            Expr::Unary(v0) => {
-                state.write_u8(35u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Unsafe(v0) => {
-                state.write_u8(36u8);
-                v0.hash(state);
-            }
-            Expr::Verbatim(v0) => {
-                state.write_u8(37u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::While(v0) => {
-                state.write_u8(38u8);
-                v0.hash(state);
-            }
-            #[cfg(feature = "full")]
-            Expr::Yield(v0) => {
-                state.write_u8(39u8);
-                v0.hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprArray {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.elems.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprAssign {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.left.hash(state);
-        self.right.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprAssignOp {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.left.hash(state);
-        self.op.hash(state);
-        self.right.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprAsync {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.capture.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprAwait {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.base.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprBinary {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.left.hash(state);
-        self.op.hash(state);
-        self.right.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprBlock {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprBox {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprBreak {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprCall {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.func.hash(state);
-        self.args.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprCast {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprClosure {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.asyncness.hash(state);
-        self.movability.hash(state);
-        self.capture.hash(state);
-        self.inputs.hash(state);
-        self.output.hash(state);
-        self.body.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprContinue {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprField {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.base.hash(state);
-        self.member.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprForLoop {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-        self.pat.hash(state);
-        self.expr.hash(state);
-        self.body.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprGroup {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprIf {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.cond.hash(state);
-        self.then_branch.hash(state);
-        self.else_branch.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprIndex {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-        self.index.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprLet {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.pat.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprLit {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.lit.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprLoop {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-        self.body.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mac.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprMatch {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-        self.arms.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprMethodCall {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.receiver.hash(state);
-        self.method.hash(state);
-        self.turbofish.hash(state);
-        self.args.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprParen {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprPath {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.qself.hash(state);
-        self.path.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprRange {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.from.hash(state);
-        self.limits.hash(state);
-        self.to.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprReference {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mutability.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprRepeat {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-        self.len.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprReturn {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprStruct {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.path.hash(state);
-        self.fields.hash(state);
-        self.dot2_token.hash(state);
-        self.rest.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprTry {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprTryBlock {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprTuple {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.elems.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprUnary {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.op.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprUnsafe {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprWhile {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.label.hash(state);
-        self.cond.hash(state);
-        self.body.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ExprYield {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Field {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.colon_token.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for FieldPat {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.member.hash(state);
-        self.colon_token.hash(state);
-        self.pat.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for FieldValue {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.member.hash(state);
-        self.colon_token.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Fields {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Fields::Named(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Fields::Unnamed(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Fields::Unit => {
-                state.write_u8(2u8);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for FieldsNamed {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.named.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for FieldsUnnamed {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.unnamed.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for File {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.shebang.hash(state);
-        self.attrs.hash(state);
-        self.items.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for FnArg {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            FnArg::Receiver(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            FnArg::Typed(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ForeignItem {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            ForeignItem::Fn(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            ForeignItem::Static(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            ForeignItem::Type(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            ForeignItem::Macro(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            ForeignItem::Verbatim(v0) => {
-                state.write_u8(4u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ForeignItemFn {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.sig.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ForeignItemMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mac.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ForeignItemStatic {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.mutability.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ForeignItemType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for GenericArgument {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            GenericArgument::Lifetime(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            GenericArgument::Type(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            GenericArgument::Binding(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            GenericArgument::Constraint(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            GenericArgument::Const(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for GenericMethodArgument {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            GenericMethodArgument::Type(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            GenericMethodArgument::Const(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for GenericParam {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            GenericParam::Type(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            GenericParam::Lifetime(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            GenericParam::Const(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Generics {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lt_token.hash(state);
-        self.params.hash(state);
-        self.gt_token.hash(state);
-        self.where_clause.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ImplItem {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            ImplItem::Const(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            ImplItem::Method(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            ImplItem::Type(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            ImplItem::Macro(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            ImplItem::Verbatim(v0) => {
-                state.write_u8(4u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ImplItemConst {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.defaultness.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ImplItemMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mac.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ImplItemMethod {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.defaultness.hash(state);
-        self.sig.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ImplItemType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.defaultness.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Item {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Item::Const(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Item::Enum(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Item::ExternCrate(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Item::Fn(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            Item::ForeignMod(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-            Item::Impl(v0) => {
-                state.write_u8(5u8);
-                v0.hash(state);
-            }
-            Item::Macro(v0) => {
-                state.write_u8(6u8);
-                v0.hash(state);
-            }
-            Item::Macro2(v0) => {
-                state.write_u8(7u8);
-                v0.hash(state);
-            }
-            Item::Mod(v0) => {
-                state.write_u8(8u8);
-                v0.hash(state);
-            }
-            Item::Static(v0) => {
-                state.write_u8(9u8);
-                v0.hash(state);
-            }
-            Item::Struct(v0) => {
-                state.write_u8(10u8);
-                v0.hash(state);
-            }
-            Item::Trait(v0) => {
-                state.write_u8(11u8);
-                v0.hash(state);
-            }
-            Item::TraitAlias(v0) => {
-                state.write_u8(12u8);
-                v0.hash(state);
-            }
-            Item::Type(v0) => {
-                state.write_u8(13u8);
-                v0.hash(state);
-            }
-            Item::Union(v0) => {
-                state.write_u8(14u8);
-                v0.hash(state);
-            }
-            Item::Use(v0) => {
-                state.write_u8(15u8);
-                v0.hash(state);
-            }
-            Item::Verbatim(v0) => {
-                state.write_u8(16u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemConst {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemEnum {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.variants.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemExternCrate {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.rename.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemFn {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.sig.hash(state);
-        self.block.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemForeignMod {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.abi.hash(state);
-        self.items.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemImpl {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.defaultness.hash(state);
-        self.unsafety.hash(state);
-        self.generics.hash(state);
-        self.trait_.hash(state);
-        self.self_ty.hash(state);
-        self.items.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.mac.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemMacro2 {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        TokenStreamHelper(&self.rules).hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemMod {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.content.hash(state);
-        self.semi.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemStatic {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.mutability.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemStruct {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.fields.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemTrait {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.unsafety.hash(state);
-        self.auto_token.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.colon_token.hash(state);
-        self.supertraits.hash(state);
-        self.items.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemTraitAlias {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemUnion {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.fields.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ItemUse {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.vis.hash(state);
-        self.leading_colon.hash(state);
-        self.tree.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Label {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.name.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for LifetimeDef {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.lifetime.hash(state);
-        self.colon_token.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Lit {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Lit::Str(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Lit::ByteStr(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Lit::Byte(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Lit::Char(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            Lit::Int(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-            Lit::Float(v0) => {
-                state.write_u8(5u8);
-                v0.hash(state);
-            }
-            Lit::Bool(v0) => {
-                state.write_u8(6u8);
-                v0.hash(state);
-            }
-            Lit::Verbatim(v0) => {
-                state.write_u8(7u8);
-                v0.to_string().hash(state);
-            }
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for LitBool {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.value.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Local {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.pat.hash(state);
-        self.init.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Macro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.path.hash(state);
-        self.delimiter.hash(state);
-        TokenStreamHelper(&self.tokens).hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for MacroDelimiter {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            MacroDelimiter::Paren(_) => {
-                state.write_u8(0u8);
-            }
-            MacroDelimiter::Brace(_) => {
-                state.write_u8(1u8);
-            }
-            MacroDelimiter::Bracket(_) => {
-                state.write_u8(2u8);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Meta {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Meta::Path(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Meta::List(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Meta::NameValue(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for MetaList {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.path.hash(state);
-        self.nested.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for MetaNameValue {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.path.hash(state);
-        self.lit.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for MethodTurbofish {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.args.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for NestedMeta {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            NestedMeta::Meta(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            NestedMeta::Lit(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ParenthesizedGenericArguments {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.inputs.hash(state);
-        self.output.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Pat {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Pat::Box(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Pat::Ident(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Pat::Lit(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Pat::Macro(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            Pat::Or(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-            Pat::Path(v0) => {
-                state.write_u8(5u8);
-                v0.hash(state);
-            }
-            Pat::Range(v0) => {
-                state.write_u8(6u8);
-                v0.hash(state);
-            }
-            Pat::Reference(v0) => {
-                state.write_u8(7u8);
-                v0.hash(state);
-            }
-            Pat::Rest(v0) => {
-                state.write_u8(8u8);
-                v0.hash(state);
-            }
-            Pat::Slice(v0) => {
-                state.write_u8(9u8);
-                v0.hash(state);
-            }
-            Pat::Struct(v0) => {
-                state.write_u8(10u8);
-                v0.hash(state);
-            }
-            Pat::Tuple(v0) => {
-                state.write_u8(11u8);
-                v0.hash(state);
-            }
-            Pat::TupleStruct(v0) => {
-                state.write_u8(12u8);
-                v0.hash(state);
-            }
-            Pat::Type(v0) => {
-                state.write_u8(13u8);
-                v0.hash(state);
-            }
-            Pat::Verbatim(v0) => {
-                state.write_u8(14u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            Pat::Wild(v0) => {
-                state.write_u8(15u8);
-                v0.hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatBox {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.pat.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatIdent {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.by_ref.hash(state);
-        self.mutability.hash(state);
-        self.ident.hash(state);
-        self.subpat.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatLit {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.expr.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mac.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatOr {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.leading_vert.hash(state);
-        self.cases.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatPath {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.qself.hash(state);
-        self.path.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatRange {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.lo.hash(state);
-        self.limits.hash(state);
-        self.hi.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatReference {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mutability.hash(state);
-        self.pat.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatRest {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatSlice {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.elems.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatStruct {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.path.hash(state);
-        self.fields.hash(state);
-        self.dot2_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatTuple {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.elems.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatTupleStruct {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.path.hash(state);
-        self.pat.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.pat.hash(state);
-        self.ty.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PatWild {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Path {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.leading_colon.hash(state);
-        self.segments.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PathArguments {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            PathArguments::None => {
-                state.write_u8(0u8);
-            }
-            PathArguments::AngleBracketed(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            PathArguments::Parenthesized(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PathSegment {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-        self.arguments.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PredicateEq {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lhs_ty.hash(state);
-        self.rhs_ty.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PredicateLifetime {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lifetime.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for PredicateType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lifetimes.hash(state);
-        self.bounded_ty.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for QSelf {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ty.hash(state);
-        self.position.hash(state);
-        self.as_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for RangeLimits {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            RangeLimits::HalfOpen(_) => {
-                state.write_u8(0u8);
-            }
-            RangeLimits::Closed(_) => {
-                state.write_u8(1u8);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Receiver {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.reference.hash(state);
-        self.mutability.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for ReturnType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            ReturnType::Default => {
-                state.write_u8(0u8);
-            }
-            ReturnType::Type(_, v1) => {
-                state.write_u8(1u8);
-                v1.hash(state);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Signature {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.constness.hash(state);
-        self.asyncness.hash(state);
-        self.unsafety.hash(state);
-        self.abi.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.inputs.hash(state);
-        self.variadic.hash(state);
-        self.output.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Stmt {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Stmt::Local(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Stmt::Item(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Stmt::Expr(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Stmt::Semi(v0, _) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitBound {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.paren_token.hash(state);
-        self.modifier.hash(state);
-        self.lifetimes.hash(state);
-        self.path.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitBoundModifier {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            TraitBoundModifier::None => {
-                state.write_u8(0u8);
-            }
-            TraitBoundModifier::Maybe(_) => {
-                state.write_u8(1u8);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitItem {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            TraitItem::Const(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            TraitItem::Method(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            TraitItem::Type(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            TraitItem::Macro(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            TraitItem::Verbatim(v0) => {
-                state.write_u8(4u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitItemConst {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.ty.hash(state);
-        self.default.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitItemMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.mac.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitItemMethod {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.sig.hash(state);
-        self.default.hash(state);
-        self.semi_token.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TraitItemType {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.generics.hash(state);
-        self.colon_token.hash(state);
-        self.bounds.hash(state);
-        self.default.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Type {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Type::Array(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Type::BareFn(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Type::Group(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Type::ImplTrait(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            Type::Infer(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-            Type::Macro(v0) => {
-                state.write_u8(5u8);
-                v0.hash(state);
-            }
-            Type::Never(v0) => {
-                state.write_u8(6u8);
-                v0.hash(state);
-            }
-            Type::Paren(v0) => {
-                state.write_u8(7u8);
-                v0.hash(state);
-            }
-            Type::Path(v0) => {
-                state.write_u8(8u8);
-                v0.hash(state);
-            }
-            Type::Ptr(v0) => {
-                state.write_u8(9u8);
-                v0.hash(state);
-            }
-            Type::Reference(v0) => {
-                state.write_u8(10u8);
-                v0.hash(state);
-            }
-            Type::Slice(v0) => {
-                state.write_u8(11u8);
-                v0.hash(state);
-            }
-            Type::TraitObject(v0) => {
-                state.write_u8(12u8);
-                v0.hash(state);
-            }
-            Type::Tuple(v0) => {
-                state.write_u8(13u8);
-                v0.hash(state);
-            }
-            Type::Verbatim(v0) => {
-                state.write_u8(14u8);
-                TokenStreamHelper(v0).hash(state);
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeArray {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.elem.hash(state);
-        self.len.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeBareFn {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lifetimes.hash(state);
-        self.unsafety.hash(state);
-        self.abi.hash(state);
-        self.inputs.hash(state);
-        self.variadic.hash(state);
-        self.output.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeGroup {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.elem.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeImplTrait {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.bounds.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeInfer {
-    fn hash<H>(&self, _state: &mut H)
-    where
-        H: Hasher,
-    {
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeMacro {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.mac.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeNever {
-    fn hash<H>(&self, _state: &mut H)
-    where
-        H: Hasher,
-    {
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeParam {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.colon_token.hash(state);
-        self.bounds.hash(state);
-        self.eq_token.hash(state);
-        self.default.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeParamBound {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            TypeParamBound::Trait(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            TypeParamBound::Lifetime(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeParen {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.elem.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypePath {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.qself.hash(state);
-        self.path.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypePtr {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.const_token.hash(state);
-        self.mutability.hash(state);
-        self.elem.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeReference {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.lifetime.hash(state);
-        self.mutability.hash(state);
-        self.elem.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeSlice {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.elem.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeTraitObject {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.dyn_token.hash(state);
-        self.bounds.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for TypeTuple {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.elems.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UnOp {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            UnOp::Deref(_) => {
-                state.write_u8(0u8);
-            }
-            UnOp::Not(_) => {
-                state.write_u8(1u8);
-            }
-            UnOp::Neg(_) => {
-                state.write_u8(2u8);
-            }
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UseGlob {
-    fn hash<H>(&self, _state: &mut H)
-    where
-        H: Hasher,
-    {
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UseGroup {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.items.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UseName {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UsePath {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-        self.tree.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UseRename {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.ident.hash(state);
-        self.rename.hash(state);
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for UseTree {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            UseTree::Path(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            UseTree::Name(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            UseTree::Rename(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            UseTree::Glob(v0) => {
-                state.write_u8(3u8);
-                v0.hash(state);
-            }
-            UseTree::Group(v0) => {
-                state.write_u8(4u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Variadic {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Variant {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.attrs.hash(state);
-        self.ident.hash(state);
-        self.fields.hash(state);
-        self.discriminant.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for VisCrate {
-    fn hash<H>(&self, _state: &mut H)
-    where
-        H: Hasher,
-    {
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for VisPublic {
-    fn hash<H>(&self, _state: &mut H)
-    where
-        H: Hasher,
-    {
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for VisRestricted {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.in_token.hash(state);
-        self.path.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for Visibility {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            Visibility::Public(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            Visibility::Crate(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            Visibility::Restricted(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-            Visibility::Inherited => {
-                state.write_u8(3u8);
-            }
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for WhereClause {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.predicates.hash(state);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Hash for WherePredicate {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        match self {
-            WherePredicate::Type(v0) => {
-                state.write_u8(0u8);
-                v0.hash(state);
-            }
-            WherePredicate::Lifetime(v0) => {
-                state.write_u8(1u8);
-                v0.hash(state);
-            }
-            WherePredicate::Eq(v0) => {
-                state.write_u8(2u8);
-                v0.hash(state);
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/visit.rs b/vendor/syn/src/gen/visit.rs
deleted file mode 100644
index 6eaee24c..00000000
--- a/vendor/syn/src/gen/visit.rs
+++ /dev/null
@@ -1,3775 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#![allow(unused_variables)]
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::gen::helper::visit::*;
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::punctuated::Punctuated;
-use crate::*;
-use proc_macro2::Span;
-#[cfg(feature = "full")]
-macro_rules! full {
-    ($e:expr) => {
-        $e
-    };
-}
-#[cfg(all(feature = "derive", not(feature = "full")))]
-macro_rules! full {
-    ($e:expr) => {
-        unreachable!()
-    };
-}
-macro_rules! skip {
-    ($($tt:tt)*) => {};
-}
-/// Syntax tree traversal to walk a shared borrow of a syntax tree.
-///
-/// See the [module documentation] for details.
-///
-/// [module documentation]: self
-///
-/// *This trait is available only if Syn is built with the `"visit"` feature.*
-pub trait Visit<'ast> {
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_abi(&mut self, i: &'ast Abi) {
-        visit_abi(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) {
-        visit_angle_bracketed_generic_arguments(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_arm(&mut self, i: &'ast Arm) {
-        visit_arm(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_attr_style(&mut self, i: &'ast AttrStyle) {
-        visit_attr_style(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_attribute(&mut self, i: &'ast Attribute) {
-        visit_attribute(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) {
-        visit_bare_fn_arg(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bin_op(&mut self, i: &'ast BinOp) {
-        visit_bin_op(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_binding(&mut self, i: &'ast Binding) {
-        visit_binding(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_block(&mut self, i: &'ast Block) {
-        visit_block(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) {
-        visit_bound_lifetimes(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_const_param(&mut self, i: &'ast ConstParam) {
-        visit_const_param(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_constraint(&mut self, i: &'ast Constraint) {
-        visit_constraint(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data(&mut self, i: &'ast Data) {
-        visit_data(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_enum(&mut self, i: &'ast DataEnum) {
-        visit_data_enum(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_struct(&mut self, i: &'ast DataStruct) {
-        visit_data_struct(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_union(&mut self, i: &'ast DataUnion) {
-        visit_data_union(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_derive_input(&mut self, i: &'ast DeriveInput) {
-        visit_derive_input(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr(&mut self, i: &'ast Expr) {
-        visit_expr(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_array(&mut self, i: &'ast ExprArray) {
-        visit_expr_array(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
-        visit_expr_assign(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) {
-        visit_expr_assign_op(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_async(&mut self, i: &'ast ExprAsync) {
-        visit_expr_async(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_await(&mut self, i: &'ast ExprAwait) {
-        visit_expr_await(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_binary(&mut self, i: &'ast ExprBinary) {
-        visit_expr_binary(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_block(&mut self, i: &'ast ExprBlock) {
-        visit_expr_block(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_box(&mut self, i: &'ast ExprBox) {
-        visit_expr_box(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_break(&mut self, i: &'ast ExprBreak) {
-        visit_expr_break(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_call(&mut self, i: &'ast ExprCall) {
-        visit_expr_call(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_cast(&mut self, i: &'ast ExprCast) {
-        visit_expr_cast(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_closure(&mut self, i: &'ast ExprClosure) {
-        visit_expr_closure(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_continue(&mut self, i: &'ast ExprContinue) {
-        visit_expr_continue(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_field(&mut self, i: &'ast ExprField) {
-        visit_expr_field(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) {
-        visit_expr_for_loop(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_group(&mut self, i: &'ast ExprGroup) {
-        visit_expr_group(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_if(&mut self, i: &'ast ExprIf) {
-        visit_expr_if(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_index(&mut self, i: &'ast ExprIndex) {
-        visit_expr_index(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_let(&mut self, i: &'ast ExprLet) {
-        visit_expr_let(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_lit(&mut self, i: &'ast ExprLit) {
-        visit_expr_lit(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_loop(&mut self, i: &'ast ExprLoop) {
-        visit_expr_loop(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_macro(&mut self, i: &'ast ExprMacro) {
-        visit_expr_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_match(&mut self, i: &'ast ExprMatch) {
-        visit_expr_match(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) {
-        visit_expr_method_call(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_paren(&mut self, i: &'ast ExprParen) {
-        visit_expr_paren(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_path(&mut self, i: &'ast ExprPath) {
-        visit_expr_path(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_range(&mut self, i: &'ast ExprRange) {
-        visit_expr_range(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_reference(&mut self, i: &'ast ExprReference) {
-        visit_expr_reference(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) {
-        visit_expr_repeat(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_return(&mut self, i: &'ast ExprReturn) {
-        visit_expr_return(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_struct(&mut self, i: &'ast ExprStruct) {
-        visit_expr_struct(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_try(&mut self, i: &'ast ExprTry) {
-        visit_expr_try(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) {
-        visit_expr_try_block(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) {
-        visit_expr_tuple(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_type(&mut self, i: &'ast ExprType) {
-        visit_expr_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_unary(&mut self, i: &'ast ExprUnary) {
-        visit_expr_unary(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) {
-        visit_expr_unsafe(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_while(&mut self, i: &'ast ExprWhile) {
-        visit_expr_while(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_yield(&mut self, i: &'ast ExprYield) {
-        visit_expr_yield(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_field(&mut self, i: &'ast Field) {
-        visit_field(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_field_pat(&mut self, i: &'ast FieldPat) {
-        visit_field_pat(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_field_value(&mut self, i: &'ast FieldValue) {
-        visit_field_value(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields(&mut self, i: &'ast Fields) {
-        visit_fields(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields_named(&mut self, i: &'ast FieldsNamed) {
-        visit_fields_named(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) {
-        visit_fields_unnamed(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_file(&mut self, i: &'ast File) {
-        visit_file(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_fn_arg(&mut self, i: &'ast FnArg) {
-        visit_fn_arg(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item(&mut self, i: &'ast ForeignItem) {
-        visit_foreign_item(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_fn(&mut self, i: &'ast ForeignItemFn) {
-        visit_foreign_item_fn(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_macro(&mut self, i: &'ast ForeignItemMacro) {
-        visit_foreign_item_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) {
-        visit_foreign_item_static(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) {
-        visit_foreign_item_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generic_argument(&mut self, i: &'ast GenericArgument) {
-        visit_generic_argument(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) {
-        visit_generic_method_argument(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generic_param(&mut self, i: &'ast GenericParam) {
-        visit_generic_param(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generics(&mut self, i: &'ast Generics) {
-        visit_generics(self, i);
-    }
-    fn visit_ident(&mut self, i: &'ast Ident) {
-        visit_ident(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item(&mut self, i: &'ast ImplItem) {
-        visit_impl_item(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_const(&mut self, i: &'ast ImplItemConst) {
-        visit_impl_item_const(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_macro(&mut self, i: &'ast ImplItemMacro) {
-        visit_impl_item_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_method(&mut self, i: &'ast ImplItemMethod) {
-        visit_impl_item_method(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) {
-        visit_impl_item_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_index(&mut self, i: &'ast Index) {
-        visit_index(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item(&mut self, i: &'ast Item) {
-        visit_item(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_const(&mut self, i: &'ast ItemConst) {
-        visit_item_const(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_enum(&mut self, i: &'ast ItemEnum) {
-        visit_item_enum(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_extern_crate(&mut self, i: &'ast ItemExternCrate) {
-        visit_item_extern_crate(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_fn(&mut self, i: &'ast ItemFn) {
-        visit_item_fn(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) {
-        visit_item_foreign_mod(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_impl(&mut self, i: &'ast ItemImpl) {
-        visit_item_impl(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_macro(&mut self, i: &'ast ItemMacro) {
-        visit_item_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_macro2(&mut self, i: &'ast ItemMacro2) {
-        visit_item_macro2(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_mod(&mut self, i: &'ast ItemMod) {
-        visit_item_mod(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_static(&mut self, i: &'ast ItemStatic) {
-        visit_item_static(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
-        visit_item_struct(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_trait(&mut self, i: &'ast ItemTrait) {
-        visit_item_trait(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) {
-        visit_item_trait_alias(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_type(&mut self, i: &'ast ItemType) {
-        visit_item_type(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_union(&mut self, i: &'ast ItemUnion) {
-        visit_item_union(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_use(&mut self, i: &'ast ItemUse) {
-        visit_item_use(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_label(&mut self, i: &'ast Label) {
-        visit_label(self, i);
-    }
-    fn visit_lifetime(&mut self, i: &'ast Lifetime) {
-        visit_lifetime(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef) {
-        visit_lifetime_def(self, i);
-    }
-    fn visit_lit(&mut self, i: &'ast Lit) {
-        visit_lit(self, i);
-    }
-    fn visit_lit_bool(&mut self, i: &'ast LitBool) {
-        visit_lit_bool(self, i);
-    }
-    fn visit_lit_byte(&mut self, i: &'ast LitByte) {
-        visit_lit_byte(self, i);
-    }
-    fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr) {
-        visit_lit_byte_str(self, i);
-    }
-    fn visit_lit_char(&mut self, i: &'ast LitChar) {
-        visit_lit_char(self, i);
-    }
-    fn visit_lit_float(&mut self, i: &'ast LitFloat) {
-        visit_lit_float(self, i);
-    }
-    fn visit_lit_int(&mut self, i: &'ast LitInt) {
-        visit_lit_int(self, i);
-    }
-    fn visit_lit_str(&mut self, i: &'ast LitStr) {
-        visit_lit_str(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_local(&mut self, i: &'ast Local) {
-        visit_local(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_macro(&mut self, i: &'ast Macro) {
-        visit_macro(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) {
-        visit_macro_delimiter(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_member(&mut self, i: &'ast Member) {
-        visit_member(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta(&mut self, i: &'ast Meta) {
-        visit_meta(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta_list(&mut self, i: &'ast MetaList) {
-        visit_meta_list(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) {
-        visit_meta_name_value(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) {
-        visit_method_turbofish(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_nested_meta(&mut self, i: &'ast NestedMeta) {
-        visit_nested_meta(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) {
-        visit_parenthesized_generic_arguments(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat(&mut self, i: &'ast Pat) {
-        visit_pat(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_box(&mut self, i: &'ast PatBox) {
-        visit_pat_box(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_ident(&mut self, i: &'ast PatIdent) {
-        visit_pat_ident(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_lit(&mut self, i: &'ast PatLit) {
-        visit_pat_lit(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_macro(&mut self, i: &'ast PatMacro) {
-        visit_pat_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_or(&mut self, i: &'ast PatOr) {
-        visit_pat_or(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_path(&mut self, i: &'ast PatPath) {
-        visit_pat_path(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_range(&mut self, i: &'ast PatRange) {
-        visit_pat_range(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_reference(&mut self, i: &'ast PatReference) {
-        visit_pat_reference(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_rest(&mut self, i: &'ast PatRest) {
-        visit_pat_rest(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_slice(&mut self, i: &'ast PatSlice) {
-        visit_pat_slice(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_struct(&mut self, i: &'ast PatStruct) {
-        visit_pat_struct(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_tuple(&mut self, i: &'ast PatTuple) {
-        visit_pat_tuple(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) {
-        visit_pat_tuple_struct(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_type(&mut self, i: &'ast PatType) {
-        visit_pat_type(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_wild(&mut self, i: &'ast PatWild) {
-        visit_pat_wild(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path(&mut self, i: &'ast Path) {
-        visit_path(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path_arguments(&mut self, i: &'ast PathArguments) {
-        visit_path_arguments(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path_segment(&mut self, i: &'ast PathSegment) {
-        visit_path_segment(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_eq(&mut self, i: &'ast PredicateEq) {
-        visit_predicate_eq(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) {
-        visit_predicate_lifetime(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_type(&mut self, i: &'ast PredicateType) {
-        visit_predicate_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_qself(&mut self, i: &'ast QSelf) {
-        visit_qself(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_range_limits(&mut self, i: &'ast RangeLimits) {
-        visit_range_limits(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_receiver(&mut self, i: &'ast Receiver) {
-        visit_receiver(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_return_type(&mut self, i: &'ast ReturnType) {
-        visit_return_type(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_signature(&mut self, i: &'ast Signature) {
-        visit_signature(self, i);
-    }
-    fn visit_span(&mut self, i: &Span) {
-        visit_span(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_stmt(&mut self, i: &'ast Stmt) {
-        visit_stmt(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_trait_bound(&mut self, i: &'ast TraitBound) {
-        visit_trait_bound(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) {
-        visit_trait_bound_modifier(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item(&mut self, i: &'ast TraitItem) {
-        visit_trait_item(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_const(&mut self, i: &'ast TraitItemConst) {
-        visit_trait_item_const(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_macro(&mut self, i: &'ast TraitItemMacro) {
-        visit_trait_item_macro(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_method(&mut self, i: &'ast TraitItemMethod) {
-        visit_trait_item_method(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) {
-        visit_trait_item_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type(&mut self, i: &'ast Type) {
-        visit_type(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_array(&mut self, i: &'ast TypeArray) {
-        visit_type_array(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) {
-        visit_type_bare_fn(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_group(&mut self, i: &'ast TypeGroup) {
-        visit_type_group(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) {
-        visit_type_impl_trait(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_infer(&mut self, i: &'ast TypeInfer) {
-        visit_type_infer(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_macro(&mut self, i: &'ast TypeMacro) {
-        visit_type_macro(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_never(&mut self, i: &'ast TypeNever) {
-        visit_type_never(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_param(&mut self, i: &'ast TypeParam) {
-        visit_type_param(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) {
-        visit_type_param_bound(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_paren(&mut self, i: &'ast TypeParen) {
-        visit_type_paren(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_path(&mut self, i: &'ast TypePath) {
-        visit_type_path(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_ptr(&mut self, i: &'ast TypePtr) {
-        visit_type_ptr(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_reference(&mut self, i: &'ast TypeReference) {
-        visit_type_reference(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_slice(&mut self, i: &'ast TypeSlice) {
-        visit_type_slice(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) {
-        visit_type_trait_object(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_tuple(&mut self, i: &'ast TypeTuple) {
-        visit_type_tuple(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_un_op(&mut self, i: &'ast UnOp) {
-        visit_un_op(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_glob(&mut self, i: &'ast UseGlob) {
-        visit_use_glob(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_group(&mut self, i: &'ast UseGroup) {
-        visit_use_group(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_name(&mut self, i: &'ast UseName) {
-        visit_use_name(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_path(&mut self, i: &'ast UsePath) {
-        visit_use_path(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_rename(&mut self, i: &'ast UseRename) {
-        visit_use_rename(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_tree(&mut self, i: &'ast UseTree) {
-        visit_use_tree(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_variadic(&mut self, i: &'ast Variadic) {
-        visit_variadic(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_variant(&mut self, i: &'ast Variant) {
-        visit_variant(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_crate(&mut self, i: &'ast VisCrate) {
-        visit_vis_crate(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_public(&mut self, i: &'ast VisPublic) {
-        visit_vis_public(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) {
-        visit_vis_restricted(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_visibility(&mut self, i: &'ast Visibility) {
-        visit_visibility(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_where_clause(&mut self, i: &'ast WhereClause) {
-        visit_where_clause(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_where_predicate(&mut self, i: &'ast WherePredicate) {
-        visit_where_predicate(self, i);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_abi<'ast, V>(v: &mut V, node: &'ast Abi)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.extern_token.span);
-    if let Some(it) = &node.name {
-        v.visit_lit_str(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_angle_bracketed_generic_arguments<'ast, V>(
-    v: &mut V,
-    node: &'ast AngleBracketedGenericArguments,
-) where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.colon2_token {
-        tokens_helper(v, &it.spans);
-    };
-    tokens_helper(v, &node.lt_token.spans);
-    for el in Punctuated::pairs(&node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_argument(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.gt_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_arm<'ast, V>(v: &mut V, node: &'ast Arm)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_pat(&node.pat);
-    if let Some(it) = &node.guard {
-        tokens_helper(v, &(it).0.span);
-        v.visit_expr(&*(it).1);
-    };
-    tokens_helper(v, &node.fat_arrow_token.spans);
-    v.visit_expr(&*node.body);
-    if let Some(it) = &node.comma {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_attr_style<'ast, V>(v: &mut V, node: &'ast AttrStyle)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        AttrStyle::Outer => {}
-        AttrStyle::Inner(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_attribute<'ast, V>(v: &mut V, node: &'ast Attribute)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.pound_token.spans);
-    v.visit_attr_style(&node.style);
-    tokens_helper(v, &node.bracket_token.span);
-    v.visit_path(&node.path);
-    skip!(node.tokens);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bare_fn_arg<'ast, V>(v: &mut V, node: &'ast BareFnArg)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.name {
-        v.visit_ident(&(it).0);
-        tokens_helper(v, &(it).1.spans);
-    };
-    v.visit_type(&node.ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bin_op<'ast, V>(v: &mut V, node: &'ast BinOp)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        BinOp::Add(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Sub(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Mul(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Div(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Rem(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::And(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Or(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitXor(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitAnd(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitOr(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Shl(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Shr(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Eq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Lt(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Le(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Ne(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Ge(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::Gt(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::AddEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::SubEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::MulEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::DivEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::RemEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitXorEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitAndEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::BitOrEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::ShlEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        BinOp::ShrEq(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_binding<'ast, V>(v: &mut V, node: &'ast Binding)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_type(&node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_block<'ast, V>(v: &mut V, node: &'ast Block)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.brace_token.span);
-    for it in &node.stmts {
-        v.visit_stmt(it);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bound_lifetimes<'ast, V>(v: &mut V, node: &'ast BoundLifetimes)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.for_token.span);
-    tokens_helper(v, &node.lt_token.spans);
-    for el in Punctuated::pairs(&node.lifetimes) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime_def(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.gt_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_const_param<'ast, V>(v: &mut V, node: &'ast ConstParam)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.const_token.span);
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&node.ty);
-    if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans);
-    };
-    if let Some(it) = &node.default {
-        v.visit_expr(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_constraint<'ast, V>(v: &mut V, node: &'ast Constraint)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data<'ast, V>(v: &mut V, node: &'ast Data)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Data::Struct(_binding_0) => {
-            v.visit_data_struct(_binding_0);
-        }
-        Data::Enum(_binding_0) => {
-            v.visit_data_enum(_binding_0);
-        }
-        Data::Union(_binding_0) => {
-            v.visit_data_union(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_enum<'ast, V>(v: &mut V, node: &'ast DataEnum)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.enum_token.span);
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.variants) {
-        let (it, p) = el.into_tuple();
-        v.visit_variant(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_struct<'ast, V>(v: &mut V, node: &'ast DataStruct)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.struct_token.span);
-    v.visit_fields(&node.fields);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_union<'ast, V>(v: &mut V, node: &'ast DataUnion)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.union_token.span);
-    v.visit_fields_named(&node.fields);
-}
-#[cfg(feature = "derive")]
-pub fn visit_derive_input<'ast, V>(v: &mut V, node: &'ast DeriveInput)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    v.visit_data(&node.data);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr<'ast, V>(v: &mut V, node: &'ast Expr)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Expr::Array(_binding_0) => {
-            full!(v.visit_expr_array(_binding_0));
-        }
-        Expr::Assign(_binding_0) => {
-            full!(v.visit_expr_assign(_binding_0));
-        }
-        Expr::AssignOp(_binding_0) => {
-            full!(v.visit_expr_assign_op(_binding_0));
-        }
-        Expr::Async(_binding_0) => {
-            full!(v.visit_expr_async(_binding_0));
-        }
-        Expr::Await(_binding_0) => {
-            full!(v.visit_expr_await(_binding_0));
-        }
-        Expr::Binary(_binding_0) => {
-            v.visit_expr_binary(_binding_0);
-        }
-        Expr::Block(_binding_0) => {
-            full!(v.visit_expr_block(_binding_0));
-        }
-        Expr::Box(_binding_0) => {
-            full!(v.visit_expr_box(_binding_0));
-        }
-        Expr::Break(_binding_0) => {
-            full!(v.visit_expr_break(_binding_0));
-        }
-        Expr::Call(_binding_0) => {
-            v.visit_expr_call(_binding_0);
-        }
-        Expr::Cast(_binding_0) => {
-            v.visit_expr_cast(_binding_0);
-        }
-        Expr::Closure(_binding_0) => {
-            full!(v.visit_expr_closure(_binding_0));
-        }
-        Expr::Continue(_binding_0) => {
-            full!(v.visit_expr_continue(_binding_0));
-        }
-        Expr::Field(_binding_0) => {
-            v.visit_expr_field(_binding_0);
-        }
-        Expr::ForLoop(_binding_0) => {
-            full!(v.visit_expr_for_loop(_binding_0));
-        }
-        Expr::Group(_binding_0) => {
-            full!(v.visit_expr_group(_binding_0));
-        }
-        Expr::If(_binding_0) => {
-            full!(v.visit_expr_if(_binding_0));
-        }
-        Expr::Index(_binding_0) => {
-            v.visit_expr_index(_binding_0);
-        }
-        Expr::Let(_binding_0) => {
-            full!(v.visit_expr_let(_binding_0));
-        }
-        Expr::Lit(_binding_0) => {
-            v.visit_expr_lit(_binding_0);
-        }
-        Expr::Loop(_binding_0) => {
-            full!(v.visit_expr_loop(_binding_0));
-        }
-        Expr::Macro(_binding_0) => {
-            full!(v.visit_expr_macro(_binding_0));
-        }
-        Expr::Match(_binding_0) => {
-            full!(v.visit_expr_match(_binding_0));
-        }
-        Expr::MethodCall(_binding_0) => {
-            full!(v.visit_expr_method_call(_binding_0));
-        }
-        Expr::Paren(_binding_0) => {
-            v.visit_expr_paren(_binding_0);
-        }
-        Expr::Path(_binding_0) => {
-            v.visit_expr_path(_binding_0);
-        }
-        Expr::Range(_binding_0) => {
-            full!(v.visit_expr_range(_binding_0));
-        }
-        Expr::Reference(_binding_0) => {
-            full!(v.visit_expr_reference(_binding_0));
-        }
-        Expr::Repeat(_binding_0) => {
-            full!(v.visit_expr_repeat(_binding_0));
-        }
-        Expr::Return(_binding_0) => {
-            full!(v.visit_expr_return(_binding_0));
-        }
-        Expr::Struct(_binding_0) => {
-            full!(v.visit_expr_struct(_binding_0));
-        }
-        Expr::Try(_binding_0) => {
-            full!(v.visit_expr_try(_binding_0));
-        }
-        Expr::TryBlock(_binding_0) => {
-            full!(v.visit_expr_try_block(_binding_0));
-        }
-        Expr::Tuple(_binding_0) => {
-            full!(v.visit_expr_tuple(_binding_0));
-        }
-        Expr::Type(_binding_0) => {
-            full!(v.visit_expr_type(_binding_0));
-        }
-        Expr::Unary(_binding_0) => {
-            v.visit_expr_unary(_binding_0);
-        }
-        Expr::Unsafe(_binding_0) => {
-            full!(v.visit_expr_unsafe(_binding_0));
-        }
-        Expr::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        Expr::While(_binding_0) => {
-            full!(v.visit_expr_while(_binding_0));
-        }
-        Expr::Yield(_binding_0) => {
-            full!(v.visit_expr_yield(_binding_0));
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_array<'ast, V>(v: &mut V, node: &'ast ExprArray)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.bracket_token.span);
-    for el in Punctuated::pairs(&node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_assign<'ast, V>(v: &mut V, node: &'ast ExprAssign)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.left);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_expr(&*node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_assign_op<'ast, V>(v: &mut V, node: &'ast ExprAssignOp)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.left);
-    v.visit_bin_op(&node.op);
-    v.visit_expr(&*node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_async<'ast, V>(v: &mut V, node: &'ast ExprAsync)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.async_token.span);
-    if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_block(&node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_await<'ast, V>(v: &mut V, node: &'ast ExprAwait)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.base);
-    tokens_helper(v, &node.dot_token.spans);
-    tokens_helper(v, &node.await_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast ExprBinary)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.left);
-    v.visit_bin_op(&node.op);
-    v.visit_expr(&*node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_block<'ast, V>(v: &mut V, node: &'ast ExprBlock)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.label {
-        v.visit_label(it);
-    };
-    v.visit_block(&node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_box<'ast, V>(v: &mut V, node: &'ast ExprBox)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.box_token.span);
-    v.visit_expr(&*node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_break<'ast, V>(v: &mut V, node: &'ast ExprBreak)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.break_token.span);
-    if let Some(it) = &node.label {
-        v.visit_lifetime(it);
-    };
-    if let Some(it) = &node.expr {
-        v.visit_expr(&**it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_call<'ast, V>(v: &mut V, node: &'ast ExprCall)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.func);
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_cast<'ast, V>(v: &mut V, node: &'ast ExprCast)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.as_token.span);
-    v.visit_type(&*node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_closure<'ast, V>(v: &mut V, node: &'ast ExprClosure)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.movability {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.or1_token.spans);
-    for el in Punctuated::pairs(&node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.or2_token.spans);
-    v.visit_return_type(&node.output);
-    v.visit_expr(&*node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_continue<'ast, V>(v: &mut V, node: &'ast ExprContinue)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.continue_token.span);
-    if let Some(it) = &node.label {
-        v.visit_lifetime(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_field<'ast, V>(v: &mut V, node: &'ast ExprField)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.base);
-    tokens_helper(v, &node.dot_token.spans);
-    v.visit_member(&node.member);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_for_loop<'ast, V>(v: &mut V, node: &'ast ExprForLoop)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.label {
-        v.visit_label(it);
-    };
-    tokens_helper(v, &node.for_token.span);
-    v.visit_pat(&node.pat);
-    tokens_helper(v, &node.in_token.span);
-    v.visit_expr(&*node.expr);
-    v.visit_block(&node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_group<'ast, V>(v: &mut V, node: &'ast ExprGroup)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.group_token.span);
-    v.visit_expr(&*node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_if<'ast, V>(v: &mut V, node: &'ast ExprIf)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.if_token.span);
-    v.visit_expr(&*node.cond);
-    v.visit_block(&node.then_branch);
-    if let Some(it) = &node.else_branch {
-        tokens_helper(v, &(it).0.span);
-        v.visit_expr(&*(it).1);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_index<'ast, V>(v: &mut V, node: &'ast ExprIndex)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.bracket_token.span);
-    v.visit_expr(&*node.index);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_let<'ast, V>(v: &mut V, node: &'ast ExprLet)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.let_token.span);
-    v.visit_pat(&node.pat);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_expr(&*node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_lit<'ast, V>(v: &mut V, node: &'ast ExprLit)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_lit(&node.lit);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_loop<'ast, V>(v: &mut V, node: &'ast ExprLoop)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.label {
-        v.visit_label(it);
-    };
-    tokens_helper(v, &node.loop_token.span);
-    v.visit_block(&node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_macro<'ast, V>(v: &mut V, node: &'ast ExprMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_macro(&node.mac);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_match<'ast, V>(v: &mut V, node: &'ast ExprMatch)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.match_token.span);
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.brace_token.span);
-    for it in &node.arms {
-        v.visit_arm(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_method_call<'ast, V>(v: &mut V, node: &'ast ExprMethodCall)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.receiver);
-    tokens_helper(v, &node.dot_token.spans);
-    v.visit_ident(&node.method);
-    if let Some(it) = &node.turbofish {
-        v.visit_method_turbofish(it);
-    };
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_paren<'ast, V>(v: &mut V, node: &'ast ExprParen)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.paren_token.span);
-    v.visit_expr(&*node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_path<'ast, V>(v: &mut V, node: &'ast ExprPath)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.qself {
-        v.visit_qself(it);
-    };
-    v.visit_path(&node.path);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_range<'ast, V>(v: &mut V, node: &'ast ExprRange)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.from {
-        v.visit_expr(&**it);
-    };
-    v.visit_range_limits(&node.limits);
-    if let Some(it) = &node.to {
-        v.visit_expr(&**it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_reference<'ast, V>(v: &mut V, node: &'ast ExprReference)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.and_token.spans);
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_expr(&*node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_repeat<'ast, V>(v: &mut V, node: &'ast ExprRepeat)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.bracket_token.span);
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.semi_token.spans);
-    v.visit_expr(&*node.len);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_return<'ast, V>(v: &mut V, node: &'ast ExprReturn)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.return_token.span);
-    if let Some(it) = &node.expr {
-        v.visit_expr(&**it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_struct<'ast, V>(v: &mut V, node: &'ast ExprStruct)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_path(&node.path);
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.fields) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_value(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans);
-    };
-    if let Some(it) = &node.rest {
-        v.visit_expr(&**it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_try<'ast, V>(v: &mut V, node: &'ast ExprTry)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.question_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_try_block<'ast, V>(v: &mut V, node: &'ast ExprTryBlock)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.try_token.span);
-    v.visit_block(&node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_tuple<'ast, V>(v: &mut V, node: &'ast ExprTuple)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_type<'ast, V>(v: &mut V, node: &'ast ExprType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&*node.ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_unary<'ast, V>(v: &mut V, node: &'ast ExprUnary)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_un_op(&node.op);
-    v.visit_expr(&*node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_unsafe<'ast, V>(v: &mut V, node: &'ast ExprUnsafe)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.unsafe_token.span);
-    v.visit_block(&node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_while<'ast, V>(v: &mut V, node: &'ast ExprWhile)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.label {
-        v.visit_label(it);
-    };
-    tokens_helper(v, &node.while_token.span);
-    v.visit_expr(&*node.cond);
-    v.visit_block(&node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_yield<'ast, V>(v: &mut V, node: &'ast ExprYield)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.yield_token.span);
-    if let Some(it) = &node.expr {
-        v.visit_expr(&**it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_field<'ast, V>(v: &mut V, node: &'ast Field)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    if let Some(it) = &node.ident {
-        v.visit_ident(it);
-    };
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    v.visit_type(&node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_field_pat<'ast, V>(v: &mut V, node: &'ast FieldPat)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_member(&node.member);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    v.visit_pat(&*node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_field_value<'ast, V>(v: &mut V, node: &'ast FieldValue)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_member(&node.member);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    v.visit_expr(&node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields<'ast, V>(v: &mut V, node: &'ast Fields)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Fields::Named(_binding_0) => {
-            v.visit_fields_named(_binding_0);
-        }
-        Fields::Unnamed(_binding_0) => {
-            v.visit_fields_unnamed(_binding_0);
-        }
-        Fields::Unit => {}
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields_named<'ast, V>(v: &mut V, node: &'ast FieldsNamed)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.named) {
-        let (it, p) = el.into_tuple();
-        v.visit_field(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields_unnamed<'ast, V>(v: &mut V, node: &'ast FieldsUnnamed)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.unnamed) {
-        let (it, p) = el.into_tuple();
-        v.visit_field(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_file<'ast, V>(v: &mut V, node: &'ast File)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    skip!(node.shebang);
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    for it in &node.items {
-        v.visit_item(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_fn_arg<'ast, V>(v: &mut V, node: &'ast FnArg)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        FnArg::Receiver(_binding_0) => {
-            v.visit_receiver(_binding_0);
-        }
-        FnArg::Typed(_binding_0) => {
-            v.visit_pat_type(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item<'ast, V>(v: &mut V, node: &'ast ForeignItem)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        ForeignItem::Fn(_binding_0) => {
-            v.visit_foreign_item_fn(_binding_0);
-        }
-        ForeignItem::Static(_binding_0) => {
-            v.visit_foreign_item_static(_binding_0);
-        }
-        ForeignItem::Type(_binding_0) => {
-            v.visit_foreign_item_type(_binding_0);
-        }
-        ForeignItem::Macro(_binding_0) => {
-            v.visit_foreign_item_macro(_binding_0);
-        }
-        ForeignItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_fn<'ast, V>(v: &mut V, node: &'ast ForeignItemFn)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    v.visit_signature(&node.sig);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_macro<'ast, V>(v: &mut V, node: &'ast ForeignItemMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_macro(&node.mac);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_static<'ast, V>(v: &mut V, node: &'ast ForeignItemStatic)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.static_token.span);
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&*node.ty);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_type<'ast, V>(v: &mut V, node: &'ast ForeignItemType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.type_token.span);
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generic_argument<'ast, V>(v: &mut V, node: &'ast GenericArgument)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        GenericArgument::Lifetime(_binding_0) => {
-            v.visit_lifetime(_binding_0);
-        }
-        GenericArgument::Type(_binding_0) => {
-            v.visit_type(_binding_0);
-        }
-        GenericArgument::Binding(_binding_0) => {
-            v.visit_binding(_binding_0);
-        }
-        GenericArgument::Constraint(_binding_0) => {
-            v.visit_constraint(_binding_0);
-        }
-        GenericArgument::Const(_binding_0) => {
-            v.visit_expr(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_generic_method_argument<'ast, V>(v: &mut V, node: &'ast GenericMethodArgument)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        GenericMethodArgument::Type(_binding_0) => {
-            v.visit_type(_binding_0);
-        }
-        GenericMethodArgument::Const(_binding_0) => {
-            v.visit_expr(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generic_param<'ast, V>(v: &mut V, node: &'ast GenericParam)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        GenericParam::Type(_binding_0) => {
-            v.visit_type_param(_binding_0);
-        }
-        GenericParam::Lifetime(_binding_0) => {
-            v.visit_lifetime_def(_binding_0);
-        }
-        GenericParam::Const(_binding_0) => {
-            v.visit_const_param(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generics<'ast, V>(v: &mut V, node: &'ast Generics)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.lt_token {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.params) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_param(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.gt_token {
-        tokens_helper(v, &it.spans);
-    };
-    if let Some(it) = &node.where_clause {
-        v.visit_where_clause(it);
-    };
-}
-pub fn visit_ident<'ast, V>(v: &mut V, node: &'ast Ident)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_span(&node.span());
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item<'ast, V>(v: &mut V, node: &'ast ImplItem)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        ImplItem::Const(_binding_0) => {
-            v.visit_impl_item_const(_binding_0);
-        }
-        ImplItem::Method(_binding_0) => {
-            v.visit_impl_item_method(_binding_0);
-        }
-        ImplItem::Type(_binding_0) => {
-            v.visit_impl_item_type(_binding_0);
-        }
-        ImplItem::Macro(_binding_0) => {
-            v.visit_impl_item_macro(_binding_0);
-        }
-        ImplItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_const<'ast, V>(v: &mut V, node: &'ast ImplItemConst)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.const_token.span);
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&node.ty);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_expr(&node.expr);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_macro<'ast, V>(v: &mut V, node: &'ast ImplItemMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_macro(&node.mac);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_method<'ast, V>(v: &mut V, node: &'ast ImplItemMethod)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_signature(&node.sig);
-    v.visit_block(&node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_type<'ast, V>(v: &mut V, node: &'ast ImplItemType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.type_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_type(&node.ty);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_index<'ast, V>(v: &mut V, node: &'ast Index)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    skip!(node.index);
-    v.visit_span(&node.span);
-}
-#[cfg(feature = "full")]
-pub fn visit_item<'ast, V>(v: &mut V, node: &'ast Item)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Item::Const(_binding_0) => {
-            v.visit_item_const(_binding_0);
-        }
-        Item::Enum(_binding_0) => {
-            v.visit_item_enum(_binding_0);
-        }
-        Item::ExternCrate(_binding_0) => {
-            v.visit_item_extern_crate(_binding_0);
-        }
-        Item::Fn(_binding_0) => {
-            v.visit_item_fn(_binding_0);
-        }
-        Item::ForeignMod(_binding_0) => {
-            v.visit_item_foreign_mod(_binding_0);
-        }
-        Item::Impl(_binding_0) => {
-            v.visit_item_impl(_binding_0);
-        }
-        Item::Macro(_binding_0) => {
-            v.visit_item_macro(_binding_0);
-        }
-        Item::Macro2(_binding_0) => {
-            v.visit_item_macro2(_binding_0);
-        }
-        Item::Mod(_binding_0) => {
-            v.visit_item_mod(_binding_0);
-        }
-        Item::Static(_binding_0) => {
-            v.visit_item_static(_binding_0);
-        }
-        Item::Struct(_binding_0) => {
-            v.visit_item_struct(_binding_0);
-        }
-        Item::Trait(_binding_0) => {
-            v.visit_item_trait(_binding_0);
-        }
-        Item::TraitAlias(_binding_0) => {
-            v.visit_item_trait_alias(_binding_0);
-        }
-        Item::Type(_binding_0) => {
-            v.visit_item_type(_binding_0);
-        }
-        Item::Union(_binding_0) => {
-            v.visit_item_union(_binding_0);
-        }
-        Item::Use(_binding_0) => {
-            v.visit_item_use(_binding_0);
-        }
-        Item::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_const<'ast, V>(v: &mut V, node: &'ast ItemConst)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.const_token.span);
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&*node.ty);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_enum<'ast, V>(v: &mut V, node: &'ast ItemEnum)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.enum_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.variants) {
-        let (it, p) = el.into_tuple();
-        v.visit_variant(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_extern_crate<'ast, V>(v: &mut V, node: &'ast ItemExternCrate)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.extern_token.span);
-    tokens_helper(v, &node.crate_token.span);
-    v.visit_ident(&node.ident);
-    if let Some(it) = &node.rename {
-        tokens_helper(v, &(it).0.span);
-        v.visit_ident(&(it).1);
-    };
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_fn<'ast, V>(v: &mut V, node: &'ast ItemFn)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    v.visit_signature(&node.sig);
-    v.visit_block(&*node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_foreign_mod<'ast, V>(v: &mut V, node: &'ast ItemForeignMod)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_abi(&node.abi);
-    tokens_helper(v, &node.brace_token.span);
-    for it in &node.items {
-        v.visit_foreign_item(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_impl<'ast, V>(v: &mut V, node: &'ast ItemImpl)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.impl_token.span);
-    v.visit_generics(&node.generics);
-    if let Some(it) = &node.trait_ {
-        if let Some(it) = &(it).0 {
-            tokens_helper(v, &it.spans);
-        };
-        v.visit_path(&(it).1);
-        tokens_helper(v, &(it).2.span);
-    };
-    v.visit_type(&*node.self_ty);
-    tokens_helper(v, &node.brace_token.span);
-    for it in &node.items {
-        v.visit_impl_item(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_macro<'ast, V>(v: &mut V, node: &'ast ItemMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.ident {
-        v.visit_ident(it);
-    };
-    v.visit_macro(&node.mac);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_macro2<'ast, V>(v: &mut V, node: &'ast ItemMacro2)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.macro_token.span);
-    v.visit_ident(&node.ident);
-    skip!(node.rules);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_mod<'ast, V>(v: &mut V, node: &'ast ItemMod)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.mod_token.span);
-    v.visit_ident(&node.ident);
-    if let Some(it) = &node.content {
-        tokens_helper(v, &(it).0.span);
-        for it in &(it).1 {
-            v.visit_item(it);
-        }
-    };
-    if let Some(it) = &node.semi {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_static<'ast, V>(v: &mut V, node: &'ast ItemStatic)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.static_token.span);
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&*node.ty);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_expr(&*node.expr);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_struct<'ast, V>(v: &mut V, node: &'ast ItemStruct)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.struct_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    v.visit_fields(&node.fields);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_trait<'ast, V>(v: &mut V, node: &'ast ItemTrait)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.auto_token {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.trait_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.supertraits) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.brace_token.span);
-    for it in &node.items {
-        v.visit_trait_item(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_trait_alias<'ast, V>(v: &mut V, node: &'ast ItemTraitAlias)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.trait_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    tokens_helper(v, &node.eq_token.spans);
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_type<'ast, V>(v: &mut V, node: &'ast ItemType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.type_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_type(&*node.ty);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_union<'ast, V>(v: &mut V, node: &'ast ItemUnion)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.union_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    v.visit_fields_named(&node.fields);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_use<'ast, V>(v: &mut V, node: &'ast ItemUse)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_visibility(&node.vis);
-    tokens_helper(v, &node.use_token.span);
-    if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans);
-    };
-    v.visit_use_tree(&node.tree);
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_label<'ast, V>(v: &mut V, node: &'ast Label)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_lifetime(&node.name);
-    tokens_helper(v, &node.colon_token.spans);
-}
-pub fn visit_lifetime<'ast, V>(v: &mut V, node: &'ast Lifetime)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_span(&node.apostrophe);
-    v.visit_ident(&node.ident);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_lifetime_def<'ast, V>(v: &mut V, node: &'ast LifetimeDef)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_lifetime(&node.lifetime);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-pub fn visit_lit<'ast, V>(v: &mut V, node: &'ast Lit)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Lit::Str(_binding_0) => {
-            v.visit_lit_str(_binding_0);
-        }
-        Lit::ByteStr(_binding_0) => {
-            v.visit_lit_byte_str(_binding_0);
-        }
-        Lit::Byte(_binding_0) => {
-            v.visit_lit_byte(_binding_0);
-        }
-        Lit::Char(_binding_0) => {
-            v.visit_lit_char(_binding_0);
-        }
-        Lit::Int(_binding_0) => {
-            v.visit_lit_int(_binding_0);
-        }
-        Lit::Float(_binding_0) => {
-            v.visit_lit_float(_binding_0);
-        }
-        Lit::Bool(_binding_0) => {
-            v.visit_lit_bool(_binding_0);
-        }
-        Lit::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-    }
-}
-pub fn visit_lit_bool<'ast, V>(v: &mut V, node: &'ast LitBool)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    skip!(node.value);
-    v.visit_span(&node.span);
-}
-pub fn visit_lit_byte<'ast, V>(v: &mut V, node: &'ast LitByte)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-pub fn visit_lit_byte_str<'ast, V>(v: &mut V, node: &'ast LitByteStr)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-pub fn visit_lit_char<'ast, V>(v: &mut V, node: &'ast LitChar)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-pub fn visit_lit_float<'ast, V>(v: &mut V, node: &'ast LitFloat)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-pub fn visit_lit_int<'ast, V>(v: &mut V, node: &'ast LitInt)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-pub fn visit_lit_str<'ast, V>(v: &mut V, node: &'ast LitStr)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-#[cfg(feature = "full")]
-pub fn visit_local<'ast, V>(v: &mut V, node: &'ast Local)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.let_token.span);
-    v.visit_pat(&node.pat);
-    if let Some(it) = &node.init {
-        tokens_helper(v, &(it).0.spans);
-        v.visit_expr(&*(it).1);
-    };
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_macro<'ast, V>(v: &mut V, node: &'ast Macro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_path(&node.path);
-    tokens_helper(v, &node.bang_token.spans);
-    v.visit_macro_delimiter(&node.delimiter);
-    skip!(node.tokens);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_macro_delimiter<'ast, V>(v: &mut V, node: &'ast MacroDelimiter)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        MacroDelimiter::Paren(_binding_0) => {
-            tokens_helper(v, &_binding_0.span);
-        }
-        MacroDelimiter::Brace(_binding_0) => {
-            tokens_helper(v, &_binding_0.span);
-        }
-        MacroDelimiter::Bracket(_binding_0) => {
-            tokens_helper(v, &_binding_0.span);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_member<'ast, V>(v: &mut V, node: &'ast Member)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Member::Named(_binding_0) => {
-            v.visit_ident(_binding_0);
-        }
-        Member::Unnamed(_binding_0) => {
-            v.visit_index(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta<'ast, V>(v: &mut V, node: &'ast Meta)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Meta::Path(_binding_0) => {
-            v.visit_path(_binding_0);
-        }
-        Meta::List(_binding_0) => {
-            v.visit_meta_list(_binding_0);
-        }
-        Meta::NameValue(_binding_0) => {
-            v.visit_meta_name_value(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta_list<'ast, V>(v: &mut V, node: &'ast MetaList)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_path(&node.path);
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.nested) {
-        let (it, p) = el.into_tuple();
-        v.visit_nested_meta(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta_name_value<'ast, V>(v: &mut V, node: &'ast MetaNameValue)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_path(&node.path);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_lit(&node.lit);
-}
-#[cfg(feature = "full")]
-pub fn visit_method_turbofish<'ast, V>(v: &mut V, node: &'ast MethodTurbofish)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.colon2_token.spans);
-    tokens_helper(v, &node.lt_token.spans);
-    for el in Punctuated::pairs(&node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_method_argument(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    tokens_helper(v, &node.gt_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_nested_meta<'ast, V>(v: &mut V, node: &'ast NestedMeta)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        NestedMeta::Meta(_binding_0) => {
-            v.visit_meta(_binding_0);
-        }
-        NestedMeta::Lit(_binding_0) => {
-            v.visit_lit(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_parenthesized_generic_arguments<'ast, V>(
-    v: &mut V,
-    node: &'ast ParenthesizedGenericArguments,
-) where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_type(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    v.visit_return_type(&node.output);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat<'ast, V>(v: &mut V, node: &'ast Pat)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Pat::Box(_binding_0) => {
-            v.visit_pat_box(_binding_0);
-        }
-        Pat::Ident(_binding_0) => {
-            v.visit_pat_ident(_binding_0);
-        }
-        Pat::Lit(_binding_0) => {
-            v.visit_pat_lit(_binding_0);
-        }
-        Pat::Macro(_binding_0) => {
-            v.visit_pat_macro(_binding_0);
-        }
-        Pat::Or(_binding_0) => {
-            v.visit_pat_or(_binding_0);
-        }
-        Pat::Path(_binding_0) => {
-            v.visit_pat_path(_binding_0);
-        }
-        Pat::Range(_binding_0) => {
-            v.visit_pat_range(_binding_0);
-        }
-        Pat::Reference(_binding_0) => {
-            v.visit_pat_reference(_binding_0);
-        }
-        Pat::Rest(_binding_0) => {
-            v.visit_pat_rest(_binding_0);
-        }
-        Pat::Slice(_binding_0) => {
-            v.visit_pat_slice(_binding_0);
-        }
-        Pat::Struct(_binding_0) => {
-            v.visit_pat_struct(_binding_0);
-        }
-        Pat::Tuple(_binding_0) => {
-            v.visit_pat_tuple(_binding_0);
-        }
-        Pat::TupleStruct(_binding_0) => {
-            v.visit_pat_tuple_struct(_binding_0);
-        }
-        Pat::Type(_binding_0) => {
-            v.visit_pat_type(_binding_0);
-        }
-        Pat::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        Pat::Wild(_binding_0) => {
-            v.visit_pat_wild(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_box<'ast, V>(v: &mut V, node: &'ast PatBox)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.box_token.span);
-    v.visit_pat(&*node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_ident<'ast, V>(v: &mut V, node: &'ast PatIdent)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.by_ref {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_ident(&node.ident);
-    if let Some(it) = &node.subpat {
-        tokens_helper(v, &(it).0.spans);
-        v.visit_pat(&*(it).1);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_lit<'ast, V>(v: &mut V, node: &'ast PatLit)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_macro<'ast, V>(v: &mut V, node: &'ast PatMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_macro(&node.mac);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_or<'ast, V>(v: &mut V, node: &'ast PatOr)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.leading_vert {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.cases) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_path<'ast, V>(v: &mut V, node: &'ast PatPath)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.qself {
-        v.visit_qself(it);
-    };
-    v.visit_path(&node.path);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_range<'ast, V>(v: &mut V, node: &'ast PatRange)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_expr(&*node.lo);
-    v.visit_range_limits(&node.limits);
-    v.visit_expr(&*node.hi);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_reference<'ast, V>(v: &mut V, node: &'ast PatReference)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.and_token.spans);
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_pat(&*node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_rest<'ast, V>(v: &mut V, node: &'ast PatRest)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.dot2_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_slice<'ast, V>(v: &mut V, node: &'ast PatSlice)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.bracket_token.span);
-    for el in Punctuated::pairs(&node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_struct<'ast, V>(v: &mut V, node: &'ast PatStruct)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_path(&node.path);
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.fields) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_pat(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_tuple<'ast, V>(v: &mut V, node: &'ast PatTuple)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_tuple_struct<'ast, V>(v: &mut V, node: &'ast PatTupleStruct)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_path(&node.path);
-    v.visit_pat_tuple(&node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_type<'ast, V>(v: &mut V, node: &'ast PatType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_pat(&*node.pat);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&*node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_wild<'ast, V>(v: &mut V, node: &'ast PatWild)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.underscore_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path<'ast, V>(v: &mut V, node: &'ast Path)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.segments) {
-        let (it, p) = el.into_tuple();
-        v.visit_path_segment(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path_arguments<'ast, V>(v: &mut V, node: &'ast PathArguments)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        PathArguments::None => {}
-        PathArguments::AngleBracketed(_binding_0) => {
-            v.visit_angle_bracketed_generic_arguments(_binding_0);
-        }
-        PathArguments::Parenthesized(_binding_0) => {
-            v.visit_parenthesized_generic_arguments(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path_segment<'ast, V>(v: &mut V, node: &'ast PathSegment)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-    v.visit_path_arguments(&node.arguments);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_eq<'ast, V>(v: &mut V, node: &'ast PredicateEq)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_type(&node.lhs_ty);
-    tokens_helper(v, &node.eq_token.spans);
-    v.visit_type(&node.rhs_ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_lifetime<'ast, V>(v: &mut V, node: &'ast PredicateLifetime)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_lifetime(&node.lifetime);
-    tokens_helper(v, &node.colon_token.spans);
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_type<'ast, V>(v: &mut V, node: &'ast PredicateType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it);
-    };
-    v.visit_type(&node.bounded_ty);
-    tokens_helper(v, &node.colon_token.spans);
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_qself<'ast, V>(v: &mut V, node: &'ast QSelf)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.lt_token.spans);
-    v.visit_type(&*node.ty);
-    skip!(node.position);
-    if let Some(it) = &node.as_token {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.gt_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_range_limits<'ast, V>(v: &mut V, node: &'ast RangeLimits)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        RangeLimits::HalfOpen(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        RangeLimits::Closed(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_receiver<'ast, V>(v: &mut V, node: &'ast Receiver)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    if let Some(it) = &node.reference {
-        tokens_helper(v, &(it).0.spans);
-        if let Some(it) = &(it).1 {
-            v.visit_lifetime(it);
-        };
-    };
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    tokens_helper(v, &node.self_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_return_type<'ast, V>(v: &mut V, node: &'ast ReturnType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        ReturnType::Default => {}
-        ReturnType::Type(_binding_0, _binding_1) => {
-            tokens_helper(v, &_binding_0.spans);
-            v.visit_type(&**_binding_1);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_signature<'ast, V>(v: &mut V, node: &'ast Signature)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.constness {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.abi {
-        v.visit_abi(it);
-    };
-    tokens_helper(v, &node.fn_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_fn_arg(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.variadic {
-        v.visit_variadic(it);
-    };
-    v.visit_return_type(&node.output);
-}
-pub fn visit_span<'ast, V>(v: &mut V, node: &Span)
-where
-    V: Visit<'ast> + ?Sized,
-{
-}
-#[cfg(feature = "full")]
-pub fn visit_stmt<'ast, V>(v: &mut V, node: &'ast Stmt)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Stmt::Local(_binding_0) => {
-            v.visit_local(_binding_0);
-        }
-        Stmt::Item(_binding_0) => {
-            v.visit_item(_binding_0);
-        }
-        Stmt::Expr(_binding_0) => {
-            v.visit_expr(_binding_0);
-        }
-        Stmt::Semi(_binding_0, _binding_1) => {
-            v.visit_expr(_binding_0);
-            tokens_helper(v, &_binding_1.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_trait_bound<'ast, V>(v: &mut V, node: &'ast TraitBound)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.paren_token {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_trait_bound_modifier(&node.modifier);
-    if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it);
-    };
-    v.visit_path(&node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_trait_bound_modifier<'ast, V>(v: &mut V, node: &'ast TraitBoundModifier)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        TraitBoundModifier::None => {}
-        TraitBoundModifier::Maybe(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item<'ast, V>(v: &mut V, node: &'ast TraitItem)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        TraitItem::Const(_binding_0) => {
-            v.visit_trait_item_const(_binding_0);
-        }
-        TraitItem::Method(_binding_0) => {
-            v.visit_trait_item_method(_binding_0);
-        }
-        TraitItem::Type(_binding_0) => {
-            v.visit_trait_item_type(_binding_0);
-        }
-        TraitItem::Macro(_binding_0) => {
-            v.visit_trait_item_macro(_binding_0);
-        }
-        TraitItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_const<'ast, V>(v: &mut V, node: &'ast TraitItemConst)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.const_token.span);
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon_token.spans);
-    v.visit_type(&node.ty);
-    if let Some(it) = &node.default {
-        tokens_helper(v, &(it).0.spans);
-        v.visit_expr(&(it).1);
-    };
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_macro<'ast, V>(v: &mut V, node: &'ast TraitItemMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_macro(&node.mac);
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_method<'ast, V>(v: &mut V, node: &'ast TraitItemMethod)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_signature(&node.sig);
-    if let Some(it) = &node.default {
-        v.visit_block(it);
-    };
-    if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_type<'ast, V>(v: &mut V, node: &'ast TraitItemType)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.type_token.span);
-    v.visit_ident(&node.ident);
-    v.visit_generics(&node.generics);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.default {
-        tokens_helper(v, &(it).0.spans);
-        v.visit_type(&(it).1);
-    };
-    tokens_helper(v, &node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type<'ast, V>(v: &mut V, node: &'ast Type)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Type::Array(_binding_0) => {
-            v.visit_type_array(_binding_0);
-        }
-        Type::BareFn(_binding_0) => {
-            v.visit_type_bare_fn(_binding_0);
-        }
-        Type::Group(_binding_0) => {
-            v.visit_type_group(_binding_0);
-        }
-        Type::ImplTrait(_binding_0) => {
-            v.visit_type_impl_trait(_binding_0);
-        }
-        Type::Infer(_binding_0) => {
-            v.visit_type_infer(_binding_0);
-        }
-        Type::Macro(_binding_0) => {
-            v.visit_type_macro(_binding_0);
-        }
-        Type::Never(_binding_0) => {
-            v.visit_type_never(_binding_0);
-        }
-        Type::Paren(_binding_0) => {
-            v.visit_type_paren(_binding_0);
-        }
-        Type::Path(_binding_0) => {
-            v.visit_type_path(_binding_0);
-        }
-        Type::Ptr(_binding_0) => {
-            v.visit_type_ptr(_binding_0);
-        }
-        Type::Reference(_binding_0) => {
-            v.visit_type_reference(_binding_0);
-        }
-        Type::Slice(_binding_0) => {
-            v.visit_type_slice(_binding_0);
-        }
-        Type::TraitObject(_binding_0) => {
-            v.visit_type_trait_object(_binding_0);
-        }
-        Type::Tuple(_binding_0) => {
-            v.visit_type_tuple(_binding_0);
-        }
-        Type::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_array<'ast, V>(v: &mut V, node: &'ast TypeArray)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.bracket_token.span);
-    v.visit_type(&*node.elem);
-    tokens_helper(v, &node.semi_token.spans);
-    v.visit_expr(&node.len);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_bare_fn<'ast, V>(v: &mut V, node: &'ast TypeBareFn)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it);
-    };
-    if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.abi {
-        v.visit_abi(it);
-    };
-    tokens_helper(v, &node.fn_token.span);
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_bare_fn_arg(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.variadic {
-        v.visit_variadic(it);
-    };
-    v.visit_return_type(&node.output);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_group<'ast, V>(v: &mut V, node: &'ast TypeGroup)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.group_token.span);
-    v.visit_type(&*node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_impl_trait<'ast, V>(v: &mut V, node: &'ast TypeImplTrait)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.impl_token.span);
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_infer<'ast, V>(v: &mut V, node: &'ast TypeInfer)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.underscore_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_macro<'ast, V>(v: &mut V, node: &'ast TypeMacro)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_macro(&node.mac);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_never<'ast, V>(v: &mut V, node: &'ast TypeNever)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.bang_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_param<'ast, V>(v: &mut V, node: &'ast TypeParam)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_ident(&node.ident);
-    if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans);
-    };
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-    if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans);
-    };
-    if let Some(it) = &node.default {
-        v.visit_type(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_param_bound<'ast, V>(v: &mut V, node: &'ast TypeParamBound)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        TypeParamBound::Trait(_binding_0) => {
-            v.visit_trait_bound(_binding_0);
-        }
-        TypeParamBound::Lifetime(_binding_0) => {
-            v.visit_lifetime(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_paren<'ast, V>(v: &mut V, node: &'ast TypeParen)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.paren_token.span);
-    v.visit_type(&*node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_path<'ast, V>(v: &mut V, node: &'ast TypePath)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.qself {
-        v.visit_qself(it);
-    };
-    v.visit_path(&node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_ptr<'ast, V>(v: &mut V, node: &'ast TypePtr)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.star_token.spans);
-    if let Some(it) = &node.const_token {
-        tokens_helper(v, &it.span);
-    };
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_type(&*node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_reference<'ast, V>(v: &mut V, node: &'ast TypeReference)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.and_token.spans);
-    if let Some(it) = &node.lifetime {
-        v.visit_lifetime(it);
-    };
-    if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_type(&*node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_slice<'ast, V>(v: &mut V, node: &'ast TypeSlice)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.bracket_token.span);
-    v.visit_type(&*node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_trait_object<'ast, V>(v: &mut V, node: &'ast TypeTraitObject)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    if let Some(it) = &node.dyn_token {
-        tokens_helper(v, &it.span);
-    };
-    for el in Punctuated::pairs(&node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_tuple<'ast, V>(v: &mut V, node: &'ast TypeTuple)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.paren_token.span);
-    for el in Punctuated::pairs(&node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_type(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_un_op<'ast, V>(v: &mut V, node: &'ast UnOp)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        UnOp::Deref(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        UnOp::Not(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-        UnOp::Neg(_binding_0) => {
-            tokens_helper(v, &_binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_use_glob<'ast, V>(v: &mut V, node: &'ast UseGlob)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.star_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_group<'ast, V>(v: &mut V, node: &'ast UseGroup)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.brace_token.span);
-    for el in Punctuated::pairs(&node.items) {
-        let (it, p) = el.into_tuple();
-        v.visit_use_tree(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_use_name<'ast, V>(v: &mut V, node: &'ast UseName)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_path<'ast, V>(v: &mut V, node: &'ast UsePath)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.colon2_token.spans);
-    v.visit_use_tree(&*node.tree);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_rename<'ast, V>(v: &mut V, node: &'ast UseRename)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    v.visit_ident(&node.ident);
-    tokens_helper(v, &node.as_token.span);
-    v.visit_ident(&node.rename);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_tree<'ast, V>(v: &mut V, node: &'ast UseTree)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        UseTree::Path(_binding_0) => {
-            v.visit_use_path(_binding_0);
-        }
-        UseTree::Name(_binding_0) => {
-            v.visit_use_name(_binding_0);
-        }
-        UseTree::Rename(_binding_0) => {
-            v.visit_use_rename(_binding_0);
-        }
-        UseTree::Glob(_binding_0) => {
-            v.visit_use_glob(_binding_0);
-        }
-        UseTree::Group(_binding_0) => {
-            v.visit_use_group(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_variadic<'ast, V>(v: &mut V, node: &'ast Variadic)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    tokens_helper(v, &node.dots.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_variant<'ast, V>(v: &mut V, node: &'ast Variant)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    for it in &node.attrs {
-        v.visit_attribute(it);
-    }
-    v.visit_ident(&node.ident);
-    v.visit_fields(&node.fields);
-    if let Some(it) = &node.discriminant {
-        tokens_helper(v, &(it).0.spans);
-        v.visit_expr(&(it).1);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_crate<'ast, V>(v: &mut V, node: &'ast VisCrate)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.crate_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_public<'ast, V>(v: &mut V, node: &'ast VisPublic)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.pub_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_restricted<'ast, V>(v: &mut V, node: &'ast VisRestricted)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.pub_token.span);
-    tokens_helper(v, &node.paren_token.span);
-    if let Some(it) = &node.in_token {
-        tokens_helper(v, &it.span);
-    };
-    v.visit_path(&*node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_visibility<'ast, V>(v: &mut V, node: &'ast Visibility)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        Visibility::Public(_binding_0) => {
-            v.visit_vis_public(_binding_0);
-        }
-        Visibility::Crate(_binding_0) => {
-            v.visit_vis_crate(_binding_0);
-        }
-        Visibility::Restricted(_binding_0) => {
-            v.visit_vis_restricted(_binding_0);
-        }
-        Visibility::Inherited => {}
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_where_clause<'ast, V>(v: &mut V, node: &'ast WhereClause)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    tokens_helper(v, &node.where_token.span);
-    for el in Punctuated::pairs(&node.predicates) {
-        let (it, p) = el.into_tuple();
-        v.visit_where_predicate(it);
-        if let Some(p) = p {
-            tokens_helper(v, &p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_where_predicate<'ast, V>(v: &mut V, node: &'ast WherePredicate)
-where
-    V: Visit<'ast> + ?Sized,
-{
-    match node {
-        WherePredicate::Type(_binding_0) => {
-            v.visit_predicate_type(_binding_0);
-        }
-        WherePredicate::Lifetime(_binding_0) => {
-            v.visit_predicate_lifetime(_binding_0);
-        }
-        WherePredicate::Eq(_binding_0) => {
-            v.visit_predicate_eq(_binding_0);
-        }
-    }
-}
diff --git a/vendor/syn/src/gen/visit_mut.rs b/vendor/syn/src/gen/visit_mut.rs
deleted file mode 100644
index 1de0c95e..00000000
--- a/vendor/syn/src/gen/visit_mut.rs
+++ /dev/null
@@ -1,3781 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#![allow(unused_variables)]
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::gen::helper::visit_mut::*;
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::punctuated::Punctuated;
-use crate::*;
-use proc_macro2::Span;
-#[cfg(feature = "full")]
-macro_rules! full {
-    ($e:expr) => {
-        $e
-    };
-}
-#[cfg(all(feature = "derive", not(feature = "full")))]
-macro_rules! full {
-    ($e:expr) => {
-        unreachable!()
-    };
-}
-macro_rules! skip {
-    ($($tt:tt)*) => {};
-}
-/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in
-/// place.
-///
-/// See the [module documentation] for details.
-///
-/// [module documentation]: self
-///
-/// *This trait is available only if Syn is built with the `"visit-mut"` feature.*
-pub trait VisitMut {
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_abi_mut(&mut self, i: &mut Abi) {
-        visit_abi_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_angle_bracketed_generic_arguments_mut(
-        &mut self,
-        i: &mut AngleBracketedGenericArguments,
-    ) {
-        visit_angle_bracketed_generic_arguments_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_arm_mut(&mut self, i: &mut Arm) {
-        visit_arm_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) {
-        visit_attr_style_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_attribute_mut(&mut self, i: &mut Attribute) {
-        visit_attribute_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) {
-        visit_bare_fn_arg_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bin_op_mut(&mut self, i: &mut BinOp) {
-        visit_bin_op_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_binding_mut(&mut self, i: &mut Binding) {
-        visit_binding_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_block_mut(&mut self, i: &mut Block) {
-        visit_block_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) {
-        visit_bound_lifetimes_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_const_param_mut(&mut self, i: &mut ConstParam) {
-        visit_const_param_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_constraint_mut(&mut self, i: &mut Constraint) {
-        visit_constraint_mut(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_mut(&mut self, i: &mut Data) {
-        visit_data_mut(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_enum_mut(&mut self, i: &mut DataEnum) {
-        visit_data_enum_mut(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_struct_mut(&mut self, i: &mut DataStruct) {
-        visit_data_struct_mut(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_data_union_mut(&mut self, i: &mut DataUnion) {
-        visit_data_union_mut(self, i);
-    }
-    #[cfg(feature = "derive")]
-    fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) {
-        visit_derive_input_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_mut(&mut self, i: &mut Expr) {
-        visit_expr_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
-        visit_expr_array_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
-        visit_expr_assign_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) {
-        visit_expr_assign_op_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
-        visit_expr_async_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_await_mut(&mut self, i: &mut ExprAwait) {
-        visit_expr_await_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
-        visit_expr_binary_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
-        visit_expr_block_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_box_mut(&mut self, i: &mut ExprBox) {
-        visit_expr_box_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) {
-        visit_expr_break_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_call_mut(&mut self, i: &mut ExprCall) {
-        visit_expr_call_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
-        visit_expr_cast_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
-        visit_expr_closure_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) {
-        visit_expr_continue_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
-        visit_expr_field_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) {
-        visit_expr_for_loop_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
-        visit_expr_group_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_if_mut(&mut self, i: &mut ExprIf) {
-        visit_expr_if_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
-        visit_expr_index_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
-        visit_expr_let_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
-        visit_expr_lit_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
-        visit_expr_loop_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
-        visit_expr_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
-        visit_expr_match_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) {
-        visit_expr_method_call_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) {
-        visit_expr_paren_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
-        visit_expr_path_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
-        visit_expr_range_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
-        visit_expr_reference_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
-        visit_expr_repeat_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
-        visit_expr_return_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
-        visit_expr_struct_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
-        visit_expr_try_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) {
-        visit_expr_try_block_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
-        visit_expr_tuple_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_type_mut(&mut self, i: &mut ExprType) {
-        visit_expr_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
-        visit_expr_unary_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
-        visit_expr_unsafe_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
-        visit_expr_while_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) {
-        visit_expr_yield_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_field_mut(&mut self, i: &mut Field) {
-        visit_field_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
-        visit_field_pat_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_field_value_mut(&mut self, i: &mut FieldValue) {
-        visit_field_value_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields_mut(&mut self, i: &mut Fields) {
-        visit_fields_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) {
-        visit_fields_named_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) {
-        visit_fields_unnamed_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_file_mut(&mut self, i: &mut File) {
-        visit_file_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_fn_arg_mut(&mut self, i: &mut FnArg) {
-        visit_fn_arg_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) {
-        visit_foreign_item_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) {
-        visit_foreign_item_fn_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) {
-        visit_foreign_item_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) {
-        visit_foreign_item_static_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) {
-        visit_foreign_item_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
-        visit_generic_argument_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) {
-        visit_generic_method_argument_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generic_param_mut(&mut self, i: &mut GenericParam) {
-        visit_generic_param_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_generics_mut(&mut self, i: &mut Generics) {
-        visit_generics_mut(self, i);
-    }
-    fn visit_ident_mut(&mut self, i: &mut Ident) {
-        visit_ident_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_mut(&mut self, i: &mut ImplItem) {
-        visit_impl_item_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) {
-        visit_impl_item_const_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) {
-        visit_impl_item_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_method_mut(&mut self, i: &mut ImplItemMethod) {
-        visit_impl_item_method_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) {
-        visit_impl_item_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_index_mut(&mut self, i: &mut Index) {
-        visit_index_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_mut(&mut self, i: &mut Item) {
-        visit_item_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_const_mut(&mut self, i: &mut ItemConst) {
-        visit_item_const_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) {
-        visit_item_enum_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) {
-        visit_item_extern_crate_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_fn_mut(&mut self, i: &mut ItemFn) {
-        visit_item_fn_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) {
-        visit_item_foreign_mod_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) {
-        visit_item_impl_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) {
-        visit_item_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_macro2_mut(&mut self, i: &mut ItemMacro2) {
-        visit_item_macro2_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_mod_mut(&mut self, i: &mut ItemMod) {
-        visit_item_mod_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_static_mut(&mut self, i: &mut ItemStatic) {
-        visit_item_static_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) {
-        visit_item_struct_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) {
-        visit_item_trait_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) {
-        visit_item_trait_alias_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_type_mut(&mut self, i: &mut ItemType) {
-        visit_item_type_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_union_mut(&mut self, i: &mut ItemUnion) {
-        visit_item_union_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_item_use_mut(&mut self, i: &mut ItemUse) {
-        visit_item_use_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_label_mut(&mut self, i: &mut Label) {
-        visit_label_mut(self, i);
-    }
-    fn visit_lifetime_mut(&mut self, i: &mut Lifetime) {
-        visit_lifetime_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) {
-        visit_lifetime_def_mut(self, i);
-    }
-    fn visit_lit_mut(&mut self, i: &mut Lit) {
-        visit_lit_mut(self, i);
-    }
-    fn visit_lit_bool_mut(&mut self, i: &mut LitBool) {
-        visit_lit_bool_mut(self, i);
-    }
-    fn visit_lit_byte_mut(&mut self, i: &mut LitByte) {
-        visit_lit_byte_mut(self, i);
-    }
-    fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) {
-        visit_lit_byte_str_mut(self, i);
-    }
-    fn visit_lit_char_mut(&mut self, i: &mut LitChar) {
-        visit_lit_char_mut(self, i);
-    }
-    fn visit_lit_float_mut(&mut self, i: &mut LitFloat) {
-        visit_lit_float_mut(self, i);
-    }
-    fn visit_lit_int_mut(&mut self, i: &mut LitInt) {
-        visit_lit_int_mut(self, i);
-    }
-    fn visit_lit_str_mut(&mut self, i: &mut LitStr) {
-        visit_lit_str_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_local_mut(&mut self, i: &mut Local) {
-        visit_local_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_macro_mut(&mut self, i: &mut Macro) {
-        visit_macro_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) {
-        visit_macro_delimiter_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_member_mut(&mut self, i: &mut Member) {
-        visit_member_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta_mut(&mut self, i: &mut Meta) {
-        visit_meta_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta_list_mut(&mut self, i: &mut MetaList) {
-        visit_meta_list_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) {
-        visit_meta_name_value_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) {
-        visit_method_turbofish_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) {
-        visit_nested_meta_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) {
-        visit_parenthesized_generic_arguments_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_mut(&mut self, i: &mut Pat) {
-        visit_pat_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_box_mut(&mut self, i: &mut PatBox) {
-        visit_pat_box_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
-        visit_pat_ident_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_lit_mut(&mut self, i: &mut PatLit) {
-        visit_pat_lit_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) {
-        visit_pat_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_or_mut(&mut self, i: &mut PatOr) {
-        visit_pat_or_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_path_mut(&mut self, i: &mut PatPath) {
-        visit_pat_path_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_range_mut(&mut self, i: &mut PatRange) {
-        visit_pat_range_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_reference_mut(&mut self, i: &mut PatReference) {
-        visit_pat_reference_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_rest_mut(&mut self, i: &mut PatRest) {
-        visit_pat_rest_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
-        visit_pat_slice_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
-        visit_pat_struct_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
-        visit_pat_tuple_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) {
-        visit_pat_tuple_struct_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_type_mut(&mut self, i: &mut PatType) {
-        visit_pat_type_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_pat_wild_mut(&mut self, i: &mut PatWild) {
-        visit_pat_wild_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path_mut(&mut self, i: &mut Path) {
-        visit_path_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) {
-        visit_path_arguments_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_path_segment_mut(&mut self, i: &mut PathSegment) {
-        visit_path_segment_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) {
-        visit_predicate_eq_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) {
-        visit_predicate_lifetime_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) {
-        visit_predicate_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_qself_mut(&mut self, i: &mut QSelf) {
-        visit_qself_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
-        visit_range_limits_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_receiver_mut(&mut self, i: &mut Receiver) {
-        visit_receiver_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
-        visit_return_type_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_signature_mut(&mut self, i: &mut Signature) {
-        visit_signature_mut(self, i);
-    }
-    fn visit_span_mut(&mut self, i: &mut Span) {
-        visit_span_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_stmt_mut(&mut self, i: &mut Stmt) {
-        visit_stmt_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) {
-        visit_trait_bound_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) {
-        visit_trait_bound_modifier_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_mut(&mut self, i: &mut TraitItem) {
-        visit_trait_item_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) {
-        visit_trait_item_const_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_macro_mut(&mut self, i: &mut TraitItemMacro) {
-        visit_trait_item_macro_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_method_mut(&mut self, i: &mut TraitItemMethod) {
-        visit_trait_item_method_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) {
-        visit_trait_item_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_mut(&mut self, i: &mut Type) {
-        visit_type_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_array_mut(&mut self, i: &mut TypeArray) {
-        visit_type_array_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) {
-        visit_type_bare_fn_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_group_mut(&mut self, i: &mut TypeGroup) {
-        visit_type_group_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) {
-        visit_type_impl_trait_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) {
-        visit_type_infer_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) {
-        visit_type_macro_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_never_mut(&mut self, i: &mut TypeNever) {
-        visit_type_never_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_param_mut(&mut self, i: &mut TypeParam) {
-        visit_type_param_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) {
-        visit_type_param_bound_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_paren_mut(&mut self, i: &mut TypeParen) {
-        visit_type_paren_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_path_mut(&mut self, i: &mut TypePath) {
-        visit_type_path_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) {
-        visit_type_ptr_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_reference_mut(&mut self, i: &mut TypeReference) {
-        visit_type_reference_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) {
-        visit_type_slice_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) {
-        visit_type_trait_object_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) {
-        visit_type_tuple_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_un_op_mut(&mut self, i: &mut UnOp) {
-        visit_un_op_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_glob_mut(&mut self, i: &mut UseGlob) {
-        visit_use_glob_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_group_mut(&mut self, i: &mut UseGroup) {
-        visit_use_group_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_name_mut(&mut self, i: &mut UseName) {
-        visit_use_name_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_path_mut(&mut self, i: &mut UsePath) {
-        visit_use_path_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_rename_mut(&mut self, i: &mut UseRename) {
-        visit_use_rename_mut(self, i);
-    }
-    #[cfg(feature = "full")]
-    fn visit_use_tree_mut(&mut self, i: &mut UseTree) {
-        visit_use_tree_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_variadic_mut(&mut self, i: &mut Variadic) {
-        visit_variadic_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_variant_mut(&mut self, i: &mut Variant) {
-        visit_variant_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) {
-        visit_vis_crate_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_public_mut(&mut self, i: &mut VisPublic) {
-        visit_vis_public_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) {
-        visit_vis_restricted_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_visibility_mut(&mut self, i: &mut Visibility) {
-        visit_visibility_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_where_clause_mut(&mut self, i: &mut WhereClause) {
-        visit_where_clause_mut(self, i);
-    }
-    #[cfg(any(feature = "derive", feature = "full"))]
-    fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) {
-        visit_where_predicate_mut(self, i);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_abi_mut<V>(v: &mut V, node: &mut Abi)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.extern_token.span);
-    if let Some(it) = &mut node.name {
-        v.visit_lit_str_mut(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_angle_bracketed_generic_arguments_mut<V>(
-    v: &mut V,
-    node: &mut AngleBracketedGenericArguments,
-) where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.colon2_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    tokens_helper(v, &mut node.lt_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_argument_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.gt_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_arm_mut<V>(v: &mut V, node: &mut Arm)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_pat_mut(&mut node.pat);
-    if let Some(it) = &mut node.guard {
-        tokens_helper(v, &mut (it).0.span);
-        v.visit_expr_mut(&mut *(it).1);
-    };
-    tokens_helper(v, &mut node.fat_arrow_token.spans);
-    v.visit_expr_mut(&mut *node.body);
-    if let Some(it) = &mut node.comma {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_attr_style_mut<V>(v: &mut V, node: &mut AttrStyle)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        AttrStyle::Outer => {}
-        AttrStyle::Inner(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_attribute_mut<V>(v: &mut V, node: &mut Attribute)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.pound_token.spans);
-    v.visit_attr_style_mut(&mut node.style);
-    tokens_helper(v, &mut node.bracket_token.span);
-    v.visit_path_mut(&mut node.path);
-    skip!(node.tokens);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bare_fn_arg_mut<V>(v: &mut V, node: &mut BareFnArg)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.name {
-        v.visit_ident_mut(&mut (it).0);
-        tokens_helper(v, &mut (it).1.spans);
-    };
-    v.visit_type_mut(&mut node.ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bin_op_mut<V>(v: &mut V, node: &mut BinOp)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        BinOp::Add(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Sub(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Mul(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Div(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Rem(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::And(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Or(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitXor(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitAnd(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitOr(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Shl(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Shr(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Eq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Lt(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Le(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Ne(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Ge(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::Gt(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::AddEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::SubEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::MulEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::DivEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::RemEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitXorEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitAndEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::BitOrEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::ShlEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        BinOp::ShrEq(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_binding_mut<V>(v: &mut V, node: &mut Binding)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_type_mut(&mut node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_block_mut<V>(v: &mut V, node: &mut Block)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.brace_token.span);
-    for it in &mut node.stmts {
-        v.visit_stmt_mut(it);
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_bound_lifetimes_mut<V>(v: &mut V, node: &mut BoundLifetimes)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.for_token.span);
-    tokens_helper(v, &mut node.lt_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.lifetimes) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime_def_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.gt_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_const_param_mut<V>(v: &mut V, node: &mut ConstParam)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.const_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut node.ty);
-    if let Some(it) = &mut node.eq_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    if let Some(it) = &mut node.default {
-        v.visit_expr_mut(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_constraint_mut<V>(v: &mut V, node: &mut Constraint)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_mut<V>(v: &mut V, node: &mut Data)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Data::Struct(_binding_0) => {
-            v.visit_data_struct_mut(_binding_0);
-        }
-        Data::Enum(_binding_0) => {
-            v.visit_data_enum_mut(_binding_0);
-        }
-        Data::Union(_binding_0) => {
-            v.visit_data_union_mut(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_enum_mut<V>(v: &mut V, node: &mut DataEnum)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.enum_token.span);
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.variants) {
-        let (it, p) = el.into_tuple();
-        v.visit_variant_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_struct_mut<V>(v: &mut V, node: &mut DataStruct)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.struct_token.span);
-    v.visit_fields_mut(&mut node.fields);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "derive")]
-pub fn visit_data_union_mut<V>(v: &mut V, node: &mut DataUnion)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.union_token.span);
-    v.visit_fields_named_mut(&mut node.fields);
-}
-#[cfg(feature = "derive")]
-pub fn visit_derive_input_mut<V>(v: &mut V, node: &mut DeriveInput)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    v.visit_data_mut(&mut node.data);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Expr::Array(_binding_0) => {
-            full!(v.visit_expr_array_mut(_binding_0));
-        }
-        Expr::Assign(_binding_0) => {
-            full!(v.visit_expr_assign_mut(_binding_0));
-        }
-        Expr::AssignOp(_binding_0) => {
-            full!(v.visit_expr_assign_op_mut(_binding_0));
-        }
-        Expr::Async(_binding_0) => {
-            full!(v.visit_expr_async_mut(_binding_0));
-        }
-        Expr::Await(_binding_0) => {
-            full!(v.visit_expr_await_mut(_binding_0));
-        }
-        Expr::Binary(_binding_0) => {
-            v.visit_expr_binary_mut(_binding_0);
-        }
-        Expr::Block(_binding_0) => {
-            full!(v.visit_expr_block_mut(_binding_0));
-        }
-        Expr::Box(_binding_0) => {
-            full!(v.visit_expr_box_mut(_binding_0));
-        }
-        Expr::Break(_binding_0) => {
-            full!(v.visit_expr_break_mut(_binding_0));
-        }
-        Expr::Call(_binding_0) => {
-            v.visit_expr_call_mut(_binding_0);
-        }
-        Expr::Cast(_binding_0) => {
-            v.visit_expr_cast_mut(_binding_0);
-        }
-        Expr::Closure(_binding_0) => {
-            full!(v.visit_expr_closure_mut(_binding_0));
-        }
-        Expr::Continue(_binding_0) => {
-            full!(v.visit_expr_continue_mut(_binding_0));
-        }
-        Expr::Field(_binding_0) => {
-            v.visit_expr_field_mut(_binding_0);
-        }
-        Expr::ForLoop(_binding_0) => {
-            full!(v.visit_expr_for_loop_mut(_binding_0));
-        }
-        Expr::Group(_binding_0) => {
-            full!(v.visit_expr_group_mut(_binding_0));
-        }
-        Expr::If(_binding_0) => {
-            full!(v.visit_expr_if_mut(_binding_0));
-        }
-        Expr::Index(_binding_0) => {
-            v.visit_expr_index_mut(_binding_0);
-        }
-        Expr::Let(_binding_0) => {
-            full!(v.visit_expr_let_mut(_binding_0));
-        }
-        Expr::Lit(_binding_0) => {
-            v.visit_expr_lit_mut(_binding_0);
-        }
-        Expr::Loop(_binding_0) => {
-            full!(v.visit_expr_loop_mut(_binding_0));
-        }
-        Expr::Macro(_binding_0) => {
-            full!(v.visit_expr_macro_mut(_binding_0));
-        }
-        Expr::Match(_binding_0) => {
-            full!(v.visit_expr_match_mut(_binding_0));
-        }
-        Expr::MethodCall(_binding_0) => {
-            full!(v.visit_expr_method_call_mut(_binding_0));
-        }
-        Expr::Paren(_binding_0) => {
-            v.visit_expr_paren_mut(_binding_0);
-        }
-        Expr::Path(_binding_0) => {
-            v.visit_expr_path_mut(_binding_0);
-        }
-        Expr::Range(_binding_0) => {
-            full!(v.visit_expr_range_mut(_binding_0));
-        }
-        Expr::Reference(_binding_0) => {
-            full!(v.visit_expr_reference_mut(_binding_0));
-        }
-        Expr::Repeat(_binding_0) => {
-            full!(v.visit_expr_repeat_mut(_binding_0));
-        }
-        Expr::Return(_binding_0) => {
-            full!(v.visit_expr_return_mut(_binding_0));
-        }
-        Expr::Struct(_binding_0) => {
-            full!(v.visit_expr_struct_mut(_binding_0));
-        }
-        Expr::Try(_binding_0) => {
-            full!(v.visit_expr_try_mut(_binding_0));
-        }
-        Expr::TryBlock(_binding_0) => {
-            full!(v.visit_expr_try_block_mut(_binding_0));
-        }
-        Expr::Tuple(_binding_0) => {
-            full!(v.visit_expr_tuple_mut(_binding_0));
-        }
-        Expr::Type(_binding_0) => {
-            full!(v.visit_expr_type_mut(_binding_0));
-        }
-        Expr::Unary(_binding_0) => {
-            v.visit_expr_unary_mut(_binding_0);
-        }
-        Expr::Unsafe(_binding_0) => {
-            full!(v.visit_expr_unsafe_mut(_binding_0));
-        }
-        Expr::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        Expr::While(_binding_0) => {
-            full!(v.visit_expr_while_mut(_binding_0));
-        }
-        Expr::Yield(_binding_0) => {
-            full!(v.visit_expr_yield_mut(_binding_0));
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_array_mut<V>(v: &mut V, node: &mut ExprArray)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.bracket_token.span);
-    for el in Punctuated::pairs_mut(&mut node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_assign_mut<V>(v: &mut V, node: &mut ExprAssign)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.left);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_expr_mut(&mut *node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_assign_op_mut<V>(v: &mut V, node: &mut ExprAssignOp)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.left);
-    v.visit_bin_op_mut(&mut node.op);
-    v.visit_expr_mut(&mut *node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_async_mut<V>(v: &mut V, node: &mut ExprAsync)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.async_token.span);
-    if let Some(it) = &mut node.capture {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_block_mut(&mut node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_await_mut<V>(v: &mut V, node: &mut ExprAwait)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.base);
-    tokens_helper(v, &mut node.dot_token.spans);
-    tokens_helper(v, &mut node.await_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.left);
-    v.visit_bin_op_mut(&mut node.op);
-    v.visit_expr_mut(&mut *node.right);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_block_mut<V>(v: &mut V, node: &mut ExprBlock)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.label {
-        v.visit_label_mut(it);
-    };
-    v.visit_block_mut(&mut node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_box_mut<V>(v: &mut V, node: &mut ExprBox)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.box_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_break_mut<V>(v: &mut V, node: &mut ExprBreak)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.break_token.span);
-    if let Some(it) = &mut node.label {
-        v.visit_lifetime_mut(it);
-    };
-    if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_call_mut<V>(v: &mut V, node: &mut ExprCall)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.func);
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.as_token.span);
-    v.visit_type_mut(&mut *node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_closure_mut<V>(v: &mut V, node: &mut ExprClosure)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.asyncness {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.movability {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.capture {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.or1_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.or2_token.spans);
-    v.visit_return_type_mut(&mut node.output);
-    v.visit_expr_mut(&mut *node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_continue_mut<V>(v: &mut V, node: &mut ExprContinue)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.continue_token.span);
-    if let Some(it) = &mut node.label {
-        v.visit_lifetime_mut(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_field_mut<V>(v: &mut V, node: &mut ExprField)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.base);
-    tokens_helper(v, &mut node.dot_token.spans);
-    v.visit_member_mut(&mut node.member);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_for_loop_mut<V>(v: &mut V, node: &mut ExprForLoop)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.label {
-        v.visit_label_mut(it);
-    };
-    tokens_helper(v, &mut node.for_token.span);
-    v.visit_pat_mut(&mut node.pat);
-    tokens_helper(v, &mut node.in_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-    v.visit_block_mut(&mut node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_group_mut<V>(v: &mut V, node: &mut ExprGroup)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.group_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_if_mut<V>(v: &mut V, node: &mut ExprIf)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.if_token.span);
-    v.visit_expr_mut(&mut *node.cond);
-    v.visit_block_mut(&mut node.then_branch);
-    if let Some(it) = &mut node.else_branch {
-        tokens_helper(v, &mut (it).0.span);
-        v.visit_expr_mut(&mut *(it).1);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_index_mut<V>(v: &mut V, node: &mut ExprIndex)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.bracket_token.span);
-    v.visit_expr_mut(&mut *node.index);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.let_token.span);
-    v.visit_pat_mut(&mut node.pat);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_lit_mut<V>(v: &mut V, node: &mut ExprLit)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_lit_mut(&mut node.lit);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_loop_mut<V>(v: &mut V, node: &mut ExprLoop)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.label {
-        v.visit_label_mut(it);
-    };
-    tokens_helper(v, &mut node.loop_token.span);
-    v.visit_block_mut(&mut node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_macro_mut<V>(v: &mut V, node: &mut ExprMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_macro_mut(&mut node.mac);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.match_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.brace_token.span);
-    for it in &mut node.arms {
-        v.visit_arm_mut(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_method_call_mut<V>(v: &mut V, node: &mut ExprMethodCall)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.receiver);
-    tokens_helper(v, &mut node.dot_token.spans);
-    v.visit_ident_mut(&mut node.method);
-    if let Some(it) = &mut node.turbofish {
-        v.visit_method_turbofish_mut(it);
-    };
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_paren_mut<V>(v: &mut V, node: &mut ExprParen)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.paren_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_path_mut<V>(v: &mut V, node: &mut ExprPath)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it);
-    };
-    v.visit_path_mut(&mut node.path);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_range_mut<V>(v: &mut V, node: &mut ExprRange)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.from {
-        v.visit_expr_mut(&mut **it);
-    };
-    v.visit_range_limits_mut(&mut node.limits);
-    if let Some(it) = &mut node.to {
-        v.visit_expr_mut(&mut **it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.and_token.spans);
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_repeat_mut<V>(v: &mut V, node: &mut ExprRepeat)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.bracket_token.span);
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.semi_token.spans);
-    v.visit_expr_mut(&mut *node.len);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_return_mut<V>(v: &mut V, node: &mut ExprReturn)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.return_token.span);
-    if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_struct_mut<V>(v: &mut V, node: &mut ExprStruct)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_path_mut(&mut node.path);
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.fields) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_value_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.dot2_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    if let Some(it) = &mut node.rest {
-        v.visit_expr_mut(&mut **it);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_try_mut<V>(v: &mut V, node: &mut ExprTry)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.question_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_try_block_mut<V>(v: &mut V, node: &mut ExprTryBlock)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.try_token.span);
-    v.visit_block_mut(&mut node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_tuple_mut<V>(v: &mut V, node: &mut ExprTuple)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_expr_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_type_mut<V>(v: &mut V, node: &mut ExprType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_expr_unary_mut<V>(v: &mut V, node: &mut ExprUnary)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_un_op_mut(&mut node.op);
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_unsafe_mut<V>(v: &mut V, node: &mut ExprUnsafe)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.unsafe_token.span);
-    v.visit_block_mut(&mut node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_while_mut<V>(v: &mut V, node: &mut ExprWhile)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.label {
-        v.visit_label_mut(it);
-    };
-    tokens_helper(v, &mut node.while_token.span);
-    v.visit_expr_mut(&mut *node.cond);
-    v.visit_block_mut(&mut node.body);
-}
-#[cfg(feature = "full")]
-pub fn visit_expr_yield_mut<V>(v: &mut V, node: &mut ExprYield)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.yield_token.span);
-    if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_field_mut<V>(v: &mut V, node: &mut Field)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    if let Some(it) = &mut node.ident {
-        v.visit_ident_mut(it);
-    };
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    v.visit_type_mut(&mut node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_field_pat_mut<V>(v: &mut V, node: &mut FieldPat)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_member_mut(&mut node.member);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    v.visit_pat_mut(&mut *node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_field_value_mut<V>(v: &mut V, node: &mut FieldValue)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_member_mut(&mut node.member);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    v.visit_expr_mut(&mut node.expr);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields_mut<V>(v: &mut V, node: &mut Fields)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Fields::Named(_binding_0) => {
-            v.visit_fields_named_mut(_binding_0);
-        }
-        Fields::Unnamed(_binding_0) => {
-            v.visit_fields_unnamed_mut(_binding_0);
-        }
-        Fields::Unit => {}
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields_named_mut<V>(v: &mut V, node: &mut FieldsNamed)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.named) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_fields_unnamed_mut<V>(v: &mut V, node: &mut FieldsUnnamed)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.unnamed) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_file_mut<V>(v: &mut V, node: &mut File)
-where
-    V: VisitMut + ?Sized,
-{
-    skip!(node.shebang);
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    for it in &mut node.items {
-        v.visit_item_mut(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_fn_arg_mut<V>(v: &mut V, node: &mut FnArg)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        FnArg::Receiver(_binding_0) => {
-            v.visit_receiver_mut(_binding_0);
-        }
-        FnArg::Typed(_binding_0) => {
-            v.visit_pat_type_mut(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_mut<V>(v: &mut V, node: &mut ForeignItem)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        ForeignItem::Fn(_binding_0) => {
-            v.visit_foreign_item_fn_mut(_binding_0);
-        }
-        ForeignItem::Static(_binding_0) => {
-            v.visit_foreign_item_static_mut(_binding_0);
-        }
-        ForeignItem::Type(_binding_0) => {
-            v.visit_foreign_item_type_mut(_binding_0);
-        }
-        ForeignItem::Macro(_binding_0) => {
-            v.visit_foreign_item_macro_mut(_binding_0);
-        }
-        ForeignItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_fn_mut<V>(v: &mut V, node: &mut ForeignItemFn)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    v.visit_signature_mut(&mut node.sig);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_macro_mut<V>(v: &mut V, node: &mut ForeignItemMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_macro_mut(&mut node.mac);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_static_mut<V>(v: &mut V, node: &mut ForeignItemStatic)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.static_token.span);
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_foreign_item_type_mut<V>(v: &mut V, node: &mut ForeignItemType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.type_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generic_argument_mut<V>(v: &mut V, node: &mut GenericArgument)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        GenericArgument::Lifetime(_binding_0) => {
-            v.visit_lifetime_mut(_binding_0);
-        }
-        GenericArgument::Type(_binding_0) => {
-            v.visit_type_mut(_binding_0);
-        }
-        GenericArgument::Binding(_binding_0) => {
-            v.visit_binding_mut(_binding_0);
-        }
-        GenericArgument::Constraint(_binding_0) => {
-            v.visit_constraint_mut(_binding_0);
-        }
-        GenericArgument::Const(_binding_0) => {
-            v.visit_expr_mut(_binding_0);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_generic_method_argument_mut<V>(v: &mut V, node: &mut GenericMethodArgument)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        GenericMethodArgument::Type(_binding_0) => {
-            v.visit_type_mut(_binding_0);
-        }
-        GenericMethodArgument::Const(_binding_0) => {
-            v.visit_expr_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generic_param_mut<V>(v: &mut V, node: &mut GenericParam)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        GenericParam::Type(_binding_0) => {
-            v.visit_type_param_mut(_binding_0);
-        }
-        GenericParam::Lifetime(_binding_0) => {
-            v.visit_lifetime_def_mut(_binding_0);
-        }
-        GenericParam::Const(_binding_0) => {
-            v.visit_const_param_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_generics_mut<V>(v: &mut V, node: &mut Generics)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.lt_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.params) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_param_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.gt_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    if let Some(it) = &mut node.where_clause {
-        v.visit_where_clause_mut(it);
-    };
-}
-pub fn visit_ident_mut<V>(v: &mut V, node: &mut Ident)
-where
-    V: VisitMut + ?Sized,
-{
-    let mut span = node.span();
-    v.visit_span_mut(&mut span);
-    node.set_span(span);
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_mut<V>(v: &mut V, node: &mut ImplItem)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        ImplItem::Const(_binding_0) => {
-            v.visit_impl_item_const_mut(_binding_0);
-        }
-        ImplItem::Method(_binding_0) => {
-            v.visit_impl_item_method_mut(_binding_0);
-        }
-        ImplItem::Type(_binding_0) => {
-            v.visit_impl_item_type_mut(_binding_0);
-        }
-        ImplItem::Macro(_binding_0) => {
-            v.visit_impl_item_macro_mut(_binding_0);
-        }
-        ImplItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_const_mut<V>(v: &mut V, node: &mut ImplItemConst)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.const_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut node.ty);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_expr_mut(&mut node.expr);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_macro_mut<V>(v: &mut V, node: &mut ImplItemMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_macro_mut(&mut node.mac);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_method_mut<V>(v: &mut V, node: &mut ImplItemMethod)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_signature_mut(&mut node.sig);
-    v.visit_block_mut(&mut node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_impl_item_type_mut<V>(v: &mut V, node: &mut ImplItemType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.type_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_type_mut(&mut node.ty);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_index_mut<V>(v: &mut V, node: &mut Index)
-where
-    V: VisitMut + ?Sized,
-{
-    skip!(node.index);
-    v.visit_span_mut(&mut node.span);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_mut<V>(v: &mut V, node: &mut Item)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Item::Const(_binding_0) => {
-            v.visit_item_const_mut(_binding_0);
-        }
-        Item::Enum(_binding_0) => {
-            v.visit_item_enum_mut(_binding_0);
-        }
-        Item::ExternCrate(_binding_0) => {
-            v.visit_item_extern_crate_mut(_binding_0);
-        }
-        Item::Fn(_binding_0) => {
-            v.visit_item_fn_mut(_binding_0);
-        }
-        Item::ForeignMod(_binding_0) => {
-            v.visit_item_foreign_mod_mut(_binding_0);
-        }
-        Item::Impl(_binding_0) => {
-            v.visit_item_impl_mut(_binding_0);
-        }
-        Item::Macro(_binding_0) => {
-            v.visit_item_macro_mut(_binding_0);
-        }
-        Item::Macro2(_binding_0) => {
-            v.visit_item_macro2_mut(_binding_0);
-        }
-        Item::Mod(_binding_0) => {
-            v.visit_item_mod_mut(_binding_0);
-        }
-        Item::Static(_binding_0) => {
-            v.visit_item_static_mut(_binding_0);
-        }
-        Item::Struct(_binding_0) => {
-            v.visit_item_struct_mut(_binding_0);
-        }
-        Item::Trait(_binding_0) => {
-            v.visit_item_trait_mut(_binding_0);
-        }
-        Item::TraitAlias(_binding_0) => {
-            v.visit_item_trait_alias_mut(_binding_0);
-        }
-        Item::Type(_binding_0) => {
-            v.visit_item_type_mut(_binding_0);
-        }
-        Item::Union(_binding_0) => {
-            v.visit_item_union_mut(_binding_0);
-        }
-        Item::Use(_binding_0) => {
-            v.visit_item_use_mut(_binding_0);
-        }
-        Item::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_const_mut<V>(v: &mut V, node: &mut ItemConst)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.const_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_enum_mut<V>(v: &mut V, node: &mut ItemEnum)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.enum_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.variants) {
-        let (it, p) = el.into_tuple();
-        v.visit_variant_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_extern_crate_mut<V>(v: &mut V, node: &mut ItemExternCrate)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.extern_token.span);
-    tokens_helper(v, &mut node.crate_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    if let Some(it) = &mut node.rename {
-        tokens_helper(v, &mut (it).0.span);
-        v.visit_ident_mut(&mut (it).1);
-    };
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_fn_mut<V>(v: &mut V, node: &mut ItemFn)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    v.visit_signature_mut(&mut node.sig);
-    v.visit_block_mut(&mut *node.block);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_foreign_mod_mut<V>(v: &mut V, node: &mut ItemForeignMod)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_abi_mut(&mut node.abi);
-    tokens_helper(v, &mut node.brace_token.span);
-    for it in &mut node.items {
-        v.visit_foreign_item_mut(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_impl_mut<V>(v: &mut V, node: &mut ItemImpl)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.impl_token.span);
-    v.visit_generics_mut(&mut node.generics);
-    if let Some(it) = &mut node.trait_ {
-        if let Some(it) = &mut (it).0 {
-            tokens_helper(v, &mut it.spans);
-        };
-        v.visit_path_mut(&mut (it).1);
-        tokens_helper(v, &mut (it).2.span);
-    };
-    v.visit_type_mut(&mut *node.self_ty);
-    tokens_helper(v, &mut node.brace_token.span);
-    for it in &mut node.items {
-        v.visit_impl_item_mut(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_macro_mut<V>(v: &mut V, node: &mut ItemMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.ident {
-        v.visit_ident_mut(it);
-    };
-    v.visit_macro_mut(&mut node.mac);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_macro2_mut<V>(v: &mut V, node: &mut ItemMacro2)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.macro_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    skip!(node.rules);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_mod_mut<V>(v: &mut V, node: &mut ItemMod)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.mod_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    if let Some(it) = &mut node.content {
-        tokens_helper(v, &mut (it).0.span);
-        for it in &mut (it).1 {
-            v.visit_item_mut(it);
-        }
-    };
-    if let Some(it) = &mut node.semi {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_static_mut<V>(v: &mut V, node: &mut ItemStatic)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.static_token.span);
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_expr_mut(&mut *node.expr);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_struct_mut<V>(v: &mut V, node: &mut ItemStruct)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.struct_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    v.visit_fields_mut(&mut node.fields);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_item_trait_mut<V>(v: &mut V, node: &mut ItemTrait)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.auto_token {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.trait_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.supertraits) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.brace_token.span);
-    for it in &mut node.items {
-        v.visit_trait_item_mut(it);
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_item_trait_alias_mut<V>(v: &mut V, node: &mut ItemTraitAlias)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.trait_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    tokens_helper(v, &mut node.eq_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_type_mut<V>(v: &mut V, node: &mut ItemType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.type_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_union_mut<V>(v: &mut V, node: &mut ItemUnion)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.union_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    v.visit_fields_named_mut(&mut node.fields);
-}
-#[cfg(feature = "full")]
-pub fn visit_item_use_mut<V>(v: &mut V, node: &mut ItemUse)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_visibility_mut(&mut node.vis);
-    tokens_helper(v, &mut node.use_token.span);
-    if let Some(it) = &mut node.leading_colon {
-        tokens_helper(v, &mut it.spans);
-    };
-    v.visit_use_tree_mut(&mut node.tree);
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_label_mut<V>(v: &mut V, node: &mut Label)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_lifetime_mut(&mut node.name);
-    tokens_helper(v, &mut node.colon_token.spans);
-}
-pub fn visit_lifetime_mut<V>(v: &mut V, node: &mut Lifetime)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_span_mut(&mut node.apostrophe);
-    v.visit_ident_mut(&mut node.ident);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_lifetime_def_mut<V>(v: &mut V, node: &mut LifetimeDef)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_lifetime_mut(&mut node.lifetime);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-pub fn visit_lit_mut<V>(v: &mut V, node: &mut Lit)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Lit::Str(_binding_0) => {
-            v.visit_lit_str_mut(_binding_0);
-        }
-        Lit::ByteStr(_binding_0) => {
-            v.visit_lit_byte_str_mut(_binding_0);
-        }
-        Lit::Byte(_binding_0) => {
-            v.visit_lit_byte_mut(_binding_0);
-        }
-        Lit::Char(_binding_0) => {
-            v.visit_lit_char_mut(_binding_0);
-        }
-        Lit::Int(_binding_0) => {
-            v.visit_lit_int_mut(_binding_0);
-        }
-        Lit::Float(_binding_0) => {
-            v.visit_lit_float_mut(_binding_0);
-        }
-        Lit::Bool(_binding_0) => {
-            v.visit_lit_bool_mut(_binding_0);
-        }
-        Lit::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-    }
-}
-pub fn visit_lit_bool_mut<V>(v: &mut V, node: &mut LitBool)
-where
-    V: VisitMut + ?Sized,
-{
-    skip!(node.value);
-    v.visit_span_mut(&mut node.span);
-}
-pub fn visit_lit_byte_mut<V>(v: &mut V, node: &mut LitByte)
-where
-    V: VisitMut + ?Sized,
-{
-}
-pub fn visit_lit_byte_str_mut<V>(v: &mut V, node: &mut LitByteStr)
-where
-    V: VisitMut + ?Sized,
-{
-}
-pub fn visit_lit_char_mut<V>(v: &mut V, node: &mut LitChar)
-where
-    V: VisitMut + ?Sized,
-{
-}
-pub fn visit_lit_float_mut<V>(v: &mut V, node: &mut LitFloat)
-where
-    V: VisitMut + ?Sized,
-{
-}
-pub fn visit_lit_int_mut<V>(v: &mut V, node: &mut LitInt)
-where
-    V: VisitMut + ?Sized,
-{
-}
-pub fn visit_lit_str_mut<V>(v: &mut V, node: &mut LitStr)
-where
-    V: VisitMut + ?Sized,
-{
-}
-#[cfg(feature = "full")]
-pub fn visit_local_mut<V>(v: &mut V, node: &mut Local)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.let_token.span);
-    v.visit_pat_mut(&mut node.pat);
-    if let Some(it) = &mut node.init {
-        tokens_helper(v, &mut (it).0.spans);
-        v.visit_expr_mut(&mut *(it).1);
-    };
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_macro_mut<V>(v: &mut V, node: &mut Macro)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_path_mut(&mut node.path);
-    tokens_helper(v, &mut node.bang_token.spans);
-    v.visit_macro_delimiter_mut(&mut node.delimiter);
-    skip!(node.tokens);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_macro_delimiter_mut<V>(v: &mut V, node: &mut MacroDelimiter)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        MacroDelimiter::Paren(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.span);
-        }
-        MacroDelimiter::Brace(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.span);
-        }
-        MacroDelimiter::Bracket(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.span);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_member_mut<V>(v: &mut V, node: &mut Member)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Member::Named(_binding_0) => {
-            v.visit_ident_mut(_binding_0);
-        }
-        Member::Unnamed(_binding_0) => {
-            v.visit_index_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta_mut<V>(v: &mut V, node: &mut Meta)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Meta::Path(_binding_0) => {
-            v.visit_path_mut(_binding_0);
-        }
-        Meta::List(_binding_0) => {
-            v.visit_meta_list_mut(_binding_0);
-        }
-        Meta::NameValue(_binding_0) => {
-            v.visit_meta_name_value_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta_list_mut<V>(v: &mut V, node: &mut MetaList)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_path_mut(&mut node.path);
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.nested) {
-        let (it, p) = el.into_tuple();
-        v.visit_nested_meta_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_meta_name_value_mut<V>(v: &mut V, node: &mut MetaNameValue)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_path_mut(&mut node.path);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_lit_mut(&mut node.lit);
-}
-#[cfg(feature = "full")]
-pub fn visit_method_turbofish_mut<V>(v: &mut V, node: &mut MethodTurbofish)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.colon2_token.spans);
-    tokens_helper(v, &mut node.lt_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.args) {
-        let (it, p) = el.into_tuple();
-        v.visit_generic_method_argument_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    tokens_helper(v, &mut node.gt_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_nested_meta_mut<V>(v: &mut V, node: &mut NestedMeta)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        NestedMeta::Meta(_binding_0) => {
-            v.visit_meta_mut(_binding_0);
-        }
-        NestedMeta::Lit(_binding_0) => {
-            v.visit_lit_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_parenthesized_generic_arguments_mut<V>(
-    v: &mut V,
-    node: &mut ParenthesizedGenericArguments,
-) where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    v.visit_return_type_mut(&mut node.output);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_mut<V>(v: &mut V, node: &mut Pat)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Pat::Box(_binding_0) => {
-            v.visit_pat_box_mut(_binding_0);
-        }
-        Pat::Ident(_binding_0) => {
-            v.visit_pat_ident_mut(_binding_0);
-        }
-        Pat::Lit(_binding_0) => {
-            v.visit_pat_lit_mut(_binding_0);
-        }
-        Pat::Macro(_binding_0) => {
-            v.visit_pat_macro_mut(_binding_0);
-        }
-        Pat::Or(_binding_0) => {
-            v.visit_pat_or_mut(_binding_0);
-        }
-        Pat::Path(_binding_0) => {
-            v.visit_pat_path_mut(_binding_0);
-        }
-        Pat::Range(_binding_0) => {
-            v.visit_pat_range_mut(_binding_0);
-        }
-        Pat::Reference(_binding_0) => {
-            v.visit_pat_reference_mut(_binding_0);
-        }
-        Pat::Rest(_binding_0) => {
-            v.visit_pat_rest_mut(_binding_0);
-        }
-        Pat::Slice(_binding_0) => {
-            v.visit_pat_slice_mut(_binding_0);
-        }
-        Pat::Struct(_binding_0) => {
-            v.visit_pat_struct_mut(_binding_0);
-        }
-        Pat::Tuple(_binding_0) => {
-            v.visit_pat_tuple_mut(_binding_0);
-        }
-        Pat::TupleStruct(_binding_0) => {
-            v.visit_pat_tuple_struct_mut(_binding_0);
-        }
-        Pat::Type(_binding_0) => {
-            v.visit_pat_type_mut(_binding_0);
-        }
-        Pat::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        Pat::Wild(_binding_0) => {
-            v.visit_pat_wild_mut(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_box_mut<V>(v: &mut V, node: &mut PatBox)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.box_token.span);
-    v.visit_pat_mut(&mut *node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_ident_mut<V>(v: &mut V, node: &mut PatIdent)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.by_ref {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_ident_mut(&mut node.ident);
-    if let Some(it) = &mut node.subpat {
-        tokens_helper(v, &mut (it).0.spans);
-        v.visit_pat_mut(&mut *(it).1);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_lit_mut<V>(v: &mut V, node: &mut PatLit)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.expr);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_macro_mut<V>(v: &mut V, node: &mut PatMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_macro_mut(&mut node.mac);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_or_mut<V>(v: &mut V, node: &mut PatOr)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.leading_vert {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.cases) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_path_mut<V>(v: &mut V, node: &mut PatPath)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it);
-    };
-    v.visit_path_mut(&mut node.path);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_range_mut<V>(v: &mut V, node: &mut PatRange)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_expr_mut(&mut *node.lo);
-    v.visit_range_limits_mut(&mut node.limits);
-    v.visit_expr_mut(&mut *node.hi);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_reference_mut<V>(v: &mut V, node: &mut PatReference)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.and_token.spans);
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_pat_mut(&mut *node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_rest_mut<V>(v: &mut V, node: &mut PatRest)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.dot2_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_slice_mut<V>(v: &mut V, node: &mut PatSlice)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.bracket_token.span);
-    for el in Punctuated::pairs_mut(&mut node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_struct_mut<V>(v: &mut V, node: &mut PatStruct)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_path_mut(&mut node.path);
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.fields) {
-        let (it, p) = el.into_tuple();
-        v.visit_field_pat_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.dot2_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_tuple_mut<V>(v: &mut V, node: &mut PatTuple)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_pat_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_tuple_struct_mut<V>(v: &mut V, node: &mut PatTupleStruct)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_path_mut(&mut node.path);
-    v.visit_pat_tuple_mut(&mut node.pat);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_type_mut<V>(v: &mut V, node: &mut PatType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_pat_mut(&mut *node.pat);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-}
-#[cfg(feature = "full")]
-pub fn visit_pat_wild_mut<V>(v: &mut V, node: &mut PatWild)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.underscore_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path_mut<V>(v: &mut V, node: &mut Path)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.leading_colon {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.segments) {
-        let (it, p) = el.into_tuple();
-        v.visit_path_segment_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path_arguments_mut<V>(v: &mut V, node: &mut PathArguments)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        PathArguments::None => {}
-        PathArguments::AngleBracketed(_binding_0) => {
-            v.visit_angle_bracketed_generic_arguments_mut(_binding_0);
-        }
-        PathArguments::Parenthesized(_binding_0) => {
-            v.visit_parenthesized_generic_arguments_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_path_segment_mut<V>(v: &mut V, node: &mut PathSegment)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_path_arguments_mut(&mut node.arguments);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_eq_mut<V>(v: &mut V, node: &mut PredicateEq)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_type_mut(&mut node.lhs_ty);
-    tokens_helper(v, &mut node.eq_token.spans);
-    v.visit_type_mut(&mut node.rhs_ty);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_lifetime_mut<V>(v: &mut V, node: &mut PredicateLifetime)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_lifetime_mut(&mut node.lifetime);
-    tokens_helper(v, &mut node.colon_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_lifetime_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_predicate_type_mut<V>(v: &mut V, node: &mut PredicateType)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it);
-    };
-    v.visit_type_mut(&mut node.bounded_ty);
-    tokens_helper(v, &mut node.colon_token.spans);
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_qself_mut<V>(v: &mut V, node: &mut QSelf)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.lt_token.spans);
-    v.visit_type_mut(&mut *node.ty);
-    skip!(node.position);
-    if let Some(it) = &mut node.as_token {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.gt_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_range_limits_mut<V>(v: &mut V, node: &mut RangeLimits)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        RangeLimits::HalfOpen(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        RangeLimits::Closed(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_receiver_mut<V>(v: &mut V, node: &mut Receiver)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    if let Some(it) = &mut node.reference {
-        tokens_helper(v, &mut (it).0.spans);
-        if let Some(it) = &mut (it).1 {
-            v.visit_lifetime_mut(it);
-        };
-    };
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    tokens_helper(v, &mut node.self_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_return_type_mut<V>(v: &mut V, node: &mut ReturnType)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        ReturnType::Default => {}
-        ReturnType::Type(_binding_0, _binding_1) => {
-            tokens_helper(v, &mut _binding_0.spans);
-            v.visit_type_mut(&mut **_binding_1);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_signature_mut<V>(v: &mut V, node: &mut Signature)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.constness {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.asyncness {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.abi {
-        v.visit_abi_mut(it);
-    };
-    tokens_helper(v, &mut node.fn_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_fn_arg_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.variadic {
-        v.visit_variadic_mut(it);
-    };
-    v.visit_return_type_mut(&mut node.output);
-}
-pub fn visit_span_mut<V>(v: &mut V, node: &mut Span)
-where
-    V: VisitMut + ?Sized,
-{
-}
-#[cfg(feature = "full")]
-pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Stmt)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Stmt::Local(_binding_0) => {
-            v.visit_local_mut(_binding_0);
-        }
-        Stmt::Item(_binding_0) => {
-            v.visit_item_mut(_binding_0);
-        }
-        Stmt::Expr(_binding_0) => {
-            v.visit_expr_mut(_binding_0);
-        }
-        Stmt::Semi(_binding_0, _binding_1) => {
-            v.visit_expr_mut(_binding_0);
-            tokens_helper(v, &mut _binding_1.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_trait_bound_mut<V>(v: &mut V, node: &mut TraitBound)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.paren_token {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_trait_bound_modifier_mut(&mut node.modifier);
-    if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it);
-    };
-    v.visit_path_mut(&mut node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_trait_bound_modifier_mut<V>(v: &mut V, node: &mut TraitBoundModifier)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        TraitBoundModifier::None => {}
-        TraitBoundModifier::Maybe(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_mut<V>(v: &mut V, node: &mut TraitItem)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        TraitItem::Const(_binding_0) => {
-            v.visit_trait_item_const_mut(_binding_0);
-        }
-        TraitItem::Method(_binding_0) => {
-            v.visit_trait_item_method_mut(_binding_0);
-        }
-        TraitItem::Type(_binding_0) => {
-            v.visit_trait_item_type_mut(_binding_0);
-        }
-        TraitItem::Macro(_binding_0) => {
-            v.visit_trait_item_macro_mut(_binding_0);
-        }
-        TraitItem::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_const_mut<V>(v: &mut V, node: &mut TraitItemConst)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.const_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon_token.spans);
-    v.visit_type_mut(&mut node.ty);
-    if let Some(it) = &mut node.default {
-        tokens_helper(v, &mut (it).0.spans);
-        v.visit_expr_mut(&mut (it).1);
-    };
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_macro_mut<V>(v: &mut V, node: &mut TraitItemMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_macro_mut(&mut node.mac);
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_method_mut<V>(v: &mut V, node: &mut TraitItemMethod)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_signature_mut(&mut node.sig);
-    if let Some(it) = &mut node.default {
-        v.visit_block_mut(it);
-    };
-    if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans);
-    };
-}
-#[cfg(feature = "full")]
-pub fn visit_trait_item_type_mut<V>(v: &mut V, node: &mut TraitItemType)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.type_token.span);
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_generics_mut(&mut node.generics);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.default {
-        tokens_helper(v, &mut (it).0.spans);
-        v.visit_type_mut(&mut (it).1);
-    };
-    tokens_helper(v, &mut node.semi_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_mut<V>(v: &mut V, node: &mut Type)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Type::Array(_binding_0) => {
-            v.visit_type_array_mut(_binding_0);
-        }
-        Type::BareFn(_binding_0) => {
-            v.visit_type_bare_fn_mut(_binding_0);
-        }
-        Type::Group(_binding_0) => {
-            v.visit_type_group_mut(_binding_0);
-        }
-        Type::ImplTrait(_binding_0) => {
-            v.visit_type_impl_trait_mut(_binding_0);
-        }
-        Type::Infer(_binding_0) => {
-            v.visit_type_infer_mut(_binding_0);
-        }
-        Type::Macro(_binding_0) => {
-            v.visit_type_macro_mut(_binding_0);
-        }
-        Type::Never(_binding_0) => {
-            v.visit_type_never_mut(_binding_0);
-        }
-        Type::Paren(_binding_0) => {
-            v.visit_type_paren_mut(_binding_0);
-        }
-        Type::Path(_binding_0) => {
-            v.visit_type_path_mut(_binding_0);
-        }
-        Type::Ptr(_binding_0) => {
-            v.visit_type_ptr_mut(_binding_0);
-        }
-        Type::Reference(_binding_0) => {
-            v.visit_type_reference_mut(_binding_0);
-        }
-        Type::Slice(_binding_0) => {
-            v.visit_type_slice_mut(_binding_0);
-        }
-        Type::TraitObject(_binding_0) => {
-            v.visit_type_trait_object_mut(_binding_0);
-        }
-        Type::Tuple(_binding_0) => {
-            v.visit_type_tuple_mut(_binding_0);
-        }
-        Type::Verbatim(_binding_0) => {
-            skip!(_binding_0);
-        }
-        _ => unreachable!(),
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_array_mut<V>(v: &mut V, node: &mut TypeArray)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.bracket_token.span);
-    v.visit_type_mut(&mut *node.elem);
-    tokens_helper(v, &mut node.semi_token.spans);
-    v.visit_expr_mut(&mut node.len);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_bare_fn_mut<V>(v: &mut V, node: &mut TypeBareFn)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it);
-    };
-    if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.abi {
-        v.visit_abi_mut(it);
-    };
-    tokens_helper(v, &mut node.fn_token.span);
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.inputs) {
-        let (it, p) = el.into_tuple();
-        v.visit_bare_fn_arg_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.variadic {
-        v.visit_variadic_mut(it);
-    };
-    v.visit_return_type_mut(&mut node.output);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_group_mut<V>(v: &mut V, node: &mut TypeGroup)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.group_token.span);
-    v.visit_type_mut(&mut *node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_impl_trait_mut<V>(v: &mut V, node: &mut TypeImplTrait)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.impl_token.span);
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_infer_mut<V>(v: &mut V, node: &mut TypeInfer)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.underscore_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_macro_mut<V>(v: &mut V, node: &mut TypeMacro)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_macro_mut(&mut node.mac);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_never_mut<V>(v: &mut V, node: &mut TypeNever)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.bang_token.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_param_mut<V>(v: &mut V, node: &mut TypeParam)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_ident_mut(&mut node.ident);
-    if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-    if let Some(it) = &mut node.eq_token {
-        tokens_helper(v, &mut it.spans);
-    };
-    if let Some(it) = &mut node.default {
-        v.visit_type_mut(it);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_param_bound_mut<V>(v: &mut V, node: &mut TypeParamBound)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        TypeParamBound::Trait(_binding_0) => {
-            v.visit_trait_bound_mut(_binding_0);
-        }
-        TypeParamBound::Lifetime(_binding_0) => {
-            v.visit_lifetime_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_paren_mut<V>(v: &mut V, node: &mut TypeParen)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.paren_token.span);
-    v.visit_type_mut(&mut *node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_path_mut<V>(v: &mut V, node: &mut TypePath)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it);
-    };
-    v.visit_path_mut(&mut node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_ptr_mut<V>(v: &mut V, node: &mut TypePtr)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.star_token.spans);
-    if let Some(it) = &mut node.const_token {
-        tokens_helper(v, &mut it.span);
-    };
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_type_mut(&mut *node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_reference_mut<V>(v: &mut V, node: &mut TypeReference)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.and_token.spans);
-    if let Some(it) = &mut node.lifetime {
-        v.visit_lifetime_mut(it);
-    };
-    if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_type_mut(&mut *node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_slice_mut<V>(v: &mut V, node: &mut TypeSlice)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.bracket_token.span);
-    v.visit_type_mut(&mut *node.elem);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_trait_object_mut<V>(v: &mut V, node: &mut TypeTraitObject)
-where
-    V: VisitMut + ?Sized,
-{
-    if let Some(it) = &mut node.dyn_token {
-        tokens_helper(v, &mut it.span);
-    };
-    for el in Punctuated::pairs_mut(&mut node.bounds) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_param_bound_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_type_tuple_mut<V>(v: &mut V, node: &mut TypeTuple)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.paren_token.span);
-    for el in Punctuated::pairs_mut(&mut node.elems) {
-        let (it, p) = el.into_tuple();
-        v.visit_type_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_un_op_mut<V>(v: &mut V, node: &mut UnOp)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        UnOp::Deref(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        UnOp::Not(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-        UnOp::Neg(_binding_0) => {
-            tokens_helper(v, &mut _binding_0.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_use_glob_mut<V>(v: &mut V, node: &mut UseGlob)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.star_token.spans);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_group_mut<V>(v: &mut V, node: &mut UseGroup)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.brace_token.span);
-    for el in Punctuated::pairs_mut(&mut node.items) {
-        let (it, p) = el.into_tuple();
-        v.visit_use_tree_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(feature = "full")]
-pub fn visit_use_name_mut<V>(v: &mut V, node: &mut UseName)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_path_mut<V>(v: &mut V, node: &mut UsePath)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.colon2_token.spans);
-    v.visit_use_tree_mut(&mut *node.tree);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_rename_mut<V>(v: &mut V, node: &mut UseRename)
-where
-    V: VisitMut + ?Sized,
-{
-    v.visit_ident_mut(&mut node.ident);
-    tokens_helper(v, &mut node.as_token.span);
-    v.visit_ident_mut(&mut node.rename);
-}
-#[cfg(feature = "full")]
-pub fn visit_use_tree_mut<V>(v: &mut V, node: &mut UseTree)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        UseTree::Path(_binding_0) => {
-            v.visit_use_path_mut(_binding_0);
-        }
-        UseTree::Name(_binding_0) => {
-            v.visit_use_name_mut(_binding_0);
-        }
-        UseTree::Rename(_binding_0) => {
-            v.visit_use_rename_mut(_binding_0);
-        }
-        UseTree::Glob(_binding_0) => {
-            v.visit_use_glob_mut(_binding_0);
-        }
-        UseTree::Group(_binding_0) => {
-            v.visit_use_group_mut(_binding_0);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_variadic_mut<V>(v: &mut V, node: &mut Variadic)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    tokens_helper(v, &mut node.dots.spans);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_variant_mut<V>(v: &mut V, node: &mut Variant)
-where
-    V: VisitMut + ?Sized,
-{
-    for it in &mut node.attrs {
-        v.visit_attribute_mut(it);
-    }
-    v.visit_ident_mut(&mut node.ident);
-    v.visit_fields_mut(&mut node.fields);
-    if let Some(it) = &mut node.discriminant {
-        tokens_helper(v, &mut (it).0.spans);
-        v.visit_expr_mut(&mut (it).1);
-    };
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_crate_mut<V>(v: &mut V, node: &mut VisCrate)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.crate_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_public_mut<V>(v: &mut V, node: &mut VisPublic)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.pub_token.span);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_vis_restricted_mut<V>(v: &mut V, node: &mut VisRestricted)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.pub_token.span);
-    tokens_helper(v, &mut node.paren_token.span);
-    if let Some(it) = &mut node.in_token {
-        tokens_helper(v, &mut it.span);
-    };
-    v.visit_path_mut(&mut *node.path);
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_visibility_mut<V>(v: &mut V, node: &mut Visibility)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        Visibility::Public(_binding_0) => {
-            v.visit_vis_public_mut(_binding_0);
-        }
-        Visibility::Crate(_binding_0) => {
-            v.visit_vis_crate_mut(_binding_0);
-        }
-        Visibility::Restricted(_binding_0) => {
-            v.visit_vis_restricted_mut(_binding_0);
-        }
-        Visibility::Inherited => {}
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_where_clause_mut<V>(v: &mut V, node: &mut WhereClause)
-where
-    V: VisitMut + ?Sized,
-{
-    tokens_helper(v, &mut node.where_token.span);
-    for el in Punctuated::pairs_mut(&mut node.predicates) {
-        let (it, p) = el.into_tuple();
-        v.visit_where_predicate_mut(it);
-        if let Some(p) = p {
-            tokens_helper(v, &mut p.spans);
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-pub fn visit_where_predicate_mut<V>(v: &mut V, node: &mut WherePredicate)
-where
-    V: VisitMut + ?Sized,
-{
-    match node {
-        WherePredicate::Type(_binding_0) => {
-            v.visit_predicate_type_mut(_binding_0);
-        }
-        WherePredicate::Lifetime(_binding_0) => {
-            v.visit_predicate_lifetime_mut(_binding_0);
-        }
-        WherePredicate::Eq(_binding_0) => {
-            v.visit_predicate_eq_mut(_binding_0);
-        }
-    }
-}
diff --git a/vendor/syn/src/gen_helper.rs b/vendor/syn/src/gen_helper.rs
deleted file mode 100644
index b2796126..00000000
--- a/vendor/syn/src/gen_helper.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-#[cfg(feature = "fold")]
-pub mod fold {
-    use crate::fold::Fold;
-    use crate::punctuated::{Pair, Punctuated};
-    use proc_macro2::Span;
-
-    pub trait FoldHelper {
-        type Item;
-        fn lift<F>(self, f: F) -> Self
-        where
-            F: FnMut(Self::Item) -> Self::Item;
-    }
-
-    impl<T> FoldHelper for Vec<T> {
-        type Item = T;
-        fn lift<F>(self, f: F) -> Self
-        where
-            F: FnMut(Self::Item) -> Self::Item,
-        {
-            self.into_iter().map(f).collect()
-        }
-    }
-
-    impl<T, U> FoldHelper for Punctuated<T, U> {
-        type Item = T;
-        fn lift<F>(self, mut f: F) -> Self
-        where
-            F: FnMut(Self::Item) -> Self::Item,
-        {
-            self.into_pairs()
-                .map(Pair::into_tuple)
-                .map(|(t, u)| Pair::new(f(t), u))
-                .collect()
-        }
-    }
-
-    pub fn tokens_helper<F: Fold + ?Sized, S: Spans>(folder: &mut F, spans: &S) -> S {
-        spans.fold(folder)
-    }
-
-    pub trait Spans {
-        fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self;
-    }
-
-    impl Spans for Span {
-        fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
-            folder.fold_span(*self)
-        }
-    }
-
-    impl Spans for [Span; 1] {
-        fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
-            [folder.fold_span(self[0])]
-        }
-    }
-
-    impl Spans for [Span; 2] {
-        fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
-            [folder.fold_span(self[0]), folder.fold_span(self[1])]
-        }
-    }
-
-    impl Spans for [Span; 3] {
-        fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
-            [
-                folder.fold_span(self[0]),
-                folder.fold_span(self[1]),
-                folder.fold_span(self[2]),
-            ]
-        }
-    }
-}
-
-#[cfg(feature = "visit")]
-pub mod visit {
-    use crate::visit::Visit;
-    use proc_macro2::Span;
-
-    pub fn tokens_helper<'ast, V: Visit<'ast> + ?Sized, S: Spans>(visitor: &mut V, spans: &S) {
-        spans.visit(visitor);
-    }
-
-    pub trait Spans {
-        fn visit<'ast, V: Visit<'ast> + ?Sized>(&self, visitor: &mut V);
-    }
-
-    impl Spans for Span {
-        fn visit<'ast, V: Visit<'ast> + ?Sized>(&self, visitor: &mut V) {
-            visitor.visit_span(self);
-        }
-    }
-
-    impl Spans for [Span; 1] {
-        fn visit<'ast, V: Visit<'ast> + ?Sized>(&self, visitor: &mut V) {
-            visitor.visit_span(&self[0]);
-        }
-    }
-
-    impl Spans for [Span; 2] {
-        fn visit<'ast, V: Visit<'ast> + ?Sized>(&self, visitor: &mut V) {
-            visitor.visit_span(&self[0]);
-            visitor.visit_span(&self[1]);
-        }
-    }
-
-    impl Spans for [Span; 3] {
-        fn visit<'ast, V: Visit<'ast> + ?Sized>(&self, visitor: &mut V) {
-            visitor.visit_span(&self[0]);
-            visitor.visit_span(&self[1]);
-            visitor.visit_span(&self[2]);
-        }
-    }
-}
-
-#[cfg(feature = "visit-mut")]
-pub mod visit_mut {
-    use crate::visit_mut::VisitMut;
-    use proc_macro2::Span;
-
-    pub fn tokens_helper<V: VisitMut + ?Sized, S: Spans>(visitor: &mut V, spans: &mut S) {
-        spans.visit_mut(visitor);
-    }
-
-    pub trait Spans {
-        fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V);
-    }
-
-    impl Spans for Span {
-        fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
-            visitor.visit_span_mut(self);
-        }
-    }
-
-    impl Spans for [Span; 1] {
-        fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
-            visitor.visit_span_mut(&mut self[0]);
-        }
-    }
-
-    impl Spans for [Span; 2] {
-        fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
-            visitor.visit_span_mut(&mut self[0]);
-            visitor.visit_span_mut(&mut self[1]);
-        }
-    }
-
-    impl Spans for [Span; 3] {
-        fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
-            visitor.visit_span_mut(&mut self[0]);
-            visitor.visit_span_mut(&mut self[1]);
-            visitor.visit_span_mut(&mut self[2]);
-        }
-    }
-}
diff --git a/vendor/syn/src/generics.rs b/vendor/syn/src/generics.rs
deleted file mode 100644
index 0950c1cb..00000000
--- a/vendor/syn/src/generics.rs
+++ /dev/null
@@ -1,1290 +0,0 @@
-use super::*;
-use crate::punctuated::{Iter, IterMut, Punctuated};
-#[cfg(all(feature = "printing", feature = "extra-traits"))]
-use std::fmt::{self, Debug};
-#[cfg(all(feature = "printing", feature = "extra-traits"))]
-use std::hash::{Hash, Hasher};
-
-ast_struct! {
-    /// Lifetimes and type parameters attached to a declaration of a function,
-    /// enum, trait, etc.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Generics {
-        pub lt_token: Option<Token![<]>,
-        pub params: Punctuated<GenericParam, Token![,]>,
-        pub gt_token: Option<Token![>]>,
-        pub where_clause: Option<WhereClause>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// A generic type parameter, lifetime, or const generic: `T: Into<String>`,
-    /// `'a: 'b`, `const LEN: usize`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum GenericParam {
-        /// A generic type parameter: `T: Into<String>`.
-        Type(TypeParam),
-
-        /// A lifetime definition: `'a: 'b + 'c + 'd`.
-        Lifetime(LifetimeDef),
-
-        /// A const generic parameter: `const LENGTH: usize`.
-        Const(ConstParam),
-    }
-}
-
-ast_struct! {
-    /// A generic type parameter: `T: Into<String>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeParam {
-        pub attrs: Vec<Attribute>,
-        pub ident: Ident,
-        pub colon_token: Option<Token![:]>,
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-        pub eq_token: Option<Token![=]>,
-        pub default: Option<Type>,
-    }
-}
-
-ast_struct! {
-    /// A lifetime definition: `'a: 'b + 'c + 'd`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct LifetimeDef {
-        pub attrs: Vec<Attribute>,
-        pub lifetime: Lifetime,
-        pub colon_token: Option<Token![:]>,
-        pub bounds: Punctuated<Lifetime, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// A const generic parameter: `const LENGTH: usize`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ConstParam {
-        pub attrs: Vec<Attribute>,
-        pub const_token: Token![const],
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Type,
-        pub eq_token: Option<Token![=]>,
-        pub default: Option<Expr>,
-    }
-}
-
-impl Default for Generics {
-    fn default() -> Self {
-        Generics {
-            lt_token: None,
-            params: Punctuated::new(),
-            gt_token: None,
-            where_clause: None,
-        }
-    }
-}
-
-impl Generics {
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
-    ///   href="struct.TypeParam.html"><code
-    ///   style="padding-left:0;padding-right:0;">TypeParam</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the type parameters in `self.params`.
-    pub fn type_params(&self) -> TypeParams {
-        TypeParams(self.params.iter())
-    }
-
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
-    ///   href="struct.TypeParam.html"><code
-    ///   style="padding-left:0;padding-right:0;">TypeParam</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the type parameters in `self.params`.
-    pub fn type_params_mut(&mut self) -> TypeParamsMut {
-        TypeParamsMut(self.params.iter_mut())
-    }
-
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
-    ///   href="struct.LifetimeDef.html"><code
-    ///   style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the lifetime parameters in `self.params`.
-    pub fn lifetimes(&self) -> Lifetimes {
-        Lifetimes(self.params.iter())
-    }
-
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
-    ///   href="struct.LifetimeDef.html"><code
-    ///   style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the lifetime parameters in `self.params`.
-    pub fn lifetimes_mut(&mut self) -> LifetimesMut {
-        LifetimesMut(self.params.iter_mut())
-    }
-
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
-    ///   href="struct.ConstParam.html"><code
-    ///   style="padding-left:0;padding-right:0;">ConstParam</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the constant parameters in `self.params`.
-    pub fn const_params(&self) -> ConstParams {
-        ConstParams(self.params.iter())
-    }
-
-    /// Returns an
-    /// <code
-    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
-    ///   href="struct.ConstParam.html"><code
-    ///   style="padding-left:0;padding-right:0;">ConstParam</code></a><code
-    ///   style="padding-left:0;">&gt;</code>
-    /// over the constant parameters in `self.params`.
-    pub fn const_params_mut(&mut self) -> ConstParamsMut {
-        ConstParamsMut(self.params.iter_mut())
-    }
-
-    /// Initializes an empty `where`-clause if there is not one present already.
-    pub fn make_where_clause(&mut self) -> &mut WhereClause {
-        self.where_clause.get_or_insert_with(|| WhereClause {
-            where_token: <Token![where]>::default(),
-            predicates: Punctuated::new(),
-        })
-    }
-}
-
-pub struct TypeParams<'a>(Iter<'a, GenericParam>);
-
-impl<'a> Iterator for TypeParams<'a> {
-    type Item = &'a TypeParam;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Type(type_param) = next {
-            Some(type_param)
-        } else {
-            self.next()
-        }
-    }
-}
-
-pub struct TypeParamsMut<'a>(IterMut<'a, GenericParam>);
-
-impl<'a> Iterator for TypeParamsMut<'a> {
-    type Item = &'a mut TypeParam;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Type(type_param) = next {
-            Some(type_param)
-        } else {
-            self.next()
-        }
-    }
-}
-
-pub struct Lifetimes<'a>(Iter<'a, GenericParam>);
-
-impl<'a> Iterator for Lifetimes<'a> {
-    type Item = &'a LifetimeDef;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Lifetime(lifetime) = next {
-            Some(lifetime)
-        } else {
-            self.next()
-        }
-    }
-}
-
-pub struct LifetimesMut<'a>(IterMut<'a, GenericParam>);
-
-impl<'a> Iterator for LifetimesMut<'a> {
-    type Item = &'a mut LifetimeDef;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Lifetime(lifetime) = next {
-            Some(lifetime)
-        } else {
-            self.next()
-        }
-    }
-}
-
-pub struct ConstParams<'a>(Iter<'a, GenericParam>);
-
-impl<'a> Iterator for ConstParams<'a> {
-    type Item = &'a ConstParam;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Const(const_param) = next {
-            Some(const_param)
-        } else {
-            self.next()
-        }
-    }
-}
-
-pub struct ConstParamsMut<'a>(IterMut<'a, GenericParam>);
-
-impl<'a> Iterator for ConstParamsMut<'a> {
-    type Item = &'a mut ConstParam;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let next = match self.0.next() {
-            Some(item) => item,
-            None => return None,
-        };
-        if let GenericParam::Const(const_param) = next {
-            Some(const_param)
-        } else {
-            self.next()
-        }
-    }
-}
-
-/// Returned by `Generics::split_for_impl`.
-///
-/// *This type is available only if Syn is built with the `"derive"` or `"full"`
-/// feature and the `"printing"` feature.*
-#[cfg(feature = "printing")]
-#[cfg_attr(
-    doc_cfg,
-    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
-)]
-pub struct ImplGenerics<'a>(&'a Generics);
-
-/// Returned by `Generics::split_for_impl`.
-///
-/// *This type is available only if Syn is built with the `"derive"` or `"full"`
-/// feature and the `"printing"` feature.*
-#[cfg(feature = "printing")]
-#[cfg_attr(
-    doc_cfg,
-    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
-)]
-pub struct TypeGenerics<'a>(&'a Generics);
-
-/// Returned by `TypeGenerics::as_turbofish`.
-///
-/// *This type is available only if Syn is built with the `"derive"` or `"full"`
-/// feature and the `"printing"` feature.*
-#[cfg(feature = "printing")]
-#[cfg_attr(
-    doc_cfg,
-    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
-)]
-pub struct Turbofish<'a>(&'a Generics);
-
-#[cfg(feature = "printing")]
-impl Generics {
-    /// Split a type's generics into the pieces required for impl'ing a trait
-    /// for that type.
-    ///
-    /// ```
-    /// # use proc_macro2::{Span, Ident};
-    /// # use quote::quote;
-    /// #
-    /// # let generics: syn::Generics = Default::default();
-    /// # let name = Ident::new("MyType", Span::call_site());
-    /// #
-    /// let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-    /// quote! {
-    ///     impl #impl_generics MyTrait for #name #ty_generics #where_clause {
-    ///         // ...
-    ///     }
-    /// }
-    /// # ;
-    /// ```
-    ///
-    /// *This method is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature and the `"printing"` feature.*
-    #[cfg_attr(
-        doc_cfg,
-        doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
-    )]
-    pub fn split_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) {
-        (
-            ImplGenerics(self),
-            TypeGenerics(self),
-            self.where_clause.as_ref(),
-        )
-    }
-}
-
-#[cfg(feature = "printing")]
-macro_rules! generics_wrapper_impls {
-    ($ty:ident) => {
-        #[cfg(feature = "clone-impls")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-        impl<'a> Clone for $ty<'a> {
-            fn clone(&self) -> Self {
-                $ty(self.0)
-            }
-        }
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl<'a> Debug for $ty<'a> {
-            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter
-                    .debug_tuple(stringify!($ty))
-                    .field(self.0)
-                    .finish()
-            }
-        }
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl<'a> Eq for $ty<'a> {}
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl<'a> PartialEq for $ty<'a> {
-            fn eq(&self, other: &Self) -> bool {
-                self.0 == other.0
-            }
-        }
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl<'a> Hash for $ty<'a> {
-            fn hash<H: Hasher>(&self, state: &mut H) {
-                self.0.hash(state);
-            }
-        }
-    };
-}
-
-#[cfg(feature = "printing")]
-generics_wrapper_impls!(ImplGenerics);
-#[cfg(feature = "printing")]
-generics_wrapper_impls!(TypeGenerics);
-#[cfg(feature = "printing")]
-generics_wrapper_impls!(Turbofish);
-
-#[cfg(feature = "printing")]
-impl<'a> TypeGenerics<'a> {
-    /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.
-    ///
-    /// *This method is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature and the `"printing"` feature.*
-    pub fn as_turbofish(&self) -> Turbofish {
-        Turbofish(self.0)
-    }
-}
-
-ast_struct! {
-    /// A set of bound lifetimes: `for<'a, 'b, 'c>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct BoundLifetimes {
-        pub for_token: Token![for],
-        pub lt_token: Token![<],
-        pub lifetimes: Punctuated<LifetimeDef, Token![,]>,
-        pub gt_token: Token![>],
-    }
-}
-
-impl Default for BoundLifetimes {
-    fn default() -> Self {
-        BoundLifetimes {
-            for_token: Default::default(),
-            lt_token: Default::default(),
-            lifetimes: Punctuated::new(),
-            gt_token: Default::default(),
-        }
-    }
-}
-
-impl LifetimeDef {
-    pub fn new(lifetime: Lifetime) -> Self {
-        LifetimeDef {
-            attrs: Vec::new(),
-            lifetime,
-            colon_token: None,
-            bounds: Punctuated::new(),
-        }
-    }
-}
-
-impl From<Ident> for TypeParam {
-    fn from(ident: Ident) -> Self {
-        TypeParam {
-            attrs: vec![],
-            ident,
-            colon_token: None,
-            bounds: Punctuated::new(),
-            eq_token: None,
-            default: None,
-        }
-    }
-}
-
-ast_enum_of_structs! {
-    /// A trait or lifetime used as a bound on a type parameter.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum TypeParamBound {
-        Trait(TraitBound),
-        Lifetime(Lifetime),
-    }
-}
-
-ast_struct! {
-    /// A trait used as a bound on a type parameter.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TraitBound {
-        pub paren_token: Option<token::Paren>,
-        pub modifier: TraitBoundModifier,
-        /// The `for<'a>` in `for<'a> Foo<&'a T>`
-        pub lifetimes: Option<BoundLifetimes>,
-        /// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`
-        pub path: Path,
-    }
-}
-
-ast_enum! {
-    /// A modifier on a trait bound, currently only used for the `?` in
-    /// `?Sized`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum TraitBoundModifier {
-        None,
-        Maybe(Token![?]),
-    }
-}
-
-ast_struct! {
-    /// A `where` clause in a definition: `where T: Deserialize<'de>, D:
-    /// 'static`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct WhereClause {
-        pub where_token: Token![where],
-        pub predicates: Punctuated<WherePredicate, Token![,]>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// A single predicate in a `where` clause: `T: Deserialize<'de>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum WherePredicate {
-        /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
-        Type(PredicateType),
-
-        /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
-        Lifetime(PredicateLifetime),
-
-        /// An equality predicate in a `where` clause (unsupported).
-        Eq(PredicateEq),
-    }
-}
-
-ast_struct! {
-    /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct PredicateType {
-        /// Any lifetimes from a `for` binding
-        pub lifetimes: Option<BoundLifetimes>,
-        /// The type being bounded
-        pub bounded_ty: Type,
-        pub colon_token: Token![:],
-        /// Trait and lifetime bounds (`Clone+Send+'static`)
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct PredicateLifetime {
-        pub lifetime: Lifetime,
-        pub colon_token: Token![:],
-        pub bounds: Punctuated<Lifetime, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// An equality predicate in a `where` clause (unsupported).
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct PredicateEq {
-        pub lhs_ty: Type,
-        pub eq_token: Token![=],
-        pub rhs_ty: Type,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Generics {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if !input.peek(Token![<]) {
-                return Ok(Generics::default());
-            }
-
-            let lt_token: Token![<] = input.parse()?;
-
-            let mut params = Punctuated::new();
-            loop {
-                if input.peek(Token![>]) {
-                    break;
-                }
-
-                let attrs = input.call(Attribute::parse_outer)?;
-                let lookahead = input.lookahead1();
-                if lookahead.peek(Lifetime) {
-                    params.push_value(GenericParam::Lifetime(LifetimeDef {
-                        attrs,
-                        ..input.parse()?
-                    }));
-                } else if lookahead.peek(Ident) {
-                    params.push_value(GenericParam::Type(TypeParam {
-                        attrs,
-                        ..input.parse()?
-                    }));
-                } else if lookahead.peek(Token![const]) {
-                    params.push_value(GenericParam::Const(ConstParam {
-                        attrs,
-                        ..input.parse()?
-                    }));
-                } else if input.peek(Token![_]) {
-                    params.push_value(GenericParam::Type(TypeParam {
-                        attrs,
-                        ident: input.call(Ident::parse_any)?,
-                        colon_token: None,
-                        bounds: Punctuated::new(),
-                        eq_token: None,
-                        default: None,
-                    }));
-                } else {
-                    return Err(lookahead.error());
-                }
-
-                if input.peek(Token![>]) {
-                    break;
-                }
-                let punct = input.parse()?;
-                params.push_punct(punct);
-            }
-
-            let gt_token: Token![>] = input.parse()?;
-
-            Ok(Generics {
-                lt_token: Some(lt_token),
-                params,
-                gt_token: Some(gt_token),
-                where_clause: None,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for GenericParam {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Ident) {
-                Ok(GenericParam::Type(TypeParam {
-                    attrs,
-                    ..input.parse()?
-                }))
-            } else if lookahead.peek(Lifetime) {
-                Ok(GenericParam::Lifetime(LifetimeDef {
-                    attrs,
-                    ..input.parse()?
-                }))
-            } else if lookahead.peek(Token![const]) {
-                Ok(GenericParam::Const(ConstParam {
-                    attrs,
-                    ..input.parse()?
-                }))
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LifetimeDef {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let has_colon;
-            Ok(LifetimeDef {
-                attrs: input.call(Attribute::parse_outer)?,
-                lifetime: input.parse()?,
-                colon_token: {
-                    if input.peek(Token![:]) {
-                        has_colon = true;
-                        Some(input.parse()?)
-                    } else {
-                        has_colon = false;
-                        None
-                    }
-                },
-                bounds: {
-                    let mut bounds = Punctuated::new();
-                    if has_colon {
-                        loop {
-                            if input.peek(Token![,]) || input.peek(Token![>]) {
-                                break;
-                            }
-                            let value = input.parse()?;
-                            bounds.push_value(value);
-                            if !input.peek(Token![+]) {
-                                break;
-                            }
-                            let punct = input.parse()?;
-                            bounds.push_punct(punct);
-                        }
-                    }
-                    bounds
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for BoundLifetimes {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(BoundLifetimes {
-                for_token: input.parse()?,
-                lt_token: input.parse()?,
-                lifetimes: {
-                    let mut lifetimes = Punctuated::new();
-                    while !input.peek(Token![>]) {
-                        lifetimes.push_value(input.parse()?);
-                        if input.peek(Token![>]) {
-                            break;
-                        }
-                        lifetimes.push_punct(input.parse()?);
-                    }
-                    lifetimes
-                },
-                gt_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Option<BoundLifetimes> {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Token![for]) {
-                input.parse().map(Some)
-            } else {
-                Ok(None)
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeParam {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let ident: Ident = input.parse()?;
-            let colon_token: Option<Token![:]> = input.parse()?;
-
-            let begin_bound = input.fork();
-            let mut is_maybe_const = false;
-            let mut bounds = Punctuated::new();
-            if colon_token.is_some() {
-                loop {
-                    if input.peek(Token![,]) || input.peek(Token![>]) || input.peek(Token![=]) {
-                        break;
-                    }
-                    if input.peek(Token![?]) && input.peek2(Token![const]) {
-                        input.parse::<Token![?]>()?;
-                        input.parse::<Token![const]>()?;
-                        is_maybe_const = true;
-                    }
-                    let value: TypeParamBound = input.parse()?;
-                    bounds.push_value(value);
-                    if !input.peek(Token![+]) {
-                        break;
-                    }
-                    let punct: Token![+] = input.parse()?;
-                    bounds.push_punct(punct);
-                }
-            }
-
-            let mut eq_token: Option<Token![=]> = input.parse()?;
-            let mut default = if eq_token.is_some() {
-                Some(input.parse::<Type>()?)
-            } else {
-                None
-            };
-
-            if is_maybe_const {
-                bounds.clear();
-                eq_token = None;
-                default = Some(Type::Verbatim(verbatim::between(begin_bound, input)));
-            }
-
-            Ok(TypeParam {
-                attrs,
-                ident,
-                colon_token,
-                bounds,
-                eq_token,
-                default,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeParamBound {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Lifetime) {
-                return input.parse().map(TypeParamBound::Lifetime);
-            }
-
-            if input.peek(token::Paren) {
-                let content;
-                let paren_token = parenthesized!(content in input);
-                let mut bound: TraitBound = content.parse()?;
-                bound.paren_token = Some(paren_token);
-                return Ok(TypeParamBound::Trait(bound));
-            }
-
-            input.parse().map(TypeParamBound::Trait)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitBound {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let modifier: TraitBoundModifier = input.parse()?;
-            let lifetimes: Option<BoundLifetimes> = input.parse()?;
-
-            let mut path: Path = input.parse()?;
-            if path.segments.last().unwrap().arguments.is_empty() && input.peek(token::Paren) {
-                let parenthesized = PathArguments::Parenthesized(input.parse()?);
-                path.segments.last_mut().unwrap().arguments = parenthesized;
-            }
-
-            Ok(TraitBound {
-                paren_token: None,
-                modifier,
-                lifetimes,
-                path,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitBoundModifier {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Token![?]) {
-                input.parse().map(TraitBoundModifier::Maybe)
-            } else {
-                Ok(TraitBoundModifier::None)
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ConstParam {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut default = None;
-            Ok(ConstParam {
-                attrs: input.call(Attribute::parse_outer)?,
-                const_token: input.parse()?,
-                ident: input.parse()?,
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                eq_token: {
-                    if input.peek(Token![=]) {
-                        let eq_token = input.parse()?;
-                        default = Some(path::parsing::const_argument(input)?);
-                        Some(eq_token)
-                    } else {
-                        None
-                    }
-                },
-                default,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for WhereClause {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(WhereClause {
-                where_token: input.parse()?,
-                predicates: {
-                    let mut predicates = Punctuated::new();
-                    loop {
-                        if input.is_empty()
-                            || input.peek(token::Brace)
-                            || input.peek(Token![,])
-                            || input.peek(Token![;])
-                            || input.peek(Token![:]) && !input.peek(Token![::])
-                            || input.peek(Token![=])
-                        {
-                            break;
-                        }
-                        let value = input.parse()?;
-                        predicates.push_value(value);
-                        if !input.peek(Token![,]) {
-                            break;
-                        }
-                        let punct = input.parse()?;
-                        predicates.push_punct(punct);
-                    }
-                    predicates
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Option<WhereClause> {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Token![where]) {
-                input.parse().map(Some)
-            } else {
-                Ok(None)
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for WherePredicate {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Lifetime) && input.peek2(Token![:]) {
-                Ok(WherePredicate::Lifetime(PredicateLifetime {
-                    lifetime: input.parse()?,
-                    colon_token: input.parse()?,
-                    bounds: {
-                        let mut bounds = Punctuated::new();
-                        loop {
-                            if input.is_empty()
-                                || input.peek(token::Brace)
-                                || input.peek(Token![,])
-                                || input.peek(Token![;])
-                                || input.peek(Token![:])
-                                || input.peek(Token![=])
-                            {
-                                break;
-                            }
-                            let value = input.parse()?;
-                            bounds.push_value(value);
-                            if !input.peek(Token![+]) {
-                                break;
-                            }
-                            let punct = input.parse()?;
-                            bounds.push_punct(punct);
-                        }
-                        bounds
-                    },
-                }))
-            } else {
-                Ok(WherePredicate::Type(PredicateType {
-                    lifetimes: input.parse()?,
-                    bounded_ty: input.parse()?,
-                    colon_token: input.parse()?,
-                    bounds: {
-                        let mut bounds = Punctuated::new();
-                        loop {
-                            if input.is_empty()
-                                || input.peek(token::Brace)
-                                || input.peek(Token![,])
-                                || input.peek(Token![;])
-                                || input.peek(Token![:]) && !input.peek(Token![::])
-                                || input.peek(Token![=])
-                            {
-                                break;
-                            }
-                            let value = input.parse()?;
-                            bounds.push_value(value);
-                            if !input.peek(Token![+]) {
-                                break;
-                            }
-                            let punct = input.parse()?;
-                            bounds.push_punct(punct);
-                        }
-                        bounds
-                    },
-                }))
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use crate::print::TokensOrDefault;
-    use proc_macro2::TokenStream;
-    #[cfg(feature = "full")]
-    use proc_macro2::TokenTree;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Generics {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            if self.params.is_empty() {
-                return;
-            }
-
-            TokensOrDefault(&self.lt_token).to_tokens(tokens);
-
-            // Print lifetimes before types and consts, regardless of their
-            // order in self.params.
-            //
-            // TODO: ordering rules for const parameters vs type parameters have
-            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
-            let mut trailing_or_empty = true;
-            for param in self.params.pairs() {
-                if let GenericParam::Lifetime(_) = **param.value() {
-                    param.to_tokens(tokens);
-                    trailing_or_empty = param.punct().is_some();
-                }
-            }
-            for param in self.params.pairs() {
-                match **param.value() {
-                    GenericParam::Type(_) | GenericParam::Const(_) => {
-                        if !trailing_or_empty {
-                            <Token![,]>::default().to_tokens(tokens);
-                            trailing_or_empty = true;
-                        }
-                        param.to_tokens(tokens);
-                    }
-                    GenericParam::Lifetime(_) => {}
-                }
-            }
-
-            TokensOrDefault(&self.gt_token).to_tokens(tokens);
-        }
-    }
-
-    impl<'a> ToTokens for ImplGenerics<'a> {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            if self.0.params.is_empty() {
-                return;
-            }
-
-            TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
-
-            // Print lifetimes before types and consts, regardless of their
-            // order in self.params.
-            //
-            // TODO: ordering rules for const parameters vs type parameters have
-            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
-            let mut trailing_or_empty = true;
-            for param in self.0.params.pairs() {
-                if let GenericParam::Lifetime(_) = **param.value() {
-                    param.to_tokens(tokens);
-                    trailing_or_empty = param.punct().is_some();
-                }
-            }
-            for param in self.0.params.pairs() {
-                if let GenericParam::Lifetime(_) = **param.value() {
-                    continue;
-                }
-                if !trailing_or_empty {
-                    <Token![,]>::default().to_tokens(tokens);
-                    trailing_or_empty = true;
-                }
-                match *param.value() {
-                    GenericParam::Lifetime(_) => unreachable!(),
-                    GenericParam::Type(param) => {
-                        // Leave off the type parameter defaults
-                        tokens.append_all(param.attrs.outer());
-                        param.ident.to_tokens(tokens);
-                        if !param.bounds.is_empty() {
-                            TokensOrDefault(&param.colon_token).to_tokens(tokens);
-                            param.bounds.to_tokens(tokens);
-                        }
-                    }
-                    GenericParam::Const(param) => {
-                        // Leave off the const parameter defaults
-                        tokens.append_all(param.attrs.outer());
-                        param.const_token.to_tokens(tokens);
-                        param.ident.to_tokens(tokens);
-                        param.colon_token.to_tokens(tokens);
-                        param.ty.to_tokens(tokens);
-                    }
-                }
-                param.punct().to_tokens(tokens);
-            }
-
-            TokensOrDefault(&self.0.gt_token).to_tokens(tokens);
-        }
-    }
-
-    impl<'a> ToTokens for TypeGenerics<'a> {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            if self.0.params.is_empty() {
-                return;
-            }
-
-            TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
-
-            // Print lifetimes before types and consts, regardless of their
-            // order in self.params.
-            //
-            // TODO: ordering rules for const parameters vs type parameters have
-            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
-            let mut trailing_or_empty = true;
-            for param in self.0.params.pairs() {
-                if let GenericParam::Lifetime(def) = *param.value() {
-                    // Leave off the lifetime bounds and attributes
-                    def.lifetime.to_tokens(tokens);
-                    param.punct().to_tokens(tokens);
-                    trailing_or_empty = param.punct().is_some();
-                }
-            }
-            for param in self.0.params.pairs() {
-                if let GenericParam::Lifetime(_) = **param.value() {
-                    continue;
-                }
-                if !trailing_or_empty {
-                    <Token![,]>::default().to_tokens(tokens);
-                    trailing_or_empty = true;
-                }
-                match *param.value() {
-                    GenericParam::Lifetime(_) => unreachable!(),
-                    GenericParam::Type(param) => {
-                        // Leave off the type parameter defaults
-                        param.ident.to_tokens(tokens);
-                    }
-                    GenericParam::Const(param) => {
-                        // Leave off the const parameter defaults
-                        param.ident.to_tokens(tokens);
-                    }
-                }
-                param.punct().to_tokens(tokens);
-            }
-
-            TokensOrDefault(&self.0.gt_token).to_tokens(tokens);
-        }
-    }
-
-    impl<'a> ToTokens for Turbofish<'a> {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            if !self.0.params.is_empty() {
-                <Token![::]>::default().to_tokens(tokens);
-                TypeGenerics(self.0).to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for BoundLifetimes {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.for_token.to_tokens(tokens);
-            self.lt_token.to_tokens(tokens);
-            self.lifetimes.to_tokens(tokens);
-            self.gt_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LifetimeDef {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.lifetime.to_tokens(tokens);
-            if !self.bounds.is_empty() {
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-                self.bounds.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeParam {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.ident.to_tokens(tokens);
-            if !self.bounds.is_empty() {
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-                self.bounds.to_tokens(tokens);
-            }
-            if let Some(default) = &self.default {
-                #[cfg(feature = "full")]
-                {
-                    if self.eq_token.is_none() {
-                        if let Type::Verbatim(default) = default {
-                            let mut iter = default.clone().into_iter().peekable();
-                            while let Some(token) = iter.next() {
-                                if let TokenTree::Punct(q) = token {
-                                    if q.as_char() == '?' {
-                                        if let Some(TokenTree::Ident(c)) = iter.peek() {
-                                            if c == "const" {
-                                                if self.bounds.is_empty() {
-                                                    TokensOrDefault(&self.colon_token)
-                                                        .to_tokens(tokens);
-                                                }
-                                                return default.to_tokens(tokens);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                TokensOrDefault(&self.eq_token).to_tokens(tokens);
-                default.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitBound {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            let to_tokens = |tokens: &mut TokenStream| {
-                self.modifier.to_tokens(tokens);
-                self.lifetimes.to_tokens(tokens);
-                self.path.to_tokens(tokens);
-            };
-            match &self.paren_token {
-                Some(paren) => paren.surround(tokens, to_tokens),
-                None => to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitBoundModifier {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                TraitBoundModifier::None => {}
-                TraitBoundModifier::Maybe(t) => t.to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ConstParam {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.const_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            if let Some(default) = &self.default {
-                TokensOrDefault(&self.eq_token).to_tokens(tokens);
-                default.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for WhereClause {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            if !self.predicates.is_empty() {
-                self.where_token.to_tokens(tokens);
-                self.predicates.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PredicateType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.lifetimes.to_tokens(tokens);
-            self.bounded_ty.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PredicateLifetime {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.lifetime.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PredicateEq {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.lhs_ty.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.rhs_ty.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/group.rs b/vendor/syn/src/group.rs
deleted file mode 100644
index 6b057101..00000000
--- a/vendor/syn/src/group.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-use crate::error::Result;
-use crate::parse::ParseBuffer;
-use crate::token;
-use proc_macro2::{Delimiter, Span};
-
-// Not public API.
-#[doc(hidden)]
-pub struct Parens<'a> {
-    pub token: token::Paren,
-    pub content: ParseBuffer<'a>,
-}
-
-// Not public API.
-#[doc(hidden)]
-pub struct Braces<'a> {
-    pub token: token::Brace,
-    pub content: ParseBuffer<'a>,
-}
-
-// Not public API.
-#[doc(hidden)]
-pub struct Brackets<'a> {
-    pub token: token::Bracket,
-    pub content: ParseBuffer<'a>,
-}
-
-// Not public API.
-#[cfg(any(feature = "full", feature = "derive"))]
-#[doc(hidden)]
-pub struct Group<'a> {
-    pub token: token::Group,
-    pub content: ParseBuffer<'a>,
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn parse_parens<'a>(input: &ParseBuffer<'a>) -> Result<Parens<'a>> {
-    parse_delimited(input, Delimiter::Parenthesis).map(|(span, content)| Parens {
-        token: token::Paren(span),
-        content,
-    })
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn parse_braces<'a>(input: &ParseBuffer<'a>) -> Result<Braces<'a>> {
-    parse_delimited(input, Delimiter::Brace).map(|(span, content)| Braces {
-        token: token::Brace(span),
-        content,
-    })
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn parse_brackets<'a>(input: &ParseBuffer<'a>) -> Result<Brackets<'a>> {
-    parse_delimited(input, Delimiter::Bracket).map(|(span, content)| Brackets {
-        token: token::Bracket(span),
-        content,
-    })
-}
-
-#[cfg(any(feature = "full", feature = "derive"))]
-pub(crate) fn parse_group<'a>(input: &ParseBuffer<'a>) -> Result<Group<'a>> {
-    parse_delimited(input, Delimiter::None).map(|(span, content)| Group {
-        token: token::Group(span),
-        content,
-    })
-}
-
-fn parse_delimited<'a>(
-    input: &ParseBuffer<'a>,
-    delimiter: Delimiter,
-) -> Result<(Span, ParseBuffer<'a>)> {
-    input.step(|cursor| {
-        if let Some((content, span, rest)) = cursor.group(delimiter) {
-            let scope = crate::buffer::close_span_of_group(*cursor);
-            let nested = crate::parse::advance_step_cursor(cursor, content);
-            let unexpected = crate::parse::get_unexpected(input);
-            let content = crate::parse::new_parse_buffer(scope, nested, unexpected);
-            Ok(((span, content), rest))
-        } else {
-            let message = match delimiter {
-                Delimiter::Parenthesis => "expected parentheses",
-                Delimiter::Brace => "expected curly braces",
-                Delimiter::Bracket => "expected square brackets",
-                Delimiter::None => "expected invisible group",
-            };
-            Err(cursor.error(message))
-        }
-    })
-}
-
-/// Parse a set of parentheses and expose their content to subsequent parsers.
-///
-/// # Example
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// use syn::{parenthesized, token, Ident, Result, Token, Type};
-/// use syn::parse::{Parse, ParseStream};
-/// use syn::punctuated::Punctuated;
-///
-/// // Parse a simplified tuple struct syntax like:
-/// //
-/// //     struct S(A, B);
-/// struct TupleStruct {
-///     struct_token: Token![struct],
-///     ident: Ident,
-///     paren_token: token::Paren,
-///     fields: Punctuated<Type, Token![,]>,
-///     semi_token: Token![;],
-/// }
-///
-/// impl Parse for TupleStruct {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let content;
-///         Ok(TupleStruct {
-///             struct_token: input.parse()?,
-///             ident: input.parse()?,
-///             paren_token: parenthesized!(content in input),
-///             fields: content.parse_terminated(Type::parse)?,
-///             semi_token: input.parse()?,
-///         })
-///     }
-/// }
-/// #
-/// # fn main() {
-/// #     let input = quote! {
-/// #         struct S(A, B);
-/// #     };
-/// #     syn::parse2::<TupleStruct>(input).unwrap();
-/// # }
-/// ```
-#[macro_export]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-macro_rules! parenthesized {
-    ($content:ident in $cursor:expr) => {
-        match $crate::group::parse_parens(&$cursor) {
-            $crate::__private::Ok(parens) => {
-                $content = parens.content;
-                parens.token
-            }
-            $crate::__private::Err(error) => {
-                return $crate::__private::Err(error);
-            }
-        }
-    };
-}
-
-/// Parse a set of curly braces and expose their content to subsequent parsers.
-///
-/// # Example
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// use syn::{braced, token, Ident, Result, Token, Type};
-/// use syn::parse::{Parse, ParseStream};
-/// use syn::punctuated::Punctuated;
-///
-/// // Parse a simplified struct syntax like:
-/// //
-/// //     struct S {
-/// //         a: A,
-/// //         b: B,
-/// //     }
-/// struct Struct {
-///     struct_token: Token![struct],
-///     ident: Ident,
-///     brace_token: token::Brace,
-///     fields: Punctuated<Field, Token![,]>,
-/// }
-///
-/// struct Field {
-///     name: Ident,
-///     colon_token: Token![:],
-///     ty: Type,
-/// }
-///
-/// impl Parse for Struct {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let content;
-///         Ok(Struct {
-///             struct_token: input.parse()?,
-///             ident: input.parse()?,
-///             brace_token: braced!(content in input),
-///             fields: content.parse_terminated(Field::parse)?,
-///         })
-///     }
-/// }
-///
-/// impl Parse for Field {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         Ok(Field {
-///             name: input.parse()?,
-///             colon_token: input.parse()?,
-///             ty: input.parse()?,
-///         })
-///     }
-/// }
-/// #
-/// # fn main() {
-/// #     let input = quote! {
-/// #         struct S {
-/// #             a: A,
-/// #             b: B,
-/// #         }
-/// #     };
-/// #     syn::parse2::<Struct>(input).unwrap();
-/// # }
-/// ```
-#[macro_export]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-macro_rules! braced {
-    ($content:ident in $cursor:expr) => {
-        match $crate::group::parse_braces(&$cursor) {
-            $crate::__private::Ok(braces) => {
-                $content = braces.content;
-                braces.token
-            }
-            $crate::__private::Err(error) => {
-                return $crate::__private::Err(error);
-            }
-        }
-    };
-}
-
-/// Parse a set of square brackets and expose their content to subsequent
-/// parsers.
-///
-/// # Example
-///
-/// ```
-/// # use quote::quote;
-/// #
-/// use proc_macro2::TokenStream;
-/// use syn::{bracketed, token, Result, Token};
-/// use syn::parse::{Parse, ParseStream};
-///
-/// // Parse an outer attribute like:
-/// //
-/// //     #[repr(C, packed)]
-/// struct OuterAttribute {
-///     pound_token: Token![#],
-///     bracket_token: token::Bracket,
-///     content: TokenStream,
-/// }
-///
-/// impl Parse for OuterAttribute {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let content;
-///         Ok(OuterAttribute {
-///             pound_token: input.parse()?,
-///             bracket_token: bracketed!(content in input),
-///             content: content.parse()?,
-///         })
-///     }
-/// }
-/// #
-/// # fn main() {
-/// #     let input = quote! {
-/// #         #[repr(C, packed)]
-/// #     };
-/// #     syn::parse2::<OuterAttribute>(input).unwrap();
-/// # }
-/// ```
-#[macro_export]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-macro_rules! bracketed {
-    ($content:ident in $cursor:expr) => {
-        match $crate::group::parse_brackets(&$cursor) {
-            $crate::__private::Ok(brackets) => {
-                $content = brackets.content;
-                brackets.token
-            }
-            $crate::__private::Err(error) => {
-                return $crate::__private::Err(error);
-            }
-        }
-    };
-}
diff --git a/vendor/syn/src/ident.rs b/vendor/syn/src/ident.rs
deleted file mode 100644
index 61e08877..00000000
--- a/vendor/syn/src/ident.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-#[cfg(feature = "parsing")]
-use crate::buffer::Cursor;
-#[cfg(feature = "parsing")]
-use crate::lookahead;
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, ParseStream, Result};
-#[cfg(feature = "parsing")]
-use crate::token::Token;
-use unicode_xid::UnicodeXID;
-
-pub use proc_macro2::Ident;
-
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[allow(non_snake_case)]
-pub fn Ident(marker: lookahead::TokenMarker) -> Ident {
-    match marker {}
-}
-
-#[cfg(feature = "parsing")]
-fn accept_as_ident(ident: &Ident) -> bool {
-    match ident.to_string().as_str() {
-        "_" |
-        // Based on https://doc.rust-lang.org/grammar.html#keywords
-        // and https://github.com/rust-lang/rfcs/blob/master/text/2421-unreservations-2018.md
-        // and https://github.com/rust-lang/rfcs/blob/master/text/2420-unreserve-proc.md
-        "abstract" | "as" | "become" | "box" | "break" | "const" | "continue" |
-        "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" |
-        "for" | "if" | "impl" | "in" | "let" | "loop" | "macro" | "match" |
-        "mod" | "move" | "mut" | "override" | "priv" | "pub" | "ref" |
-        "return" | "Self" | "self" | "static" | "struct" | "super" | "trait" |
-        "true" | "type" | "typeof" | "unsafe" | "unsized" | "use" | "virtual" |
-        "where" | "while" | "yield" => false,
-        _ => true,
-    }
-}
-
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for Ident {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| {
-            if let Some((ident, rest)) = cursor.ident() {
-                if accept_as_ident(&ident) {
-                    return Ok((ident, rest));
-                }
-            }
-            Err(cursor.error("expected identifier"))
-        })
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl Token for Ident {
-    fn peek(cursor: Cursor) -> bool {
-        if let Some((ident, _rest)) = cursor.ident() {
-            accept_as_ident(&ident)
-        } else {
-            false
-        }
-    }
-
-    fn display() -> &'static str {
-        "identifier"
-    }
-}
-
-macro_rules! ident_from_token {
-    ($token:ident) => {
-        impl From<Token![$token]> for Ident {
-            fn from(token: Token![$token]) -> Ident {
-                Ident::new(stringify!($token), token.span)
-            }
-        }
-    };
-}
-
-ident_from_token!(self);
-ident_from_token!(Self);
-ident_from_token!(super);
-ident_from_token!(crate);
-ident_from_token!(extern);
-
-impl From<Token![_]> for Ident {
-    fn from(token: Token![_]) -> Ident {
-        Ident::new("_", token.span)
-    }
-}
-
-pub fn xid_ok(symbol: &str) -> bool {
-    let mut chars = symbol.chars();
-    let first = chars.next().unwrap();
-    if !(UnicodeXID::is_xid_start(first) || first == '_') {
-        return false;
-    }
-    for ch in chars {
-        if !UnicodeXID::is_xid_continue(ch) {
-            return false;
-        }
-    }
-    true
-}
diff --git a/vendor/syn/src/item.rs b/vendor/syn/src/item.rs
deleted file mode 100644
index 0fd1226a..00000000
--- a/vendor/syn/src/item.rs
+++ /dev/null
@@ -1,3360 +0,0 @@
-use super::*;
-use crate::derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput};
-use crate::punctuated::Punctuated;
-use proc_macro2::TokenStream;
-
-#[cfg(feature = "parsing")]
-use std::mem;
-
-ast_enum_of_structs! {
-    /// Things that can appear directly inside of a module or scope.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum Item {
-        /// A constant item: `const MAX: u16 = 65535`.
-        Const(ItemConst),
-
-        /// An enum definition: `enum Foo<A, B> { A(A), B(B) }`.
-        Enum(ItemEnum),
-
-        /// An `extern crate` item: `extern crate serde`.
-        ExternCrate(ItemExternCrate),
-
-        /// A free-standing function: `fn process(n: usize) -> Result<()> { ...
-        /// }`.
-        Fn(ItemFn),
-
-        /// A block of foreign items: `extern "C" { ... }`.
-        ForeignMod(ItemForeignMod),
-
-        /// An impl block providing trait or associated items: `impl<A> Trait
-        /// for Data<A> { ... }`.
-        Impl(ItemImpl),
-
-        /// A macro invocation, which includes `macro_rules!` definitions.
-        Macro(ItemMacro),
-
-        /// A 2.0-style declarative macro introduced by the `macro` keyword.
-        Macro2(ItemMacro2),
-
-        /// A module or module declaration: `mod m` or `mod m { ... }`.
-        Mod(ItemMod),
-
-        /// A static item: `static BIKE: Shed = Shed(42)`.
-        Static(ItemStatic),
-
-        /// A struct definition: `struct Foo<A> { x: A }`.
-        Struct(ItemStruct),
-
-        /// A trait definition: `pub trait Iterator { ... }`.
-        Trait(ItemTrait),
-
-        /// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
-        TraitAlias(ItemTraitAlias),
-
-        /// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
-        Type(ItemType),
-
-        /// A union definition: `union Foo<A, B> { x: A, y: B }`.
-        Union(ItemUnion),
-
-        /// A use declaration: `use std::collections::HashMap`.
-        Use(ItemUse),
-
-        /// Tokens forming an item not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         Item::Const(e) => {...}
-        //         Item::Enum(e) => {...}
-        //         ...
-        //         Item::Verbatim(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         Item::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, Item will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// A constant item: `const MAX: u16 = 65535`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemConst {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub const_token: Token![const],
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Box<Type>,
-        pub eq_token: Token![=],
-        pub expr: Box<Expr>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// An enum definition: `enum Foo<A, B> { A(A), B(B) }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemEnum {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub enum_token: Token![enum],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub brace_token: token::Brace,
-        pub variants: Punctuated<Variant, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// An `extern crate` item: `extern crate serde`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemExternCrate {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub extern_token: Token![extern],
-        pub crate_token: Token![crate],
-        pub ident: Ident,
-        pub rename: Option<(Token![as], Ident)>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A free-standing function: `fn process(n: usize) -> Result<()> { ...
-    /// }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemFn {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub sig: Signature,
-        pub block: Box<Block>,
-    }
-}
-
-ast_struct! {
-    /// A block of foreign items: `extern "C" { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemForeignMod {
-        pub attrs: Vec<Attribute>,
-        pub abi: Abi,
-        pub brace_token: token::Brace,
-        pub items: Vec<ForeignItem>,
-    }
-}
-
-ast_struct! {
-    /// An impl block providing trait or associated items: `impl<A> Trait
-    /// for Data<A> { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemImpl {
-        pub attrs: Vec<Attribute>,
-        pub defaultness: Option<Token![default]>,
-        pub unsafety: Option<Token![unsafe]>,
-        pub impl_token: Token![impl],
-        pub generics: Generics,
-        /// Trait this impl implements.
-        pub trait_: Option<(Option<Token![!]>, Path, Token![for])>,
-        /// The Self type of the impl.
-        pub self_ty: Box<Type>,
-        pub brace_token: token::Brace,
-        pub items: Vec<ImplItem>,
-    }
-}
-
-ast_struct! {
-    /// A macro invocation, which includes `macro_rules!` definitions.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemMacro {
-        pub attrs: Vec<Attribute>,
-        /// The `example` in `macro_rules! example { ... }`.
-        pub ident: Option<Ident>,
-        pub mac: Macro,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// A 2.0-style declarative macro introduced by the `macro` keyword.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemMacro2 {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub macro_token: Token![macro],
-        pub ident: Ident,
-        pub rules: TokenStream,
-    }
-}
-
-ast_struct! {
-    /// A module or module declaration: `mod m` or `mod m { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemMod {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub mod_token: Token![mod],
-        pub ident: Ident,
-        pub content: Option<(token::Brace, Vec<Item>)>,
-        pub semi: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// A static item: `static BIKE: Shed = Shed(42)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemStatic {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub static_token: Token![static],
-        pub mutability: Option<Token![mut]>,
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Box<Type>,
-        pub eq_token: Token![=],
-        pub expr: Box<Expr>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A struct definition: `struct Foo<A> { x: A }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemStruct {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub struct_token: Token![struct],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub fields: Fields,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// A trait definition: `pub trait Iterator { ... }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemTrait {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub unsafety: Option<Token![unsafe]>,
-        pub auto_token: Option<Token![auto]>,
-        pub trait_token: Token![trait],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub colon_token: Option<Token![:]>,
-        pub supertraits: Punctuated<TypeParamBound, Token![+]>,
-        pub brace_token: token::Brace,
-        pub items: Vec<TraitItem>,
-    }
-}
-
-ast_struct! {
-    /// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemTraitAlias {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub trait_token: Token![trait],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub eq_token: Token![=],
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemType {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub type_token: Token![type],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub eq_token: Token![=],
-        pub ty: Box<Type>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A union definition: `union Foo<A, B> { x: A, y: B }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemUnion {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub union_token: Token![union],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub fields: FieldsNamed,
-    }
-}
-
-ast_struct! {
-    /// A use declaration: `use std::collections::HashMap`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ItemUse {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub use_token: Token![use],
-        pub leading_colon: Option<Token![::]>,
-        pub tree: UseTree,
-        pub semi_token: Token![;],
-    }
-}
-
-impl Item {
-    #[cfg(feature = "parsing")]
-    pub(crate) fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> {
-        match self {
-            Item::ExternCrate(ItemExternCrate { attrs, .. })
-            | Item::Use(ItemUse { attrs, .. })
-            | Item::Static(ItemStatic { attrs, .. })
-            | Item::Const(ItemConst { attrs, .. })
-            | Item::Fn(ItemFn { attrs, .. })
-            | Item::Mod(ItemMod { attrs, .. })
-            | Item::ForeignMod(ItemForeignMod { attrs, .. })
-            | Item::Type(ItemType { attrs, .. })
-            | Item::Struct(ItemStruct { attrs, .. })
-            | Item::Enum(ItemEnum { attrs, .. })
-            | Item::Union(ItemUnion { attrs, .. })
-            | Item::Trait(ItemTrait { attrs, .. })
-            | Item::TraitAlias(ItemTraitAlias { attrs, .. })
-            | Item::Impl(ItemImpl { attrs, .. })
-            | Item::Macro(ItemMacro { attrs, .. })
-            | Item::Macro2(ItemMacro2 { attrs, .. }) => mem::replace(attrs, new),
-            Item::Verbatim(_) => Vec::new(),
-
-            #[cfg(test)]
-            Item::__TestExhaustive(_) => unimplemented!(),
-            #[cfg(not(test))]
-            _ => unreachable!(),
-        }
-    }
-}
-
-impl From<DeriveInput> for Item {
-    fn from(input: DeriveInput) -> Item {
-        match input.data {
-            Data::Struct(data) => Item::Struct(ItemStruct {
-                attrs: input.attrs,
-                vis: input.vis,
-                struct_token: data.struct_token,
-                ident: input.ident,
-                generics: input.generics,
-                fields: data.fields,
-                semi_token: data.semi_token,
-            }),
-            Data::Enum(data) => Item::Enum(ItemEnum {
-                attrs: input.attrs,
-                vis: input.vis,
-                enum_token: data.enum_token,
-                ident: input.ident,
-                generics: input.generics,
-                brace_token: data.brace_token,
-                variants: data.variants,
-            }),
-            Data::Union(data) => Item::Union(ItemUnion {
-                attrs: input.attrs,
-                vis: input.vis,
-                union_token: data.union_token,
-                ident: input.ident,
-                generics: input.generics,
-                fields: data.fields,
-            }),
-        }
-    }
-}
-
-impl From<ItemStruct> for DeriveInput {
-    fn from(input: ItemStruct) -> DeriveInput {
-        DeriveInput {
-            attrs: input.attrs,
-            vis: input.vis,
-            ident: input.ident,
-            generics: input.generics,
-            data: Data::Struct(DataStruct {
-                struct_token: input.struct_token,
-                fields: input.fields,
-                semi_token: input.semi_token,
-            }),
-        }
-    }
-}
-
-impl From<ItemEnum> for DeriveInput {
-    fn from(input: ItemEnum) -> DeriveInput {
-        DeriveInput {
-            attrs: input.attrs,
-            vis: input.vis,
-            ident: input.ident,
-            generics: input.generics,
-            data: Data::Enum(DataEnum {
-                enum_token: input.enum_token,
-                brace_token: input.brace_token,
-                variants: input.variants,
-            }),
-        }
-    }
-}
-
-impl From<ItemUnion> for DeriveInput {
-    fn from(input: ItemUnion) -> DeriveInput {
-        DeriveInput {
-            attrs: input.attrs,
-            vis: input.vis,
-            ident: input.ident,
-            generics: input.generics,
-            data: Data::Union(DataUnion {
-                union_token: input.union_token,
-                fields: input.fields,
-            }),
-        }
-    }
-}
-
-ast_enum_of_structs! {
-    /// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum UseTree {
-        /// A path prefix of imports in a `use` item: `std::...`.
-        Path(UsePath),
-
-        /// An identifier imported by a `use` item: `HashMap`.
-        Name(UseName),
-
-        /// An renamed identifier imported by a `use` item: `HashMap as Map`.
-        Rename(UseRename),
-
-        /// A glob import in a `use` item: `*`.
-        Glob(UseGlob),
-
-        /// A braced group of imports in a `use` item: `{A, B, C}`.
-        Group(UseGroup),
-    }
-}
-
-ast_struct! {
-    /// A path prefix of imports in a `use` item: `std::...`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct UsePath {
-        pub ident: Ident,
-        pub colon2_token: Token![::],
-        pub tree: Box<UseTree>,
-    }
-}
-
-ast_struct! {
-    /// An identifier imported by a `use` item: `HashMap`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct UseName {
-        pub ident: Ident,
-    }
-}
-
-ast_struct! {
-    /// An renamed identifier imported by a `use` item: `HashMap as Map`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct UseRename {
-        pub ident: Ident,
-        pub as_token: Token![as],
-        pub rename: Ident,
-    }
-}
-
-ast_struct! {
-    /// A glob import in a `use` item: `*`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct UseGlob {
-        pub star_token: Token![*],
-    }
-}
-
-ast_struct! {
-    /// A braced group of imports in a `use` item: `{A, B, C}`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct UseGroup {
-        pub brace_token: token::Brace,
-        pub items: Punctuated<UseTree, Token![,]>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// An item within an `extern` block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum ForeignItem {
-        /// A foreign function in an `extern` block.
-        Fn(ForeignItemFn),
-
-        /// A foreign static item in an `extern` block: `static ext: u8`.
-        Static(ForeignItemStatic),
-
-        /// A foreign type in an `extern` block: `type void`.
-        Type(ForeignItemType),
-
-        /// A macro invocation within an extern block.
-        Macro(ForeignItemMacro),
-
-        /// Tokens in an `extern` block not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         ForeignItem::Fn(e) => {...}
-        //         ForeignItem::Static(e) => {...}
-        //         ...
-        //         ForeignItem::Verbatim(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         ForeignItem::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, ForeignItem will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// A foreign function in an `extern` block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ForeignItemFn {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub sig: Signature,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A foreign static item in an `extern` block: `static ext: u8`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ForeignItemStatic {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub static_token: Token![static],
-        pub mutability: Option<Token![mut]>,
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Box<Type>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A foreign type in an `extern` block: `type void`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ForeignItemType {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub type_token: Token![type],
-        pub ident: Ident,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A macro invocation within an extern block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ForeignItemMacro {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// An item declaration within the definition of a trait.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum TraitItem {
-        /// An associated constant within the definition of a trait.
-        Const(TraitItemConst),
-
-        /// A trait method within the definition of a trait.
-        Method(TraitItemMethod),
-
-        /// An associated type within the definition of a trait.
-        Type(TraitItemType),
-
-        /// A macro invocation within the definition of a trait.
-        Macro(TraitItemMacro),
-
-        /// Tokens within the definition of a trait not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         TraitItem::Const(e) => {...}
-        //         TraitItem::Method(e) => {...}
-        //         ...
-        //         TraitItem::Verbatim(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         TraitItem::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, TraitItem will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// An associated constant within the definition of a trait.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct TraitItemConst {
-        pub attrs: Vec<Attribute>,
-        pub const_token: Token![const],
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Type,
-        pub default: Option<(Token![=], Expr)>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A trait method within the definition of a trait.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct TraitItemMethod {
-        pub attrs: Vec<Attribute>,
-        pub sig: Signature,
-        pub default: Option<Block>,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// An associated type within the definition of a trait.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct TraitItemType {
-        pub attrs: Vec<Attribute>,
-        pub type_token: Token![type],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub colon_token: Option<Token![:]>,
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-        pub default: Option<(Token![=], Type)>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A macro invocation within the definition of a trait.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct TraitItemMacro {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// An item within an impl block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum ImplItem {
-        /// An associated constant within an impl block.
-        Const(ImplItemConst),
-
-        /// A method within an impl block.
-        Method(ImplItemMethod),
-
-        /// An associated type within an impl block.
-        Type(ImplItemType),
-
-        /// A macro invocation within an impl block.
-        Macro(ImplItemMacro),
-
-        /// Tokens within an impl block not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         ImplItem::Const(e) => {...}
-        //         ImplItem::Method(e) => {...}
-        //         ...
-        //         ImplItem::Verbatim(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         ImplItem::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, ImplItem will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// An associated constant within an impl block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ImplItemConst {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub defaultness: Option<Token![default]>,
-        pub const_token: Token![const],
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub ty: Type,
-        pub eq_token: Token![=],
-        pub expr: Expr,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A method within an impl block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ImplItemMethod {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub defaultness: Option<Token![default]>,
-        pub sig: Signature,
-        pub block: Block,
-    }
-}
-
-ast_struct! {
-    /// An associated type within an impl block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ImplItemType {
-        pub attrs: Vec<Attribute>,
-        pub vis: Visibility,
-        pub defaultness: Option<Token![default]>,
-        pub type_token: Token![type],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub eq_token: Token![=],
-        pub ty: Type,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// A macro invocation within an impl block.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct ImplItemMacro {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-ast_struct! {
-    /// A function signature in a trait or implementation: `unsafe fn
-    /// initialize(&self)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Signature {
-        pub constness: Option<Token![const]>,
-        pub asyncness: Option<Token![async]>,
-        pub unsafety: Option<Token![unsafe]>,
-        pub abi: Option<Abi>,
-        pub fn_token: Token![fn],
-        pub ident: Ident,
-        pub generics: Generics,
-        pub paren_token: token::Paren,
-        pub inputs: Punctuated<FnArg, Token![,]>,
-        pub variadic: Option<Variadic>,
-        pub output: ReturnType,
-    }
-}
-
-impl Signature {
-    /// A method's `self` receiver, such as `&self` or `self: Box<Self>`.
-    pub fn receiver(&self) -> Option<&FnArg> {
-        let arg = self.inputs.first()?;
-        match arg {
-            FnArg::Receiver(_) => Some(arg),
-            FnArg::Typed(PatType { pat, .. }) => {
-                if let Pat::Ident(PatIdent { ident, .. }) = &**pat {
-                    if ident == "self" {
-                        return Some(arg);
-                    }
-                }
-                None
-            }
-        }
-    }
-}
-
-ast_enum_of_structs! {
-    /// An argument in a function signature: the `n: usize` in `fn f(n: usize)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum FnArg {
-        /// The `self` argument of an associated method, whether taken by value
-        /// or by reference.
-        ///
-        /// Note that `self` receivers with a specified type, such as `self:
-        /// Box<Self>`, are parsed as a `FnArg::Typed`.
-        Receiver(Receiver),
-
-        /// A function argument accepted by pattern and type.
-        Typed(PatType),
-    }
-}
-
-ast_struct! {
-    /// The `self` argument of an associated method, whether taken by value
-    /// or by reference.
-    ///
-    /// Note that `self` receivers with a specified type, such as `self:
-    /// Box<Self>`, are parsed as a `FnArg::Typed`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Receiver {
-        pub attrs: Vec<Attribute>,
-        pub reference: Option<(Token![&], Option<Lifetime>)>,
-        pub mutability: Option<Token![mut]>,
-        pub self_token: Token![self],
-    }
-}
-
-impl Receiver {
-    pub fn lifetime(&self) -> Option<&Lifetime> {
-        self.reference.as_ref()?.1.as_ref()
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::discouraged::Speculative;
-    use crate::parse::{Parse, ParseBuffer, ParseStream, Result};
-    use crate::token::Brace;
-    use proc_macro2::{Delimiter, Group, Punct, Spacing, TokenTree};
-    use std::iter::{self, FromIterator};
-
-    crate::custom_keyword!(existential);
-    crate::custom_keyword!(macro_rules);
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Item {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let begin = input.fork();
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let ahead = input.fork();
-            let vis: Visibility = ahead.parse()?;
-
-            let lookahead = ahead.lookahead1();
-            let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
-                let vis: Visibility = input.parse()?;
-                let sig: Signature = input.parse()?;
-                if input.peek(Token![;]) {
-                    input.parse::<Token![;]>()?;
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
-                } else {
-                    parse_rest_of_fn(input, Vec::new(), vis, sig).map(Item::Fn)
-                }
-            } else if lookahead.peek(Token![extern]) {
-                ahead.parse::<Token![extern]>()?;
-                let lookahead = ahead.lookahead1();
-                if lookahead.peek(Token![crate]) {
-                    input.parse().map(Item::ExternCrate)
-                } else if lookahead.peek(token::Brace) {
-                    input.parse().map(Item::ForeignMod)
-                } else if lookahead.peek(LitStr) {
-                    ahead.parse::<LitStr>()?;
-                    let lookahead = ahead.lookahead1();
-                    if lookahead.peek(token::Brace) {
-                        input.parse().map(Item::ForeignMod)
-                    } else {
-                        Err(lookahead.error())
-                    }
-                } else {
-                    Err(lookahead.error())
-                }
-            } else if lookahead.peek(Token![use]) {
-                input.parse().map(Item::Use)
-            } else if lookahead.peek(Token![static]) {
-                let vis = input.parse()?;
-                let static_token = input.parse()?;
-                let mutability = input.parse()?;
-                let ident = input.parse()?;
-                if input.peek(Token![=]) {
-                    input.parse::<Token![=]>()?;
-                    input.parse::<Expr>()?;
-                    input.parse::<Token![;]>()?;
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
-                } else {
-                    let colon_token = input.parse()?;
-                    let ty = input.parse()?;
-                    if input.peek(Token![;]) {
-                        input.parse::<Token![;]>()?;
-                        Ok(Item::Verbatim(verbatim::between(begin, input)))
-                    } else {
-                        Ok(Item::Static(ItemStatic {
-                            attrs: Vec::new(),
-                            vis,
-                            static_token,
-                            mutability,
-                            ident,
-                            colon_token,
-                            ty,
-                            eq_token: input.parse()?,
-                            expr: input.parse()?,
-                            semi_token: input.parse()?,
-                        }))
-                    }
-                }
-            } else if lookahead.peek(Token![const]) {
-                ahead.parse::<Token![const]>()?;
-                let lookahead = ahead.lookahead1();
-                if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                    let vis = input.parse()?;
-                    let const_token = input.parse()?;
-                    let ident = {
-                        let lookahead = input.lookahead1();
-                        if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                            input.call(Ident::parse_any)?
-                        } else {
-                            return Err(lookahead.error());
-                        }
-                    };
-                    let colon_token = input.parse()?;
-                    let ty = input.parse()?;
-                    if input.peek(Token![;]) {
-                        input.parse::<Token![;]>()?;
-                        Ok(Item::Verbatim(verbatim::between(begin, input)))
-                    } else {
-                        Ok(Item::Const(ItemConst {
-                            attrs: Vec::new(),
-                            vis,
-                            const_token,
-                            ident,
-                            colon_token,
-                            ty,
-                            eq_token: input.parse()?,
-                            expr: input.parse()?,
-                            semi_token: input.parse()?,
-                        }))
-                    }
-                } else {
-                    Err(lookahead.error())
-                }
-            } else if lookahead.peek(Token![unsafe]) {
-                ahead.parse::<Token![unsafe]>()?;
-                let lookahead = ahead.lookahead1();
-                if lookahead.peek(Token![trait])
-                    || lookahead.peek(Token![auto]) && ahead.peek2(Token![trait])
-                {
-                    input.parse().map(Item::Trait)
-                } else if lookahead.peek(Token![impl]) {
-                    let allow_verbatim_impl = true;
-                    if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
-                        Ok(Item::Impl(item))
-                    } else {
-                        Ok(Item::Verbatim(verbatim::between(begin, input)))
-                    }
-                } else if lookahead.peek(Token![extern]) {
-                    input.parse::<Visibility>()?;
-                    input.parse::<Token![unsafe]>()?;
-                    input.parse::<ItemForeignMod>()?;
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
-                } else if lookahead.peek(Token![mod]) {
-                    input.parse::<Visibility>()?;
-                    input.parse::<Token![unsafe]>()?;
-                    input.parse::<ItemMod>()?;
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
-                } else {
-                    Err(lookahead.error())
-                }
-            } else if lookahead.peek(Token![mod]) {
-                input.parse().map(Item::Mod)
-            } else if lookahead.peek(Token![type]) {
-                parse_item_type(begin, input)
-            } else if lookahead.peek(existential) {
-                input.call(item_existential).map(Item::Verbatim)
-            } else if lookahead.peek(Token![struct]) {
-                input.parse().map(Item::Struct)
-            } else if lookahead.peek(Token![enum]) {
-                input.parse().map(Item::Enum)
-            } else if lookahead.peek(Token![union]) && ahead.peek2(Ident) {
-                input.parse().map(Item::Union)
-            } else if lookahead.peek(Token![trait]) {
-                input.call(parse_trait_or_trait_alias)
-            } else if lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) {
-                input.parse().map(Item::Trait)
-            } else if lookahead.peek(Token![impl])
-                || lookahead.peek(Token![default]) && !ahead.peek2(Token![!])
-            {
-                let allow_verbatim_impl = true;
-                if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
-                    Ok(Item::Impl(item))
-                } else {
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
-                }
-            } else if lookahead.peek(Token![macro]) {
-                input.parse().map(Item::Macro2)
-            } else if vis.is_inherited()
-                && (lookahead.peek(Ident)
-                    || lookahead.peek(Token![self])
-                    || lookahead.peek(Token![super])
-                    || lookahead.peek(Token![crate])
-                    || lookahead.peek(Token![::]))
-            {
-                input.parse().map(Item::Macro)
-            } else if ahead.peek(macro_rules) {
-                input.advance_to(&ahead);
-                input.parse::<ItemMacro>()?;
-                Ok(Item::Verbatim(verbatim::between(begin, input)))
-            } else {
-                Err(lookahead.error())
-            }?;
-
-            attrs.extend(item.replace_attrs(Vec::new()));
-            item.replace_attrs(attrs);
-            Ok(item)
-        }
-    }
-
-    struct FlexibleItemType {
-        vis: Visibility,
-        defaultness: Option<Token![default]>,
-        type_token: Token![type],
-        ident: Ident,
-        generics: Generics,
-        colon_token: Option<Token![:]>,
-        bounds: Punctuated<TypeParamBound, Token![+]>,
-        ty: Option<(Token![=], Type)>,
-        semi_token: Token![;],
-    }
-
-    impl Parse for FlexibleItemType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let vis: Visibility = input.parse()?;
-            let defaultness: Option<Token![default]> = input.parse()?;
-            let type_token: Token![type] = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let mut generics: Generics = input.parse()?;
-            let colon_token: Option<Token![:]> = input.parse()?;
-            let mut bounds = Punctuated::new();
-            if colon_token.is_some() {
-                loop {
-                    if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
-                        break;
-                    }
-                    bounds.push_value(input.parse::<TypeParamBound>()?);
-                    if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
-                        break;
-                    }
-                    bounds.push_punct(input.parse::<Token![+]>()?);
-                }
-            }
-            generics.where_clause = input.parse()?;
-            let ty = if let Some(eq_token) = input.parse()? {
-                Some((eq_token, input.parse::<Type>()?))
-            } else {
-                None
-            };
-            let semi_token: Token![;] = input.parse()?;
-
-            Ok(FlexibleItemType {
-                vis,
-                defaultness,
-                type_token,
-                ident,
-                generics,
-                colon_token,
-                bounds,
-                ty,
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let path = input.call(Path::parse_mod_style)?;
-            let bang_token: Token![!] = input.parse()?;
-            let ident: Option<Ident> = input.parse()?;
-            let (delimiter, tokens) = input.call(mac::parse_delimiter)?;
-            let semi_token: Option<Token![;]> = if !delimiter.is_brace() {
-                Some(input.parse()?)
-            } else {
-                None
-            };
-            Ok(ItemMacro {
-                attrs,
-                ident,
-                mac: Macro {
-                    path,
-                    bang_token,
-                    delimiter,
-                    tokens,
-                },
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemMacro2 {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let macro_token: Token![macro] = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let mut rules = TokenStream::new();
-
-            let mut lookahead = input.lookahead1();
-            if lookahead.peek(token::Paren) {
-                let paren_content;
-                let paren_token = parenthesized!(paren_content in input);
-                let args: TokenStream = paren_content.parse()?;
-                let mut args = Group::new(Delimiter::Parenthesis, args);
-                args.set_span(paren_token.span);
-                rules.extend(iter::once(TokenTree::Group(args)));
-                lookahead = input.lookahead1();
-            }
-
-            if lookahead.peek(token::Brace) {
-                let brace_content;
-                let brace_token = braced!(brace_content in input);
-                let body: TokenStream = brace_content.parse()?;
-                let mut body = Group::new(Delimiter::Brace, body);
-                body.set_span(brace_token.span);
-                rules.extend(iter::once(TokenTree::Group(body)));
-            } else {
-                return Err(lookahead.error());
-            }
-
-            Ok(ItemMacro2 {
-                attrs,
-                vis,
-                macro_token,
-                ident,
-                rules,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemExternCrate {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ItemExternCrate {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                extern_token: input.parse()?,
-                crate_token: input.parse()?,
-                ident: {
-                    if input.peek(Token![self]) {
-                        input.call(Ident::parse_any)?
-                    } else {
-                        input.parse()?
-                    }
-                },
-                rename: {
-                    if input.peek(Token![as]) {
-                        let as_token: Token![as] = input.parse()?;
-                        let rename: Ident = if input.peek(Token![_]) {
-                            Ident::from(input.parse::<Token![_]>()?)
-                        } else {
-                            input.parse()?
-                        };
-                        Some((as_token, rename))
-                    } else {
-                        None
-                    }
-                },
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemUse {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ItemUse {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                use_token: input.parse()?,
-                leading_colon: input.parse()?,
-                tree: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for UseTree {
-        fn parse(input: ParseStream) -> Result<UseTree> {
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Ident)
-                || lookahead.peek(Token![self])
-                || lookahead.peek(Token![super])
-                || lookahead.peek(Token![crate])
-            {
-                let ident = input.call(Ident::parse_any)?;
-                if input.peek(Token![::]) {
-                    Ok(UseTree::Path(UsePath {
-                        ident,
-                        colon2_token: input.parse()?,
-                        tree: Box::new(input.parse()?),
-                    }))
-                } else if input.peek(Token![as]) {
-                    Ok(UseTree::Rename(UseRename {
-                        ident,
-                        as_token: input.parse()?,
-                        rename: {
-                            if input.peek(Ident) {
-                                input.parse()?
-                            } else if input.peek(Token![_]) {
-                                Ident::from(input.parse::<Token![_]>()?)
-                            } else {
-                                return Err(input.error("expected identifier or underscore"));
-                            }
-                        },
-                    }))
-                } else {
-                    Ok(UseTree::Name(UseName { ident }))
-                }
-            } else if lookahead.peek(Token![*]) {
-                Ok(UseTree::Glob(UseGlob {
-                    star_token: input.parse()?,
-                }))
-            } else if lookahead.peek(token::Brace) {
-                let content;
-                Ok(UseTree::Group(UseGroup {
-                    brace_token: braced!(content in input),
-                    items: content.parse_terminated(UseTree::parse)?,
-                }))
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemStatic {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ItemStatic {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                static_token: input.parse()?,
-                mutability: input.parse()?,
-                ident: input.parse()?,
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                eq_token: input.parse()?,
-                expr: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemConst {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ItemConst {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                const_token: input.parse()?,
-                ident: {
-                    let lookahead = input.lookahead1();
-                    if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                        input.call(Ident::parse_any)?
-                    } else {
-                        return Err(lookahead.error());
-                    }
-                },
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                eq_token: input.parse()?,
-                expr: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    fn pop_variadic(args: &mut Punctuated<FnArg, Token![,]>) -> Option<Variadic> {
-        let trailing_punct = args.trailing_punct();
-
-        let last = match args.last_mut()? {
-            FnArg::Typed(last) => last,
-            _ => return None,
-        };
-
-        let ty = match last.ty.as_ref() {
-            Type::Verbatim(ty) => ty,
-            _ => return None,
-        };
-
-        let mut variadic = Variadic {
-            attrs: Vec::new(),
-            dots: parse2(ty.clone()).ok()?,
-        };
-
-        if let Pat::Verbatim(pat) = last.pat.as_ref() {
-            if pat.to_string() == "..." && !trailing_punct {
-                variadic.attrs = mem::replace(&mut last.attrs, Vec::new());
-                args.pop();
-            }
-        }
-
-        Some(variadic)
-    }
-
-    fn variadic_to_tokens(dots: &Token![...]) -> TokenStream {
-        TokenStream::from_iter(vec![
-            TokenTree::Punct({
-                let mut dot = Punct::new('.', Spacing::Joint);
-                dot.set_span(dots.spans[0]);
-                dot
-            }),
-            TokenTree::Punct({
-                let mut dot = Punct::new('.', Spacing::Joint);
-                dot.set_span(dots.spans[1]);
-                dot
-            }),
-            TokenTree::Punct({
-                let mut dot = Punct::new('.', Spacing::Alone);
-                dot.set_span(dots.spans[2]);
-                dot
-            }),
-        ])
-    }
-
-    fn peek_signature(input: ParseStream) -> bool {
-        let fork = input.fork();
-        fork.parse::<Option<Token![const]>>().is_ok()
-            && fork.parse::<Option<Token![async]>>().is_ok()
-            && fork.parse::<Option<Token![unsafe]>>().is_ok()
-            && fork.parse::<Option<Abi>>().is_ok()
-            && fork.peek(Token![fn])
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Signature {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let constness: Option<Token![const]> = input.parse()?;
-            let asyncness: Option<Token![async]> = input.parse()?;
-            let unsafety: Option<Token![unsafe]> = input.parse()?;
-            let abi: Option<Abi> = input.parse()?;
-            let fn_token: Token![fn] = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let mut generics: Generics = input.parse()?;
-
-            let content;
-            let paren_token = parenthesized!(content in input);
-            let mut inputs = parse_fn_args(&content)?;
-            let variadic = pop_variadic(&mut inputs);
-
-            let output: ReturnType = input.parse()?;
-            generics.where_clause = input.parse()?;
-
-            Ok(Signature {
-                constness,
-                asyncness,
-                unsafety,
-                abi,
-                fn_token,
-                ident,
-                generics,
-                paren_token,
-                inputs,
-                variadic,
-                output,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemFn {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let sig: Signature = input.parse()?;
-            parse_rest_of_fn(input, outer_attrs, vis, sig)
-        }
-    }
-
-    fn parse_rest_of_fn(
-        input: ParseStream,
-        mut attrs: Vec<Attribute>,
-        vis: Visibility,
-        sig: Signature,
-    ) -> Result<ItemFn> {
-        let content;
-        let brace_token = braced!(content in input);
-        attr::parsing::parse_inner(&content, &mut attrs)?;
-        let stmts = content.call(Block::parse_within)?;
-
-        Ok(ItemFn {
-            attrs,
-            vis,
-            sig,
-            block: Box::new(Block { brace_token, stmts }),
-        })
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for FnArg {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-
-            let ahead = input.fork();
-            if let Ok(mut receiver) = ahead.parse::<Receiver>() {
-                if !ahead.peek(Token![:]) {
-                    input.advance_to(&ahead);
-                    receiver.attrs = attrs;
-                    return Ok(FnArg::Receiver(receiver));
-                }
-            }
-
-            let mut typed = input.call(fn_arg_typed)?;
-            typed.attrs = attrs;
-            Ok(FnArg::Typed(typed))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Receiver {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(Receiver {
-                attrs: Vec::new(),
-                reference: {
-                    if input.peek(Token![&]) {
-                        Some((input.parse()?, input.parse()?))
-                    } else {
-                        None
-                    }
-                },
-                mutability: input.parse()?,
-                self_token: input.parse()?,
-            })
-        }
-    }
-
-    fn parse_fn_args(input: ParseStream) -> Result<Punctuated<FnArg, Token![,]>> {
-        let mut args = Punctuated::new();
-        let mut has_receiver = false;
-
-        while !input.is_empty() {
-            let attrs = input.call(Attribute::parse_outer)?;
-
-            let arg = if let Some(dots) = input.parse::<Option<Token![...]>>()? {
-                FnArg::Typed(PatType {
-                    attrs,
-                    pat: Box::new(Pat::Verbatim(variadic_to_tokens(&dots))),
-                    colon_token: Token![:](dots.spans[0]),
-                    ty: Box::new(Type::Verbatim(variadic_to_tokens(&dots))),
-                })
-            } else {
-                let mut arg: FnArg = input.parse()?;
-                match &mut arg {
-                    FnArg::Receiver(receiver) if has_receiver => {
-                        return Err(Error::new(
-                            receiver.self_token.span,
-                            "unexpected second method receiver",
-                        ));
-                    }
-                    FnArg::Receiver(receiver) if !args.is_empty() => {
-                        return Err(Error::new(
-                            receiver.self_token.span,
-                            "unexpected method receiver",
-                        ));
-                    }
-                    FnArg::Receiver(receiver) => {
-                        has_receiver = true;
-                        receiver.attrs = attrs;
-                    }
-                    FnArg::Typed(arg) => arg.attrs = attrs,
-                }
-                arg
-            };
-            args.push_value(arg);
-
-            if input.is_empty() {
-                break;
-            }
-
-            let comma: Token![,] = input.parse()?;
-            args.push_punct(comma);
-        }
-
-        Ok(args)
-    }
-
-    fn fn_arg_typed(input: ParseStream) -> Result<PatType> {
-        // Hack to parse pre-2018 syntax in
-        // test/ui/rfc-2565-param-attrs/param-attrs-pretty.rs
-        // because the rest of the test case is valuable.
-        if input.peek(Ident) && input.peek2(Token![<]) {
-            let span = input.fork().parse::<Ident>()?.span();
-            return Ok(PatType {
-                attrs: Vec::new(),
-                pat: Box::new(Pat::Wild(PatWild {
-                    attrs: Vec::new(),
-                    underscore_token: Token![_](span),
-                })),
-                colon_token: Token![:](span),
-                ty: input.parse()?,
-            });
-        }
-
-        Ok(PatType {
-            attrs: Vec::new(),
-            pat: Box::new(pat::parsing::multi_pat(input)?),
-            colon_token: input.parse()?,
-            ty: Box::new(match input.parse::<Option<Token![...]>>()? {
-                Some(dot3) => Type::Verbatim(variadic_to_tokens(&dot3)),
-                None => input.parse()?,
-            }),
-        })
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemMod {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let mod_token: Token![mod] = input.parse()?;
-            let ident: Ident = input.parse()?;
-
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Token![;]) {
-                Ok(ItemMod {
-                    attrs,
-                    vis,
-                    mod_token,
-                    ident,
-                    content: None,
-                    semi: Some(input.parse()?),
-                })
-            } else if lookahead.peek(token::Brace) {
-                let content;
-                let brace_token = braced!(content in input);
-                attr::parsing::parse_inner(&content, &mut attrs)?;
-
-                let mut items = Vec::new();
-                while !content.is_empty() {
-                    items.push(content.parse()?);
-                }
-
-                Ok(ItemMod {
-                    attrs,
-                    vis,
-                    mod_token,
-                    ident,
-                    content: Some((brace_token, items)),
-                    semi: None,
-                })
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemForeignMod {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let abi: Abi = input.parse()?;
-
-            let content;
-            let brace_token = braced!(content in input);
-            attr::parsing::parse_inner(&content, &mut attrs)?;
-            let mut items = Vec::new();
-            while !content.is_empty() {
-                items.push(content.parse()?);
-            }
-
-            Ok(ItemForeignMod {
-                attrs,
-                abi,
-                brace_token,
-                items,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ForeignItem {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let begin = input.fork();
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let ahead = input.fork();
-            let vis: Visibility = ahead.parse()?;
-
-            let lookahead = ahead.lookahead1();
-            let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
-                let vis: Visibility = input.parse()?;
-                let sig: Signature = input.parse()?;
-                if input.peek(token::Brace) {
-                    let content;
-                    braced!(content in input);
-                    content.call(Attribute::parse_inner)?;
-                    content.call(Block::parse_within)?;
-
-                    Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
-                } else {
-                    Ok(ForeignItem::Fn(ForeignItemFn {
-                        attrs: Vec::new(),
-                        vis,
-                        sig,
-                        semi_token: input.parse()?,
-                    }))
-                }
-            } else if lookahead.peek(Token![static]) {
-                let vis = input.parse()?;
-                let static_token = input.parse()?;
-                let mutability = input.parse()?;
-                let ident = input.parse()?;
-                let colon_token = input.parse()?;
-                let ty = input.parse()?;
-                if input.peek(Token![=]) {
-                    input.parse::<Token![=]>()?;
-                    input.parse::<Expr>()?;
-                    input.parse::<Token![;]>()?;
-                    Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
-                } else {
-                    Ok(ForeignItem::Static(ForeignItemStatic {
-                        attrs: Vec::new(),
-                        vis,
-                        static_token,
-                        mutability,
-                        ident,
-                        colon_token,
-                        ty,
-                        semi_token: input.parse()?,
-                    }))
-                }
-            } else if lookahead.peek(Token![type]) {
-                parse_foreign_item_type(begin, input)
-            } else if vis.is_inherited()
-                && (lookahead.peek(Ident)
-                    || lookahead.peek(Token![self])
-                    || lookahead.peek(Token![super])
-                    || lookahead.peek(Token![crate])
-                    || lookahead.peek(Token![::]))
-            {
-                input.parse().map(ForeignItem::Macro)
-            } else {
-                Err(lookahead.error())
-            }?;
-
-            let item_attrs = match &mut item {
-                ForeignItem::Fn(item) => &mut item.attrs,
-                ForeignItem::Static(item) => &mut item.attrs,
-                ForeignItem::Type(item) => &mut item.attrs,
-                ForeignItem::Macro(item) => &mut item.attrs,
-                ForeignItem::Verbatim(_) => return Ok(item),
-
-                #[cfg(test)]
-                ForeignItem::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
-                _ => unreachable!(),
-            };
-            attrs.append(item_attrs);
-            *item_attrs = attrs;
-
-            Ok(item)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ForeignItemFn {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let sig: Signature = input.parse()?;
-            let semi_token: Token![;] = input.parse()?;
-            Ok(ForeignItemFn {
-                attrs,
-                vis,
-                sig,
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ForeignItemStatic {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ForeignItemStatic {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                static_token: input.parse()?,
-                mutability: input.parse()?,
-                ident: input.parse()?,
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ForeignItemType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ForeignItemType {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                type_token: input.parse()?,
-                ident: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    fn parse_foreign_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ForeignItem> {
-        let FlexibleItemType {
-            vis,
-            defaultness,
-            type_token,
-            ident,
-            generics,
-            colon_token,
-            bounds: _,
-            ty,
-            semi_token,
-        } = input.parse()?;
-
-        if defaultness.is_some()
-            || generics.lt_token.is_some()
-            || generics.where_clause.is_some()
-            || colon_token.is_some()
-            || ty.is_some()
-        {
-            Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
-        } else {
-            Ok(ForeignItem::Type(ForeignItemType {
-                attrs: Vec::new(),
-                vis,
-                type_token,
-                ident,
-                semi_token,
-            }))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ForeignItemMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let mac: Macro = input.parse()?;
-            let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() {
-                None
-            } else {
-                Some(input.parse()?)
-            };
-            Ok(ForeignItemMacro {
-                attrs,
-                mac,
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ItemType {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                type_token: input.parse()?,
-                ident: input.parse()?,
-                generics: {
-                    let mut generics: Generics = input.parse()?;
-                    generics.where_clause = input.parse()?;
-                    generics
-                },
-                eq_token: input.parse()?,
-                ty: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    fn parse_item_type(begin: ParseBuffer, input: ParseStream) -> Result<Item> {
-        let FlexibleItemType {
-            vis,
-            defaultness,
-            type_token,
-            ident,
-            generics,
-            colon_token,
-            bounds: _,
-            ty,
-            semi_token,
-        } = input.parse()?;
-
-        if defaultness.is_some() || colon_token.is_some() || ty.is_none() {
-            Ok(Item::Verbatim(verbatim::between(begin, input)))
-        } else {
-            let (eq_token, ty) = ty.unwrap();
-            Ok(Item::Type(ItemType {
-                attrs: Vec::new(),
-                vis,
-                type_token,
-                ident,
-                generics,
-                eq_token,
-                ty: Box::new(ty),
-                semi_token,
-            }))
-        }
-    }
-
-    #[cfg(not(feature = "printing"))]
-    fn item_existential(input: ParseStream) -> Result<TokenStream> {
-        Err(input.error("existential type is not supported"))
-    }
-
-    #[cfg(feature = "printing")]
-    fn item_existential(input: ParseStream) -> Result<TokenStream> {
-        use crate::attr::FilterAttrs;
-        use quote::{ToTokens, TokenStreamExt};
-
-        let attrs = input.call(Attribute::parse_outer)?;
-        let vis: Visibility = input.parse()?;
-        let existential_token: existential = input.parse()?;
-        let type_token: Token![type] = input.parse()?;
-        let ident: Ident = input.parse()?;
-
-        let mut generics: Generics = input.parse()?;
-        generics.where_clause = input.parse()?;
-
-        let colon_token: Token![:] = input.parse()?;
-
-        let mut bounds = Punctuated::new();
-        while !input.peek(Token![;]) {
-            if !bounds.is_empty() {
-                bounds.push_punct(input.parse::<Token![+]>()?);
-            }
-            bounds.push_value(input.parse::<TypeParamBound>()?);
-        }
-
-        let semi_token: Token![;] = input.parse()?;
-
-        let mut tokens = TokenStream::new();
-        tokens.append_all(attrs.outer());
-        vis.to_tokens(&mut tokens);
-        existential_token.to_tokens(&mut tokens);
-        type_token.to_tokens(&mut tokens);
-        ident.to_tokens(&mut tokens);
-        generics.to_tokens(&mut tokens);
-        generics.where_clause.to_tokens(&mut tokens);
-        if !bounds.is_empty() {
-            colon_token.to_tokens(&mut tokens);
-            bounds.to_tokens(&mut tokens);
-        }
-        semi_token.to_tokens(&mut tokens);
-        Ok(tokens)
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemStruct {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis = input.parse::<Visibility>()?;
-            let struct_token = input.parse::<Token![struct]>()?;
-            let ident = input.parse::<Ident>()?;
-            let generics = input.parse::<Generics>()?;
-            let (where_clause, fields, semi_token) =
-                derive::parsing::data_struct(input, &mut attrs)?;
-            Ok(ItemStruct {
-                attrs,
-                vis,
-                struct_token,
-                ident,
-                generics: Generics {
-                    where_clause,
-                    ..generics
-                },
-                fields,
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemEnum {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis = input.parse::<Visibility>()?;
-            let enum_token = input.parse::<Token![enum]>()?;
-            let ident = input.parse::<Ident>()?;
-            let generics = input.parse::<Generics>()?;
-            let (where_clause, brace_token, variants) =
-                derive::parsing::data_enum(input, &mut attrs)?;
-            Ok(ItemEnum {
-                attrs,
-                vis,
-                enum_token,
-                ident,
-                generics: Generics {
-                    where_clause,
-                    ..generics
-                },
-                brace_token,
-                variants,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemUnion {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis = input.parse::<Visibility>()?;
-            let union_token = input.parse::<Token![union]>()?;
-            let ident = input.parse::<Ident>()?;
-            let generics = input.parse::<Generics>()?;
-            let (where_clause, fields) = derive::parsing::data_union(input, &mut attrs)?;
-            Ok(ItemUnion {
-                attrs,
-                vis,
-                union_token,
-                ident,
-                generics: Generics {
-                    where_clause,
-                    ..generics
-                },
-                fields,
-            })
-        }
-    }
-
-    fn parse_trait_or_trait_alias(input: ParseStream) -> Result<Item> {
-        let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?;
-        let lookahead = input.lookahead1();
-        if lookahead.peek(token::Brace)
-            || lookahead.peek(Token![:])
-            || lookahead.peek(Token![where])
-        {
-            let unsafety = None;
-            let auto_token = None;
-            parse_rest_of_trait(
-                input,
-                attrs,
-                vis,
-                unsafety,
-                auto_token,
-                trait_token,
-                ident,
-                generics,
-            )
-            .map(Item::Trait)
-        } else if lookahead.peek(Token![=]) {
-            parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics)
-                .map(Item::TraitAlias)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemTrait {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let outer_attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let unsafety: Option<Token![unsafe]> = input.parse()?;
-            let auto_token: Option<Token![auto]> = input.parse()?;
-            let trait_token: Token![trait] = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let generics: Generics = input.parse()?;
-            parse_rest_of_trait(
-                input,
-                outer_attrs,
-                vis,
-                unsafety,
-                auto_token,
-                trait_token,
-                ident,
-                generics,
-            )
-        }
-    }
-
-    fn parse_rest_of_trait(
-        input: ParseStream,
-        mut attrs: Vec<Attribute>,
-        vis: Visibility,
-        unsafety: Option<Token![unsafe]>,
-        auto_token: Option<Token![auto]>,
-        trait_token: Token![trait],
-        ident: Ident,
-        mut generics: Generics,
-    ) -> Result<ItemTrait> {
-        let colon_token: Option<Token![:]> = input.parse()?;
-
-        let mut supertraits = Punctuated::new();
-        if colon_token.is_some() {
-            loop {
-                if input.peek(Token![where]) || input.peek(token::Brace) {
-                    break;
-                }
-                supertraits.push_value(input.parse()?);
-                if input.peek(Token![where]) || input.peek(token::Brace) {
-                    break;
-                }
-                supertraits.push_punct(input.parse()?);
-            }
-        }
-
-        generics.where_clause = input.parse()?;
-
-        let content;
-        let brace_token = braced!(content in input);
-        attr::parsing::parse_inner(&content, &mut attrs)?;
-        let mut items = Vec::new();
-        while !content.is_empty() {
-            items.push(content.parse()?);
-        }
-
-        Ok(ItemTrait {
-            attrs,
-            vis,
-            unsafety,
-            auto_token,
-            trait_token,
-            ident,
-            generics,
-            colon_token,
-            supertraits,
-            brace_token,
-            items,
-        })
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemTraitAlias {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?;
-            parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics)
-        }
-    }
-
-    fn parse_start_of_trait_alias(
-        input: ParseStream,
-    ) -> Result<(Vec<Attribute>, Visibility, Token![trait], Ident, Generics)> {
-        let attrs = input.call(Attribute::parse_outer)?;
-        let vis: Visibility = input.parse()?;
-        let trait_token: Token![trait] = input.parse()?;
-        let ident: Ident = input.parse()?;
-        let generics: Generics = input.parse()?;
-        Ok((attrs, vis, trait_token, ident, generics))
-    }
-
-    fn parse_rest_of_trait_alias(
-        input: ParseStream,
-        attrs: Vec<Attribute>,
-        vis: Visibility,
-        trait_token: Token![trait],
-        ident: Ident,
-        mut generics: Generics,
-    ) -> Result<ItemTraitAlias> {
-        let eq_token: Token![=] = input.parse()?;
-
-        let mut bounds = Punctuated::new();
-        loop {
-            if input.peek(Token![where]) || input.peek(Token![;]) {
-                break;
-            }
-            bounds.push_value(input.parse()?);
-            if input.peek(Token![where]) || input.peek(Token![;]) {
-                break;
-            }
-            bounds.push_punct(input.parse()?);
-        }
-
-        generics.where_clause = input.parse()?;
-        let semi_token: Token![;] = input.parse()?;
-
-        Ok(ItemTraitAlias {
-            attrs,
-            vis,
-            trait_token,
-            ident,
-            generics,
-            eq_token,
-            bounds,
-            semi_token,
-        })
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitItem {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let begin = input.fork();
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let defaultness: Option<Token![default]> = input.parse()?;
-            let ahead = input.fork();
-
-            let lookahead = ahead.lookahead1();
-            let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
-                input.parse().map(TraitItem::Method)
-            } else if lookahead.peek(Token![const]) {
-                ahead.parse::<Token![const]>()?;
-                let lookahead = ahead.lookahead1();
-                if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                    input.parse().map(TraitItem::Const)
-                } else if lookahead.peek(Token![async])
-                    || lookahead.peek(Token![unsafe])
-                    || lookahead.peek(Token![extern])
-                    || lookahead.peek(Token![fn])
-                {
-                    input.parse().map(TraitItem::Method)
-                } else {
-                    Err(lookahead.error())
-                }
-            } else if lookahead.peek(Token![type]) {
-                parse_trait_item_type(begin.fork(), input)
-            } else if lookahead.peek(Ident)
-                || lookahead.peek(Token![self])
-                || lookahead.peek(Token![super])
-                || lookahead.peek(Token![crate])
-                || lookahead.peek(Token![::])
-            {
-                input.parse().map(TraitItem::Macro)
-            } else {
-                Err(lookahead.error())
-            }?;
-
-            match (vis, defaultness) {
-                (Visibility::Inherited, None) => {}
-                _ => return Ok(TraitItem::Verbatim(verbatim::between(begin, input))),
-            }
-
-            let item_attrs = match &mut item {
-                TraitItem::Const(item) => &mut item.attrs,
-                TraitItem::Method(item) => &mut item.attrs,
-                TraitItem::Type(item) => &mut item.attrs,
-                TraitItem::Macro(item) => &mut item.attrs,
-                TraitItem::Verbatim(_) => unreachable!(),
-
-                #[cfg(test)]
-                TraitItem::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
-                _ => unreachable!(),
-            };
-            attrs.append(item_attrs);
-            *item_attrs = attrs;
-            Ok(item)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitItemConst {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TraitItemConst {
-                attrs: input.call(Attribute::parse_outer)?,
-                const_token: input.parse()?,
-                ident: {
-                    let lookahead = input.lookahead1();
-                    if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                        input.call(Ident::parse_any)?
-                    } else {
-                        return Err(lookahead.error());
-                    }
-                },
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                default: {
-                    if input.peek(Token![=]) {
-                        let eq_token: Token![=] = input.parse()?;
-                        let default: Expr = input.parse()?;
-                        Some((eq_token, default))
-                    } else {
-                        None
-                    }
-                },
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitItemMethod {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let sig: Signature = input.parse()?;
-
-            let lookahead = input.lookahead1();
-            let (brace_token, stmts, semi_token) = if lookahead.peek(token::Brace) {
-                let content;
-                let brace_token = braced!(content in input);
-                attr::parsing::parse_inner(&content, &mut attrs)?;
-                let stmts = content.call(Block::parse_within)?;
-                (Some(brace_token), stmts, None)
-            } else if lookahead.peek(Token![;]) {
-                let semi_token: Token![;] = input.parse()?;
-                (None, Vec::new(), Some(semi_token))
-            } else {
-                return Err(lookahead.error());
-            };
-
-            Ok(TraitItemMethod {
-                attrs,
-                sig,
-                default: brace_token.map(|brace_token| Block { brace_token, stmts }),
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitItemType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let type_token: Token![type] = input.parse()?;
-            let ident: Ident = input.parse()?;
-            let mut generics: Generics = input.parse()?;
-            let colon_token: Option<Token![:]> = input.parse()?;
-
-            let mut bounds = Punctuated::new();
-            if colon_token.is_some() {
-                while !input.peek(Token![where]) && !input.peek(Token![=]) && !input.peek(Token![;])
-                {
-                    if !bounds.is_empty() {
-                        bounds.push_punct(input.parse()?);
-                    }
-                    bounds.push_value(input.parse()?);
-                }
-            }
-
-            generics.where_clause = input.parse()?;
-            let default = if input.peek(Token![=]) {
-                let eq_token: Token![=] = input.parse()?;
-                let default: Type = input.parse()?;
-                Some((eq_token, default))
-            } else {
-                None
-            };
-            let semi_token: Token![;] = input.parse()?;
-
-            Ok(TraitItemType {
-                attrs,
-                type_token,
-                ident,
-                generics,
-                colon_token,
-                bounds,
-                default,
-                semi_token,
-            })
-        }
-    }
-
-    fn parse_trait_item_type(begin: ParseBuffer, input: ParseStream) -> Result<TraitItem> {
-        let FlexibleItemType {
-            vis,
-            defaultness,
-            type_token,
-            ident,
-            generics,
-            colon_token,
-            bounds,
-            ty,
-            semi_token,
-        } = input.parse()?;
-
-        if defaultness.is_some() || vis.is_some() {
-            Ok(TraitItem::Verbatim(verbatim::between(begin, input)))
-        } else {
-            Ok(TraitItem::Type(TraitItemType {
-                attrs: Vec::new(),
-                type_token,
-                ident,
-                generics,
-                colon_token,
-                bounds,
-                default: ty,
-                semi_token,
-            }))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TraitItemMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let mac: Macro = input.parse()?;
-            let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() {
-                None
-            } else {
-                Some(input.parse()?)
-            };
-            Ok(TraitItemMacro {
-                attrs,
-                mac,
-                semi_token,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ItemImpl {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_verbatim_impl = false;
-            parse_impl(input, allow_verbatim_impl).map(Option::unwrap)
-        }
-    }
-
-    fn parse_impl(input: ParseStream, allow_verbatim_impl: bool) -> Result<Option<ItemImpl>> {
-        let mut attrs = input.call(Attribute::parse_outer)?;
-        let has_visibility = allow_verbatim_impl && input.parse::<Visibility>()?.is_some();
-        let defaultness: Option<Token![default]> = input.parse()?;
-        let unsafety: Option<Token![unsafe]> = input.parse()?;
-        let impl_token: Token![impl] = input.parse()?;
-
-        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 is_const_impl = allow_verbatim_impl
-            && (input.peek(Token![const]) || input.peek(Token![?]) && input.peek2(Token![const]));
-        if is_const_impl {
-            input.parse::<Option<Token![?]>>()?;
-            input.parse::<Token![const]>()?;
-        }
-
-        let begin = input.fork();
-        let polarity = if input.peek(Token![!]) && !input.peek2(token::Brace) {
-            Some(input.parse::<Token![!]>()?)
-        } else {
-            None
-        };
-
-        #[cfg(not(feature = "printing"))]
-        let first_ty_span = input.span();
-        let mut first_ty: Type = input.parse()?;
-        let self_ty: Type;
-        let trait_;
-
-        let is_impl_for = input.peek(Token![for]);
-        if is_impl_for {
-            let for_token: Token![for] = input.parse()?;
-            let mut first_ty_ref = &first_ty;
-            while let Type::Group(ty) = first_ty_ref {
-                first_ty_ref = &ty.elem;
-            }
-            if let Type::Path(_) = first_ty_ref {
-                while let Type::Group(ty) = first_ty {
-                    first_ty = *ty.elem;
-                }
-                if let Type::Path(TypePath { qself: None, path }) = first_ty {
-                    trait_ = Some((polarity, path, for_token));
-                } else {
-                    unreachable!();
-                }
-            } else if !allow_verbatim_impl {
-                #[cfg(feature = "printing")]
-                return Err(Error::new_spanned(first_ty_ref, "expected trait path"));
-                #[cfg(not(feature = "printing"))]
-                return Err(Error::new(first_ty_span, "expected trait path"));
-            } else {
-                trait_ = None;
-            }
-            self_ty = input.parse()?;
-        } else {
-            trait_ = None;
-            self_ty = if polarity.is_none() {
-                first_ty
-            } else {
-                Type::Verbatim(verbatim::between(begin, input))
-            };
-        }
-
-        generics.where_clause = input.parse()?;
-
-        let content;
-        let brace_token = braced!(content in input);
-        attr::parsing::parse_inner(&content, &mut attrs)?;
-
-        let mut items = Vec::new();
-        while !content.is_empty() {
-            items.push(content.parse()?);
-        }
-
-        if has_visibility || is_const_impl || is_impl_for && trait_.is_none() {
-            Ok(None)
-        } else {
-            Ok(Some(ItemImpl {
-                attrs,
-                defaultness,
-                unsafety,
-                impl_token,
-                generics,
-                trait_,
-                self_ty: Box::new(self_ty),
-                brace_token,
-                items,
-            }))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ImplItem {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let begin = input.fork();
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let ahead = input.fork();
-            let vis: Visibility = ahead.parse()?;
-
-            let mut lookahead = ahead.lookahead1();
-            let defaultness = if lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) {
-                let defaultness: Token![default] = ahead.parse()?;
-                lookahead = ahead.lookahead1();
-                Some(defaultness)
-            } else {
-                None
-            };
-
-            let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
-                input.parse().map(ImplItem::Method)
-            } else if lookahead.peek(Token![const]) {
-                let const_token: Token![const] = ahead.parse()?;
-                let lookahead = ahead.lookahead1();
-                if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                    input.advance_to(&ahead);
-                    let ident: Ident = input.call(Ident::parse_any)?;
-                    let colon_token: Token![:] = input.parse()?;
-                    let ty: Type = input.parse()?;
-                    if let Some(eq_token) = input.parse()? {
-                        return Ok(ImplItem::Const(ImplItemConst {
-                            attrs,
-                            vis,
-                            defaultness,
-                            const_token,
-                            ident,
-                            colon_token,
-                            ty,
-                            eq_token,
-                            expr: input.parse()?,
-                            semi_token: input.parse()?,
-                        }));
-                    } else {
-                        input.parse::<Token![;]>()?;
-                        return Ok(ImplItem::Verbatim(verbatim::between(begin, input)));
-                    }
-                } else {
-                    Err(lookahead.error())
-                }
-            } else if lookahead.peek(Token![type]) {
-                parse_impl_item_type(begin, input)
-            } else if vis.is_inherited() && defaultness.is_none() && lookahead.peek(existential) {
-                input.call(item_existential).map(ImplItem::Verbatim)
-            } else if vis.is_inherited()
-                && defaultness.is_none()
-                && (lookahead.peek(Ident)
-                    || lookahead.peek(Token![self])
-                    || lookahead.peek(Token![super])
-                    || lookahead.peek(Token![crate])
-                    || lookahead.peek(Token![::]))
-            {
-                input.parse().map(ImplItem::Macro)
-            } else {
-                Err(lookahead.error())
-            }?;
-
-            {
-                let item_attrs = match &mut item {
-                    ImplItem::Const(item) => &mut item.attrs,
-                    ImplItem::Method(item) => &mut item.attrs,
-                    ImplItem::Type(item) => &mut item.attrs,
-                    ImplItem::Macro(item) => &mut item.attrs,
-                    ImplItem::Verbatim(_) => return Ok(item),
-
-                    #[cfg(test)]
-                    ImplItem::__TestExhaustive(_) => unimplemented!(),
-                    #[cfg(not(test))]
-                    _ => unreachable!(),
-                };
-                attrs.append(item_attrs);
-                *item_attrs = attrs;
-            }
-
-            Ok(item)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ImplItemConst {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ImplItemConst {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                defaultness: input.parse()?,
-                const_token: input.parse()?,
-                ident: {
-                    let lookahead = input.lookahead1();
-                    if lookahead.peek(Ident) || lookahead.peek(Token![_]) {
-                        input.call(Ident::parse_any)?
-                    } else {
-                        return Err(lookahead.error());
-                    }
-                },
-                colon_token: input.parse()?,
-                ty: input.parse()?,
-                eq_token: input.parse()?,
-                expr: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ImplItemMethod {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let mut attrs = input.call(Attribute::parse_outer)?;
-            let vis: Visibility = input.parse()?;
-            let defaultness: Option<Token![default]> = input.parse()?;
-            let sig: Signature = input.parse()?;
-
-            let block = if let Some(semi) = input.parse::<Option<Token![;]>>()? {
-                // Accept methods without a body in an impl block because
-                // rustc's *parser* does not reject them (the compilation error
-                // is emitted later than parsing) and it can be useful for macro
-                // DSLs.
-                let mut punct = Punct::new(';', Spacing::Alone);
-                punct.set_span(semi.span);
-                let tokens = TokenStream::from_iter(vec![TokenTree::Punct(punct)]);
-                Block {
-                    brace_token: Brace { span: semi.span },
-                    stmts: vec![Stmt::Item(Item::Verbatim(tokens))],
-                }
-            } else {
-                let content;
-                let brace_token = braced!(content in input);
-                attrs.extend(content.call(Attribute::parse_inner)?);
-                Block {
-                    brace_token,
-                    stmts: content.call(Block::parse_within)?,
-                }
-            };
-
-            Ok(ImplItemMethod {
-                attrs,
-                vis,
-                defaultness,
-                sig,
-                block,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ImplItemType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(ImplItemType {
-                attrs: input.call(Attribute::parse_outer)?,
-                vis: input.parse()?,
-                defaultness: input.parse()?,
-                type_token: input.parse()?,
-                ident: input.parse()?,
-                generics: {
-                    let mut generics: Generics = input.parse()?;
-                    generics.where_clause = input.parse()?;
-                    generics
-                },
-                eq_token: input.parse()?,
-                ty: input.parse()?,
-                semi_token: input.parse()?,
-            })
-        }
-    }
-
-    fn parse_impl_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ImplItem> {
-        let FlexibleItemType {
-            vis,
-            defaultness,
-            type_token,
-            ident,
-            generics,
-            colon_token,
-            bounds: _,
-            ty,
-            semi_token,
-        } = input.parse()?;
-
-        if colon_token.is_some() || ty.is_none() {
-            Ok(ImplItem::Verbatim(verbatim::between(begin, input)))
-        } else {
-            let (eq_token, ty) = ty.unwrap();
-            Ok(ImplItem::Type(ImplItemType {
-                attrs: Vec::new(),
-                vis,
-                defaultness,
-                type_token,
-                ident,
-                generics,
-                eq_token,
-                ty,
-                semi_token,
-            }))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ImplItemMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let attrs = input.call(Attribute::parse_outer)?;
-            let mac: Macro = input.parse()?;
-            let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() {
-                None
-            } else {
-                Some(input.parse()?)
-            };
-            Ok(ImplItemMacro {
-                attrs,
-                mac,
-                semi_token,
-            })
-        }
-    }
-
-    impl Visibility {
-        fn is_inherited(&self) -> bool {
-            match *self {
-                Visibility::Inherited => true,
-                _ => false,
-            }
-        }
-    }
-
-    impl MacroDelimiter {
-        fn is_brace(&self) -> bool {
-            match *self {
-                MacroDelimiter::Brace(_) => true,
-                MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => false,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use crate::print::TokensOrDefault;
-    use crate::punctuated::Pair;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemExternCrate {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.extern_token.to_tokens(tokens);
-            self.crate_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            if let Some((as_token, rename)) = &self.rename {
-                as_token.to_tokens(tokens);
-                rename.to_tokens(tokens);
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemUse {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.use_token.to_tokens(tokens);
-            self.leading_colon.to_tokens(tokens);
-            self.tree.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemStatic {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.static_token.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemConst {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.const_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemFn {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.sig.to_tokens(tokens);
-            self.block.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(self.attrs.inner());
-                tokens.append_all(&self.block.stmts);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemMod {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.mod_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            if let Some((brace, items)) = &self.content {
-                brace.surround(tokens, |tokens| {
-                    tokens.append_all(self.attrs.inner());
-                    tokens.append_all(items);
-                });
-            } else {
-                TokensOrDefault(&self.semi).to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemForeignMod {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.abi.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(self.attrs.inner());
-                tokens.append_all(&self.items);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.type_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemEnum {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.enum_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                self.variants.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemStruct {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.struct_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            match &self.fields {
-                Fields::Named(fields) => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    fields.to_tokens(tokens);
-                }
-                Fields::Unnamed(fields) => {
-                    fields.to_tokens(tokens);
-                    self.generics.where_clause.to_tokens(tokens);
-                    TokensOrDefault(&self.semi_token).to_tokens(tokens);
-                }
-                Fields::Unit => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    TokensOrDefault(&self.semi_token).to_tokens(tokens);
-                }
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemUnion {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.union_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.fields.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemTrait {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.unsafety.to_tokens(tokens);
-            self.auto_token.to_tokens(tokens);
-            self.trait_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            if !self.supertraits.is_empty() {
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-                self.supertraits.to_tokens(tokens);
-            }
-            self.generics.where_clause.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(self.attrs.inner());
-                tokens.append_all(&self.items);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemTraitAlias {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.trait_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemImpl {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.defaultness.to_tokens(tokens);
-            self.unsafety.to_tokens(tokens);
-            self.impl_token.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            if let Some((polarity, path, for_token)) = &self.trait_ {
-                polarity.to_tokens(tokens);
-                path.to_tokens(tokens);
-                for_token.to_tokens(tokens);
-            }
-            self.self_ty.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(self.attrs.inner());
-                tokens.append_all(&self.items);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.mac.path.to_tokens(tokens);
-            self.mac.bang_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            match &self.mac.delimiter {
-                MacroDelimiter::Paren(paren) => {
-                    paren.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens));
-                }
-                MacroDelimiter::Brace(brace) => {
-                    brace.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens));
-                }
-                MacroDelimiter::Bracket(bracket) => {
-                    bracket.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens));
-                }
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ItemMacro2 {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.macro_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.rules.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UsePath {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-            self.colon2_token.to_tokens(tokens);
-            self.tree.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UseName {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UseRename {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-            self.as_token.to_tokens(tokens);
-            self.rename.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UseGlob {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.star_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UseGroup {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.brace_token.surround(tokens, |tokens| {
-                self.items.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitItemConst {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.const_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            if let Some((eq_token, default)) = &self.default {
-                eq_token.to_tokens(tokens);
-                default.to_tokens(tokens);
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitItemMethod {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.sig.to_tokens(tokens);
-            match &self.default {
-                Some(block) => {
-                    block.brace_token.surround(tokens, |tokens| {
-                        tokens.append_all(self.attrs.inner());
-                        tokens.append_all(&block.stmts);
-                    });
-                }
-                None => {
-                    TokensOrDefault(&self.semi_token).to_tokens(tokens);
-                }
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitItemType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.type_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            if !self.bounds.is_empty() {
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-                self.bounds.to_tokens(tokens);
-            }
-            self.generics.where_clause.to_tokens(tokens);
-            if let Some((eq_token, default)) = &self.default {
-                eq_token.to_tokens(tokens);
-                default.to_tokens(tokens);
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TraitItemMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.mac.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ImplItemConst {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.defaultness.to_tokens(tokens);
-            self.const_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.expr.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ImplItemMethod {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.defaultness.to_tokens(tokens);
-            self.sig.to_tokens(tokens);
-            if self.block.stmts.len() == 1 {
-                if let Stmt::Item(Item::Verbatim(verbatim)) = &self.block.stmts[0] {
-                    if verbatim.to_string() == ";" {
-                        verbatim.to_tokens(tokens);
-                        return;
-                    }
-                }
-            }
-            self.block.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(self.attrs.inner());
-                tokens.append_all(&self.block.stmts);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ImplItemType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.defaultness.to_tokens(tokens);
-            self.type_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ImplItemMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.mac.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ForeignItemFn {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.sig.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ForeignItemStatic {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.static_token.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ForeignItemType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.vis.to_tokens(tokens);
-            self.type_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ForeignItemMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.mac.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    fn maybe_variadic_to_tokens(arg: &FnArg, tokens: &mut TokenStream) -> bool {
-        let arg = match arg {
-            FnArg::Typed(arg) => arg,
-            FnArg::Receiver(receiver) => {
-                receiver.to_tokens(tokens);
-                return false;
-            }
-        };
-
-        match arg.ty.as_ref() {
-            Type::Verbatim(ty) if ty.to_string() == "..." => {
-                match arg.pat.as_ref() {
-                    Pat::Verbatim(pat) if pat.to_string() == "..." => {
-                        tokens.append_all(arg.attrs.outer());
-                        pat.to_tokens(tokens);
-                    }
-                    _ => arg.to_tokens(tokens),
-                }
-                true
-            }
-            _ => {
-                arg.to_tokens(tokens);
-                false
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Signature {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.constness.to_tokens(tokens);
-            self.asyncness.to_tokens(tokens);
-            self.unsafety.to_tokens(tokens);
-            self.abi.to_tokens(tokens);
-            self.fn_token.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                let mut last_is_variadic = false;
-                for input in self.inputs.pairs() {
-                    match input {
-                        Pair::Punctuated(input, comma) => {
-                            maybe_variadic_to_tokens(input, tokens);
-                            comma.to_tokens(tokens);
-                        }
-                        Pair::End(input) => {
-                            last_is_variadic = maybe_variadic_to_tokens(input, tokens);
-                        }
-                    }
-                }
-                if self.variadic.is_some() && !last_is_variadic {
-                    if !self.inputs.empty_or_trailing() {
-                        <Token![,]>::default().to_tokens(tokens);
-                    }
-                    self.variadic.to_tokens(tokens);
-                }
-            });
-            self.output.to_tokens(tokens);
-            self.generics.where_clause.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Receiver {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            if let Some((ampersand, lifetime)) = &self.reference {
-                ampersand.to_tokens(tokens);
-                lifetime.to_tokens(tokens);
-            }
-            self.mutability.to_tokens(tokens);
-            self.self_token.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/lib.rs b/vendor/syn/src/lib.rs
deleted file mode 100644
index f112f63e..00000000
--- a/vendor/syn/src/lib.rs
+++ /dev/null
@@ -1,1004 +0,0 @@
-//! [![github]](https://github.com/dtolnay/syn)&ensp;[![crates-io]](https://crates.io/crates/syn)&ensp;[![docs-rs]](crate)
-//!
-//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
-//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
-//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K
-//!
-//! <br>
-//!
-//! Syn is a parsing library for parsing a stream of Rust tokens into a syntax
-//! tree of Rust source code.
-//!
-//! Currently this library is geared toward use in Rust procedural macros, but
-//! contains some APIs that may be useful more generally.
-//!
-//! - **Data structures** — Syn provides a complete syntax tree that can
-//!   represent any valid Rust source code. The syntax tree is rooted at
-//!   [`syn::File`] which represents a full source file, but there are other
-//!   entry points that may be useful to procedural macros including
-//!   [`syn::Item`], [`syn::Expr`] and [`syn::Type`].
-//!
-//! - **Derives** — Of particular interest to derive macros is
-//!   [`syn::DeriveInput`] which is any of the three legal input items to a
-//!   derive macro. An example below shows using this type in a library that can
-//!   derive implementations of a user-defined trait.
-//!
-//! - **Parsing** — Parsing in Syn is built around [parser functions] with the
-//!   signature `fn(ParseStream) -> Result<T>`. Every syntax tree node defined
-//!   by Syn is individually parsable and may be used as a building block for
-//!   custom syntaxes, or you may dream up your own brand new syntax without
-//!   involving any of our syntax tree types.
-//!
-//! - **Location information** — Every token parsed by Syn is associated with a
-//!   `Span` that tracks line and column information back to the source of that
-//!   token. These spans allow a procedural macro to display detailed error
-//!   messages pointing to all the right places in the user's code. There is an
-//!   example of this below.
-//!
-//! - **Feature flags** — Functionality is aggressively feature gated so your
-//!   procedural macros enable only what they need, and do not pay in compile
-//!   time for all the rest.
-//!
-//! [`syn::File`]: File
-//! [`syn::Item`]: Item
-//! [`syn::Expr`]: Expr
-//! [`syn::Type`]: Type
-//! [`syn::DeriveInput`]: DeriveInput
-//! [parser functions]: mod@parse
-//!
-//! <br>
-//!
-//! # Example of a derive macro
-//!
-//! The canonical derive macro using Syn looks like this. We write an ordinary
-//! Rust function tagged with a `proc_macro_derive` attribute and the name of
-//! the trait we are deriving. Any time that derive appears in the user's code,
-//! the Rust compiler passes their data structure as tokens into our macro. We
-//! get to execute arbitrary Rust code to figure out what to do with those
-//! tokens, then hand some tokens back to the compiler to compile into the
-//! user's crate.
-//!
-//! [`TokenStream`]: proc_macro::TokenStream
-//!
-//! ```toml
-//! [dependencies]
-//! syn = "1.0"
-//! quote = "1.0"
-//!
-//! [lib]
-//! proc-macro = true
-//! ```
-//!
-//! ```
-//! # extern crate proc_macro;
-//! #
-//! use proc_macro::TokenStream;
-//! use quote::quote;
-//! use syn::{parse_macro_input, DeriveInput};
-//!
-//! # const IGNORE_TOKENS: &str = stringify! {
-//! #[proc_macro_derive(MyMacro)]
-//! # };
-//! pub fn my_macro(input: TokenStream) -> TokenStream {
-//!     // Parse the input tokens into a syntax tree
-//!     let input = parse_macro_input!(input as DeriveInput);
-//!
-//!     // Build the output, possibly using quasi-quotation
-//!     let expanded = quote! {
-//!         // ...
-//!     };
-//!
-//!     // Hand the output tokens back to the compiler
-//!     TokenStream::from(expanded)
-//! }
-//! ```
-//!
-//! The [`heapsize`] example directory shows a complete working implementation
-//! of a derive macro. It works on any Rust compiler 1.31+. The example derives
-//! a `HeapSize` trait which computes an estimate of the amount of heap memory
-//! owned by a value.
-//!
-//! [`heapsize`]: https://github.com/dtolnay/syn/tree/master/examples/heapsize
-//!
-//! ```
-//! pub trait HeapSize {
-//!     /// Total number of bytes of heap memory owned by `self`.
-//!     fn heap_size_of_children(&self) -> usize;
-//! }
-//! ```
-//!
-//! The derive macro allows users to write `#[derive(HeapSize)]` on data
-//! structures in their program.
-//!
-//! ```
-//! # const IGNORE_TOKENS: &str = stringify! {
-//! #[derive(HeapSize)]
-//! # };
-//! struct Demo<'a, T: ?Sized> {
-//!     a: Box<T>,
-//!     b: u8,
-//!     c: &'a str,
-//!     d: String,
-//! }
-//! ```
-//!
-//! <p><br></p>
-//!
-//! # Spans and error reporting
-//!
-//! The token-based procedural macro API provides great control over where the
-//! compiler's error messages are displayed in user code. Consider the error the
-//! user sees if one of their field types does not implement `HeapSize`.
-//!
-//! ```
-//! # const IGNORE_TOKENS: &str = stringify! {
-//! #[derive(HeapSize)]
-//! # };
-//! struct Broken {
-//!     ok: String,
-//!     bad: std::thread::Thread,
-//! }
-//! ```
-//!
-//! By tracking span information all the way through the expansion of a
-//! procedural macro as shown in the `heapsize` example, token-based macros in
-//! Syn are able to trigger errors that directly pinpoint the source of the
-//! problem.
-//!
-//! ```text
-//! error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied
-//!  --> src/main.rs:7:5
-//!   |
-//! 7 |     bad: std::thread::Thread,
-//!   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `Thread`
-//! ```
-//!
-//! <br>
-//!
-//! # Parsing a custom syntax
-//!
-//! The [`lazy-static`] example directory shows the implementation of a
-//! `functionlike!(...)` procedural macro in which the input tokens are parsed
-//! using Syn's parsing API.
-//!
-//! [`lazy-static`]: https://github.com/dtolnay/syn/tree/master/examples/lazy-static
-//!
-//! The example reimplements the popular `lazy_static` crate from crates.io as a
-//! procedural macro.
-//!
-//! ```
-//! # macro_rules! lazy_static {
-//! #     ($($tt:tt)*) => {}
-//! # }
-//! #
-//! lazy_static! {
-//!     static ref USERNAME: Regex = Regex::new("^[a-z0-9_-]{3,16}$").unwrap();
-//! }
-//! ```
-//!
-//! The implementation shows how to trigger custom warnings and error messages
-//! on the macro input.
-//!
-//! ```text
-//! warning: come on, pick a more creative name
-//!   --> src/main.rs:10:16
-//!    |
-//! 10 |     static ref FOO: String = "lazy_static".to_owned();
-//!    |                ^^^
-//! ```
-//!
-//! <br>
-//!
-//! # Testing
-//!
-//! When testing macros, we often care not just that the macro can be used
-//! successfully but also that when the macro is provided with invalid input it
-//! produces maximally helpful error messages. Consider using the [`trybuild`]
-//! crate to write tests for errors that are emitted by your macro or errors
-//! detected by the Rust compiler in the expanded code following misuse of the
-//! macro. Such tests help avoid regressions from later refactors that
-//! mistakenly make an error no longer trigger or be less helpful than it used
-//! to be.
-//!
-//! [`trybuild`]: https://github.com/dtolnay/trybuild
-//!
-//! <br>
-//!
-//! # Debugging
-//!
-//! When developing a procedural macro it can be helpful to look at what the
-//! generated code looks like. Use `cargo rustc -- -Zunstable-options
-//! --pretty=expanded` or the [`cargo expand`] subcommand.
-//!
-//! [`cargo expand`]: https://github.com/dtolnay/cargo-expand
-//!
-//! To show the expanded code for some crate that uses your procedural macro,
-//! run `cargo expand` from that crate. To show the expanded code for one of
-//! your own test cases, run `cargo expand --test the_test_case` where the last
-//! argument is the name of the test file without the `.rs` extension.
-//!
-//! This write-up by Brandon W Maister discusses debugging in more detail:
-//! [Debugging Rust's new Custom Derive system][debugging].
-//!
-//! [debugging]: https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/
-//!
-//! <br>
-//!
-//! # Optional features
-//!
-//! Syn puts a lot of functionality behind optional features in order to
-//! optimize compile time for the most common use cases. The following features
-//! are available.
-//!
-//! - **`derive`** *(enabled by default)* — Data structures for representing the
-//!   possible input to a derive macro, including structs and enums and types.
-//! - **`full`** — Data structures for representing the syntax tree of all valid
-//!   Rust source code, including items and expressions.
-//! - **`parsing`** *(enabled by default)* — Ability to parse input tokens into
-//!   a syntax tree node of a chosen type.
-//! - **`printing`** *(enabled by default)* — Ability to print a syntax tree
-//!   node as tokens of Rust source code.
-//! - **`visit`** — Trait for traversing a syntax tree.
-//! - **`visit-mut`** — Trait for traversing and mutating in place a syntax
-//!   tree.
-//! - **`fold`** — Trait for transforming an owned syntax tree.
-//! - **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree
-//!   types.
-//! - **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree
-//!   types.
-//! - **`proc-macro`** *(enabled by default)* — Runtime dependency on the
-//!   dynamic library libproc_macro from rustc toolchain.
-
-// Syn types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/syn/1.0.75")]
-#![cfg_attr(doc_cfg, feature(doc_cfg))]
-#![allow(non_camel_case_types)]
-// Ignored clippy lints.
-#![allow(
-    clippy::collapsible_match, // https://github.com/rust-lang/rust-clippy/issues/7575
-    clippy::doc_markdown,
-    clippy::eval_order_dependence,
-    clippy::inherent_to_string,
-    clippy::large_enum_variant,
-    clippy::manual_map, // https://github.com/rust-lang/rust-clippy/issues/6795
-    clippy::match_on_vec_items,
-    clippy::missing_panics_doc,
-    clippy::needless_doctest_main,
-    clippy::needless_pass_by_value,
-    clippy::never_loop,
-    clippy::too_many_arguments,
-    clippy::trivially_copy_pass_by_ref,
-    clippy::unnecessary_unwrap,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6983
-    clippy::wrong_self_convention
-)]
-// Ignored clippy_pedantic lints.
-#![allow(
-    clippy::cast_possible_truncation,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7127
-    clippy::cloned_instead_of_copied,
-    clippy::default_trait_access,
-    clippy::empty_enum,
-    clippy::expl_impl_clone_on_copy,
-    clippy::if_not_else,
-    clippy::match_same_arms,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
-    clippy::match_wildcard_for_single_variants,
-    clippy::missing_errors_doc,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::option_if_let_else,
-    clippy::redundant_else,
-    clippy::shadow_unrelated,
-    clippy::similar_names,
-    clippy::single_match_else,
-    clippy::too_many_lines,
-    clippy::unseparated_literal_suffix,
-    clippy::used_underscore_binding,
-    clippy::wildcard_imports
-)]
-
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "proc-macro"
-))]
-extern crate proc_macro;
-extern crate proc_macro2;
-extern crate unicode_xid;
-
-#[cfg(feature = "printing")]
-extern crate quote;
-
-#[macro_use]
-mod macros;
-
-// Not public API.
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[macro_use]
-pub mod group;
-
-#[macro_use]
-pub mod token;
-
-mod ident;
-pub use crate::ident::Ident;
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod attr;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::attr::{
-    AttrStyle, Attribute, AttributeArgs, Meta, MetaList, MetaNameValue, NestedMeta,
-};
-
-mod bigint;
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod data;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::data::{
-    Field, Fields, FieldsNamed, FieldsUnnamed, Variant, VisCrate, VisPublic, VisRestricted,
-    Visibility,
-};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod expr;
-#[cfg(feature = "full")]
-pub use crate::expr::{
-    Arm, FieldValue, GenericMethodArgument, Label, MethodTurbofish, RangeLimits,
-};
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::expr::{
-    Expr, ExprArray, ExprAssign, ExprAssignOp, ExprAsync, ExprAwait, ExprBinary, ExprBlock,
-    ExprBox, ExprBreak, ExprCall, ExprCast, ExprClosure, ExprContinue, ExprField, ExprForLoop,
-    ExprGroup, ExprIf, ExprIndex, ExprLet, ExprLit, ExprLoop, ExprMacro, ExprMatch, ExprMethodCall,
-    ExprParen, ExprPath, ExprRange, ExprReference, ExprRepeat, ExprReturn, ExprStruct, ExprTry,
-    ExprTryBlock, ExprTuple, ExprType, ExprUnary, ExprUnsafe, ExprWhile, ExprYield, Index, Member,
-};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod generics;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::generics::{
-    BoundLifetimes, ConstParam, GenericParam, Generics, LifetimeDef, PredicateEq,
-    PredicateLifetime, PredicateType, TraitBound, TraitBoundModifier, TypeParam, TypeParamBound,
-    WhereClause, WherePredicate,
-};
-#[cfg(all(any(feature = "full", feature = "derive"), feature = "printing"))]
-pub use crate::generics::{ImplGenerics, Turbofish, TypeGenerics};
-
-#[cfg(feature = "full")]
-mod item;
-#[cfg(feature = "full")]
-pub use crate::item::{
-    FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic, ForeignItemType,
-    ImplItem, ImplItemConst, ImplItemMacro, ImplItemMethod, ImplItemType, Item, ItemConst,
-    ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMacro2, ItemMod,
-    ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Receiver,
-    Signature, TraitItem, TraitItemConst, TraitItemMacro, TraitItemMethod, TraitItemType, UseGlob,
-    UseGroup, UseName, UsePath, UseRename, UseTree,
-};
-
-#[cfg(feature = "full")]
-mod file;
-#[cfg(feature = "full")]
-pub use crate::file::File;
-
-mod lifetime;
-pub use crate::lifetime::Lifetime;
-
-mod lit;
-pub use crate::lit::{
-    Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr, StrStyle,
-};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod mac;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::mac::{Macro, MacroDelimiter};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod derive;
-#[cfg(feature = "derive")]
-pub use crate::derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod op;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::op::{BinOp, UnOp};
-
-#[cfg(feature = "full")]
-mod stmt;
-#[cfg(feature = "full")]
-pub use crate::stmt::{Block, Local, Stmt};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod ty;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::ty::{
-    Abi, BareFnArg, ReturnType, Type, TypeArray, TypeBareFn, TypeGroup, TypeImplTrait, TypeInfer,
-    TypeMacro, TypeNever, TypeParen, TypePath, TypePtr, TypeReference, TypeSlice, TypeTraitObject,
-    TypeTuple, Variadic,
-};
-
-#[cfg(feature = "full")]
-mod pat;
-#[cfg(feature = "full")]
-pub use crate::pat::{
-    FieldPat, Pat, PatBox, PatIdent, PatLit, PatMacro, PatOr, PatPath, PatRange, PatReference,
-    PatRest, PatSlice, PatStruct, PatTuple, PatTupleStruct, PatType, PatWild,
-};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-mod path;
-#[cfg(any(feature = "full", feature = "derive"))]
-pub use crate::path::{
-    AngleBracketedGenericArguments, Binding, Constraint, GenericArgument,
-    ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf,
-};
-
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-pub mod buffer;
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-pub mod ext;
-pub mod punctuated;
-#[cfg(all(any(feature = "full", feature = "derive"), feature = "extra-traits"))]
-mod tt;
-
-// Not public API except the `parse_quote!` macro.
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-pub mod parse_quote;
-
-// Not public API except the `parse_macro_input!` macro.
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "parsing",
-    feature = "proc-macro"
-))]
-#[doc(hidden)]
-pub mod parse_macro_input;
-
-#[cfg(all(feature = "parsing", feature = "printing"))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "printing"))))]
-pub mod spanned;
-
-#[cfg(all(feature = "parsing", feature = "full"))]
-mod whitespace;
-
-mod gen {
-    /// Syntax tree traversal to walk a shared borrow of a syntax tree.
-    ///
-    /// Each method of the [`Visit`] trait is a hook that can be overridden to
-    /// customize the behavior when visiting the corresponding type of node. By
-    /// default, every method recursively visits the substructure of the input
-    /// by invoking the right visitor method of each of its fields.
-    ///
-    /// [`Visit`]: visit::Visit
-    ///
-    /// ```
-    /// # use syn::{Attribute, BinOp, Expr, ExprBinary};
-    /// #
-    /// pub trait Visit<'ast> {
-    ///     /* ... */
-    ///
-    ///     fn visit_expr_binary(&mut self, node: &'ast ExprBinary) {
-    ///         visit_expr_binary(self, node);
-    ///     }
-    ///
-    ///     /* ... */
-    ///     # fn visit_attribute(&mut self, node: &'ast Attribute);
-    ///     # fn visit_expr(&mut self, node: &'ast Expr);
-    ///     # fn visit_bin_op(&mut self, node: &'ast BinOp);
-    /// }
-    ///
-    /// pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast ExprBinary)
-    /// where
-    ///     V: Visit<'ast> + ?Sized,
-    /// {
-    ///     for attr in &node.attrs {
-    ///         v.visit_attribute(attr);
-    ///     }
-    ///     v.visit_expr(&*node.left);
-    ///     v.visit_bin_op(&node.op);
-    ///     v.visit_expr(&*node.right);
-    /// }
-    ///
-    /// /* ... */
-    /// ```
-    ///
-    /// *This module is available only if Syn is built with the `"visit"` feature.*
-    ///
-    /// <br>
-    ///
-    /// # Example
-    ///
-    /// This visitor will print the name of every freestanding function in the
-    /// syntax tree, including nested functions.
-    ///
-    /// ```
-    /// // [dependencies]
-    /// // quote = "1.0"
-    /// // syn = { version = "1.0", features = ["full", "visit"] }
-    ///
-    /// use quote::quote;
-    /// use syn::visit::{self, Visit};
-    /// use syn::{File, ItemFn};
-    ///
-    /// struct FnVisitor;
-    ///
-    /// impl<'ast> Visit<'ast> for FnVisitor {
-    ///     fn visit_item_fn(&mut self, node: &'ast ItemFn) {
-    ///         println!("Function with name={}", node.sig.ident);
-    ///
-    ///         // Delegate to the default impl to visit any nested functions.
-    ///         visit::visit_item_fn(self, node);
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let code = quote! {
-    ///         pub fn f() {
-    ///             fn g() {}
-    ///         }
-    ///     };
-    ///
-    ///     let syntax_tree: File = syn::parse2(code).unwrap();
-    ///     FnVisitor.visit_file(&syntax_tree);
-    /// }
-    /// ```
-    ///
-    /// The `'ast` lifetime on the input references means that the syntax tree
-    /// outlives the complete recursive visit call, so the visitor is allowed to
-    /// hold on to references into the syntax tree.
-    ///
-    /// ```
-    /// use quote::quote;
-    /// use syn::visit::{self, Visit};
-    /// use syn::{File, ItemFn};
-    ///
-    /// struct FnVisitor<'ast> {
-    ///     functions: Vec<&'ast ItemFn>,
-    /// }
-    ///
-    /// impl<'ast> Visit<'ast> for FnVisitor<'ast> {
-    ///     fn visit_item_fn(&mut self, node: &'ast ItemFn) {
-    ///         self.functions.push(node);
-    ///         visit::visit_item_fn(self, node);
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let code = quote! {
-    ///         pub fn f() {
-    ///             fn g() {}
-    ///         }
-    ///     };
-    ///
-    ///     let syntax_tree: File = syn::parse2(code).unwrap();
-    ///     let mut visitor = FnVisitor { functions: Vec::new() };
-    ///     visitor.visit_file(&syntax_tree);
-    ///     for f in visitor.functions {
-    ///         println!("Function with name={}", f.sig.ident);
-    ///     }
-    /// }
-    /// ```
-    #[cfg(feature = "visit")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "visit")))]
-    #[rustfmt::skip]
-    pub mod visit;
-
-    /// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in
-    /// place.
-    ///
-    /// Each method of the [`VisitMut`] trait is a hook that can be overridden
-    /// to customize the behavior when mutating the corresponding type of node.
-    /// By default, every method recursively visits the substructure of the
-    /// input by invoking the right visitor method of each of its fields.
-    ///
-    /// [`VisitMut`]: visit_mut::VisitMut
-    ///
-    /// ```
-    /// # use syn::{Attribute, BinOp, Expr, ExprBinary};
-    /// #
-    /// pub trait VisitMut {
-    ///     /* ... */
-    ///
-    ///     fn visit_expr_binary_mut(&mut self, node: &mut ExprBinary) {
-    ///         visit_expr_binary_mut(self, node);
-    ///     }
-    ///
-    ///     /* ... */
-    ///     # fn visit_attribute_mut(&mut self, node: &mut Attribute);
-    ///     # fn visit_expr_mut(&mut self, node: &mut Expr);
-    ///     # fn visit_bin_op_mut(&mut self, node: &mut BinOp);
-    /// }
-    ///
-    /// pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary)
-    /// where
-    ///     V: VisitMut + ?Sized,
-    /// {
-    ///     for attr in &mut node.attrs {
-    ///         v.visit_attribute_mut(attr);
-    ///     }
-    ///     v.visit_expr_mut(&mut *node.left);
-    ///     v.visit_bin_op_mut(&mut node.op);
-    ///     v.visit_expr_mut(&mut *node.right);
-    /// }
-    ///
-    /// /* ... */
-    /// ```
-    ///
-    /// *This module is available only if Syn is built with the `"visit-mut"`
-    /// feature.*
-    ///
-    /// <br>
-    ///
-    /// # Example
-    ///
-    /// This mut visitor replace occurrences of u256 suffixed integer literals
-    /// like `999u256` with a macro invocation `bigint::u256!(999)`.
-    ///
-    /// ```
-    /// // [dependencies]
-    /// // quote = "1.0"
-    /// // syn = { version = "1.0", features = ["full", "visit-mut"] }
-    ///
-    /// use quote::quote;
-    /// use syn::visit_mut::{self, VisitMut};
-    /// use syn::{parse_quote, Expr, File, Lit, LitInt};
-    ///
-    /// struct BigintReplace;
-    ///
-    /// impl VisitMut for BigintReplace {
-    ///     fn visit_expr_mut(&mut self, node: &mut Expr) {
-    ///         if let Expr::Lit(expr) = &node {
-    ///             if let Lit::Int(int) = &expr.lit {
-    ///                 if int.suffix() == "u256" {
-    ///                     let digits = int.base10_digits();
-    ///                     let unsuffixed: LitInt = syn::parse_str(digits).unwrap();
-    ///                     *node = parse_quote!(bigint::u256!(#unsuffixed));
-    ///                     return;
-    ///                 }
-    ///             }
-    ///         }
-    ///
-    ///         // Delegate to the default impl to visit nested expressions.
-    ///         visit_mut::visit_expr_mut(self, node);
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let code = quote! {
-    ///         fn main() {
-    ///             let _ = 999u256;
-    ///         }
-    ///     };
-    ///
-    ///     let mut syntax_tree: File = syn::parse2(code).unwrap();
-    ///     BigintReplace.visit_file_mut(&mut syntax_tree);
-    ///     println!("{}", quote!(#syntax_tree));
-    /// }
-    /// ```
-    #[cfg(feature = "visit-mut")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "visit-mut")))]
-    #[rustfmt::skip]
-    pub mod visit_mut;
-
-    /// Syntax tree traversal to transform the nodes of an owned syntax tree.
-    ///
-    /// Each method of the [`Fold`] trait is a hook that can be overridden to
-    /// customize the behavior when transforming the corresponding type of node.
-    /// By default, every method recursively visits the substructure of the
-    /// input by invoking the right visitor method of each of its fields.
-    ///
-    /// [`Fold`]: fold::Fold
-    ///
-    /// ```
-    /// # use syn::{Attribute, BinOp, Expr, ExprBinary};
-    /// #
-    /// pub trait Fold {
-    ///     /* ... */
-    ///
-    ///     fn fold_expr_binary(&mut self, node: ExprBinary) -> ExprBinary {
-    ///         fold_expr_binary(self, node)
-    ///     }
-    ///
-    ///     /* ... */
-    ///     # fn fold_attribute(&mut self, node: Attribute) -> Attribute;
-    ///     # fn fold_expr(&mut self, node: Expr) -> Expr;
-    ///     # fn fold_bin_op(&mut self, node: BinOp) -> BinOp;
-    /// }
-    ///
-    /// pub fn fold_expr_binary<V>(v: &mut V, node: ExprBinary) -> ExprBinary
-    /// where
-    ///     V: Fold + ?Sized,
-    /// {
-    ///     ExprBinary {
-    ///         attrs: node
-    ///             .attrs
-    ///             .into_iter()
-    ///             .map(|attr| v.fold_attribute(attr))
-    ///             .collect(),
-    ///         left: Box::new(v.fold_expr(*node.left)),
-    ///         op: v.fold_bin_op(node.op),
-    ///         right: Box::new(v.fold_expr(*node.right)),
-    ///     }
-    /// }
-    ///
-    /// /* ... */
-    /// ```
-    ///
-    /// *This module is available only if Syn is built with the `"fold"` feature.*
-    ///
-    /// <br>
-    ///
-    /// # Example
-    ///
-    /// This fold inserts parentheses to fully parenthesizes any expression.
-    ///
-    /// ```
-    /// // [dependencies]
-    /// // quote = "1.0"
-    /// // syn = { version = "1.0", features = ["fold", "full"] }
-    ///
-    /// use quote::quote;
-    /// use syn::fold::{fold_expr, Fold};
-    /// use syn::{token, Expr, ExprParen};
-    ///
-    /// struct ParenthesizeEveryExpr;
-    ///
-    /// impl Fold for ParenthesizeEveryExpr {
-    ///     fn fold_expr(&mut self, expr: Expr) -> Expr {
-    ///         Expr::Paren(ExprParen {
-    ///             attrs: Vec::new(),
-    ///             expr: Box::new(fold_expr(self, expr)),
-    ///             paren_token: token::Paren::default(),
-    ///         })
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let code = quote! { a() + b(1) * c.d };
-    ///     let expr: Expr = syn::parse2(code).unwrap();
-    ///     let parenthesized = ParenthesizeEveryExpr.fold_expr(expr);
-    ///     println!("{}", quote!(#parenthesized));
-    ///
-    ///     // Output: (((a)()) + (((b)((1))) * ((c).d)))
-    /// }
-    /// ```
-    #[cfg(feature = "fold")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "fold")))]
-    #[rustfmt::skip]
-    pub mod fold;
-
-    #[cfg(feature = "clone-impls")]
-    #[rustfmt::skip]
-    mod clone;
-
-    #[cfg(feature = "extra-traits")]
-    #[rustfmt::skip]
-    mod eq;
-
-    #[cfg(feature = "extra-traits")]
-    #[rustfmt::skip]
-    mod hash;
-
-    #[cfg(feature = "extra-traits")]
-    #[rustfmt::skip]
-    mod debug;
-
-    #[cfg(any(feature = "full", feature = "derive"))]
-    #[path = "../gen_helper.rs"]
-    mod helper;
-}
-pub use crate::gen::*;
-
-// Not public API.
-#[doc(hidden)]
-#[path = "export.rs"]
-pub mod __private;
-
-mod custom_keyword;
-mod custom_punctuation;
-mod sealed;
-mod span;
-mod thread;
-
-#[cfg(feature = "parsing")]
-mod lookahead;
-
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-pub mod parse;
-
-#[cfg(feature = "full")]
-mod reserved;
-
-#[cfg(all(any(feature = "full", feature = "derive"), feature = "parsing"))]
-mod verbatim;
-
-#[cfg(all(any(feature = "full", feature = "derive"), feature = "printing"))]
-mod print;
-
-use crate::__private::private;
-
-////////////////////////////////////////////////////////////////////////////////
-
-// https://github.com/rust-lang/rust/issues/62830
-#[cfg(feature = "parsing")]
-mod rustdoc_workaround {
-    pub use crate::parse::{self as parse_module};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-mod error;
-pub use crate::error::{Error, Result};
-
-/// Parse tokens of source code into the chosen syntax tree node.
-///
-/// This is preferred over parsing a string because tokens are able to preserve
-/// information about where in the user's code they were originally written (the
-/// "span" of the token), possibly allowing the compiler to produce better error
-/// messages.
-///
-/// This function parses a `proc_macro::TokenStream` which is the type used for
-/// interop with the compiler in a procedural macro. To parse a
-/// `proc_macro2::TokenStream`, use [`syn::parse2`] instead.
-///
-/// [`syn::parse2`]: parse2
-///
-/// *This function is available only if Syn is built with both the `"parsing"` and
-/// `"proc-macro"` features.*
-///
-/// # Examples
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// use proc_macro::TokenStream;
-/// use quote::quote;
-/// use syn::DeriveInput;
-///
-/// # const IGNORE_TOKENS: &str = stringify! {
-/// #[proc_macro_derive(MyMacro)]
-/// # };
-/// pub fn my_macro(input: TokenStream) -> TokenStream {
-///     // Parse the tokens into a syntax tree
-///     let ast: DeriveInput = syn::parse(input).unwrap();
-///
-///     // Build the output, possibly using quasi-quotation
-///     let expanded = quote! {
-///         /* ... */
-///     };
-///
-///     // Convert into a token stream and return it
-///     expanded.into()
-/// }
-/// ```
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "parsing",
-    feature = "proc-macro"
-))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "proc-macro"))))]
-pub fn parse<T: parse::Parse>(tokens: proc_macro::TokenStream) -> Result<T> {
-    parse::Parser::parse(T::parse, tokens)
-}
-
-/// Parse a proc-macro2 token stream into the chosen syntax tree node.
-///
-/// This function will check that the input is fully parsed. If there are
-/// any unparsed tokens at the end of the stream, an error is returned.
-///
-/// This function parses a `proc_macro2::TokenStream` which is commonly useful
-/// when the input comes from a node of the Syn syntax tree, for example the
-/// body tokens of a [`Macro`] node. When in a procedural macro parsing the
-/// `proc_macro::TokenStream` provided by the compiler, use [`syn::parse`]
-/// instead.
-///
-/// [`syn::parse`]: parse()
-///
-/// *This function is available only if Syn is built with the `"parsing"` feature.*
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-pub fn parse2<T: parse::Parse>(tokens: proc_macro2::TokenStream) -> Result<T> {
-    parse::Parser::parse2(T::parse, tokens)
-}
-
-/// Parse a string of Rust code into the chosen syntax tree node.
-///
-/// *This function is available only if Syn is built with the `"parsing"` feature.*
-///
-/// # Hygiene
-///
-/// Every span in the resulting syntax tree will be set to resolve at the macro
-/// call site.
-///
-/// # Examples
-///
-/// ```
-/// use syn::{Expr, Result};
-///
-/// fn run() -> Result<()> {
-///     let code = "assert_eq!(u8::max_value(), 255)";
-///     let expr = syn::parse_str::<Expr>(code)?;
-///     println!("{:#?}", expr);
-///     Ok(())
-/// }
-/// #
-/// # run().unwrap();
-/// ```
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-pub fn parse_str<T: parse::Parse>(s: &str) -> Result<T> {
-    parse::Parser::parse_str(T::parse, s)
-}
-
-// FIXME the name parse_file makes it sound like you might pass in a path to a
-// file, rather than the content.
-/// Parse the content of a file of Rust code.
-///
-/// This is different from `syn::parse_str::<File>(content)` in two ways:
-///
-/// - It discards a leading byte order mark `\u{FEFF}` if the file has one.
-/// - It preserves the shebang line of the file, such as `#!/usr/bin/env rustx`.
-///
-/// If present, either of these would be an error using `from_str`.
-///
-/// *This function is available only if Syn is built with the `"parsing"` and
-/// `"full"` features.*
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::error::Error;
-/// use std::fs::File;
-/// use std::io::Read;
-///
-/// fn run() -> Result<(), Box<Error>> {
-///     let mut file = File::open("path/to/code.rs")?;
-///     let mut content = String::new();
-///     file.read_to_string(&mut content)?;
-///
-///     let ast = syn::parse_file(&content)?;
-///     if let Some(shebang) = ast.shebang {
-///         println!("{}", shebang);
-///     }
-///     println!("{} items", ast.items.len());
-///
-///     Ok(())
-/// }
-/// #
-/// # run().unwrap();
-/// ```
-#[cfg(all(feature = "parsing", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "full"))))]
-pub fn parse_file(mut content: &str) -> Result<File> {
-    // Strip the BOM if it is present
-    const BOM: &str = "\u{feff}";
-    if content.starts_with(BOM) {
-        content = &content[BOM.len()..];
-    }
-
-    let mut shebang = None;
-    if content.starts_with("#!") {
-        let rest = whitespace::skip(&content[2..]);
-        if !rest.starts_with('[') {
-            if let Some(idx) = content.find('\n') {
-                shebang = Some(content[..idx].to_string());
-                content = &content[idx..];
-            } else {
-                shebang = Some(content.to_string());
-                content = "";
-            }
-        }
-    }
-
-    let mut file: File = parse_str(content)?;
-    file.shebang = shebang;
-    Ok(file)
-}
diff --git a/vendor/syn/src/lifetime.rs b/vendor/syn/src/lifetime.rs
deleted file mode 100644
index 5dc1753a..00000000
--- a/vendor/syn/src/lifetime.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use proc_macro2::{Ident, Span};
-use std::cmp::Ordering;
-use std::fmt::{self, Display};
-use std::hash::{Hash, Hasher};
-
-#[cfg(feature = "parsing")]
-use crate::lookahead;
-
-/// A Rust lifetime: `'a`.
-///
-/// Lifetime names must conform to the following rules:
-///
-/// - Must start with an apostrophe.
-/// - Must not consist of just an apostrophe: `'`.
-/// - Character after the apostrophe must be `_` or a Unicode code point with
-///   the XID_Start property.
-/// - All following characters must be Unicode code points with the XID_Continue
-///   property.
-pub struct Lifetime {
-    pub apostrophe: Span,
-    pub ident: Ident,
-}
-
-impl Lifetime {
-    /// # Panics
-    ///
-    /// Panics if the lifetime does not conform to the bulleted rules above.
-    ///
-    /// # Invocation
-    ///
-    /// ```
-    /// # use proc_macro2::Span;
-    /// # use syn::Lifetime;
-    /// #
-    /// # fn f() -> Lifetime {
-    /// Lifetime::new("'a", Span::call_site())
-    /// # }
-    /// ```
-    pub fn new(symbol: &str, span: Span) -> Self {
-        if !symbol.starts_with('\'') {
-            panic!(
-                "lifetime name must start with apostrophe as in \"'a\", got {:?}",
-                symbol
-            );
-        }
-
-        if symbol == "'" {
-            panic!("lifetime name must not be empty");
-        }
-
-        if !crate::ident::xid_ok(&symbol[1..]) {
-            panic!("{:?} is not a valid lifetime name", symbol);
-        }
-
-        Lifetime {
-            apostrophe: span,
-            ident: Ident::new(&symbol[1..], span),
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        self.apostrophe
-            .join(self.ident.span())
-            .unwrap_or(self.apostrophe)
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.apostrophe = span;
-        self.ident.set_span(span);
-    }
-}
-
-impl Display for Lifetime {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        "'".fmt(formatter)?;
-        self.ident.fmt(formatter)
-    }
-}
-
-impl Clone for Lifetime {
-    fn clone(&self) -> Self {
-        Lifetime {
-            apostrophe: self.apostrophe,
-            ident: self.ident.clone(),
-        }
-    }
-}
-
-impl PartialEq for Lifetime {
-    fn eq(&self, other: &Lifetime) -> bool {
-        self.ident.eq(&other.ident)
-    }
-}
-
-impl Eq for Lifetime {}
-
-impl PartialOrd for Lifetime {
-    fn partial_cmp(&self, other: &Lifetime) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Lifetime {
-    fn cmp(&self, other: &Lifetime) -> Ordering {
-        self.ident.cmp(&other.ident)
-    }
-}
-
-impl Hash for Lifetime {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.ident.hash(h);
-    }
-}
-
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[allow(non_snake_case)]
-pub fn Lifetime(marker: lookahead::TokenMarker) -> Lifetime {
-    match marker {}
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Lifetime {
-        fn parse(input: ParseStream) -> Result<Self> {
-            input.step(|cursor| {
-                cursor
-                    .lifetime()
-                    .ok_or_else(|| cursor.error("expected lifetime"))
-            })
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::{Punct, Spacing, TokenStream};
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Lifetime {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            let mut apostrophe = Punct::new('\'', Spacing::Joint);
-            apostrophe.set_span(self.apostrophe);
-            tokens.append(apostrophe);
-            self.ident.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/lit.rs b/vendor/syn/src/lit.rs
deleted file mode 100644
index 9ea2e8c0..00000000
--- a/vendor/syn/src/lit.rs
+++ /dev/null
@@ -1,1574 +0,0 @@
-#[cfg(feature = "parsing")]
-use crate::lookahead;
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, Parser};
-use crate::{Error, Result};
-#[cfg(feature = "printing")]
-use proc_macro2::Ident;
-#[cfg(feature = "parsing")]
-use proc_macro2::TokenStream;
-use proc_macro2::TokenTree;
-use proc_macro2::{Literal, Span};
-use std::fmt::{self, Display};
-#[cfg(feature = "extra-traits")]
-use std::hash::{Hash, Hasher};
-use std::str::{self, FromStr};
-
-ast_enum_of_structs! {
-    /// A Rust literal such as a string or integer or boolean.
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: crate::Expr#syntax-tree-enums
-    pub enum Lit {
-        /// A UTF-8 string literal: `"foo"`.
-        Str(LitStr),
-
-        /// A byte string literal: `b"foo"`.
-        ByteStr(LitByteStr),
-
-        /// A byte literal: `b'f'`.
-        Byte(LitByte),
-
-        /// A character literal: `'a'`.
-        Char(LitChar),
-
-        /// An integer literal: `1` or `1u16`.
-        Int(LitInt),
-
-        /// A floating point literal: `1f64` or `1.0e10f64`.
-        ///
-        /// Must be finite. May not be infinite or NaN.
-        Float(LitFloat),
-
-        /// A boolean literal: `true` or `false`.
-        Bool(LitBool),
-
-        /// A raw token literal not interpreted by Syn.
-        Verbatim(Literal),
-    }
-}
-
-ast_struct! {
-    /// A UTF-8 string literal: `"foo"`.
-    pub struct LitStr {
-        repr: Box<LitRepr>,
-    }
-}
-
-ast_struct! {
-    /// A byte string literal: `b"foo"`.
-    pub struct LitByteStr {
-        repr: Box<LitRepr>,
-    }
-}
-
-ast_struct! {
-    /// A byte literal: `b'f'`.
-    pub struct LitByte {
-        repr: Box<LitRepr>,
-    }
-}
-
-ast_struct! {
-    /// A character literal: `'a'`.
-    pub struct LitChar {
-        repr: Box<LitRepr>,
-    }
-}
-
-struct LitRepr {
-    token: Literal,
-    suffix: Box<str>,
-}
-
-ast_struct! {
-    /// An integer literal: `1` or `1u16`.
-    pub struct LitInt {
-        repr: Box<LitIntRepr>,
-    }
-}
-
-struct LitIntRepr {
-    token: Literal,
-    digits: Box<str>,
-    suffix: Box<str>,
-}
-
-ast_struct! {
-    /// A floating point literal: `1f64` or `1.0e10f64`.
-    ///
-    /// Must be finite. May not be infinite or NaN.
-    pub struct LitFloat {
-        repr: Box<LitFloatRepr>,
-    }
-}
-
-struct LitFloatRepr {
-    token: Literal,
-    digits: Box<str>,
-    suffix: Box<str>,
-}
-
-ast_struct! {
-    /// A boolean literal: `true` or `false`.
-    pub struct LitBool {
-        pub value: bool,
-        pub span: Span,
-    }
-}
-
-impl LitStr {
-    pub fn new(value: &str, span: Span) -> Self {
-        let mut token = Literal::string(value);
-        token.set_span(span);
-        LitStr {
-            repr: Box::new(LitRepr {
-                token,
-                suffix: Box::<str>::default(),
-            }),
-        }
-    }
-
-    pub fn value(&self) -> String {
-        let repr = self.repr.token.to_string();
-        let (value, _suffix) = value::parse_lit_str(&repr);
-        String::from(value)
-    }
-
-    /// Parse a syntax tree node from the content of this string literal.
-    ///
-    /// All spans in the syntax tree will point to the span of this `LitStr`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use proc_macro2::Span;
-    /// use syn::{Attribute, Error, Ident, Lit, Meta, MetaNameValue, Path, Result};
-    ///
-    /// // Parses the path from an attribute that looks like:
-    /// //
-    /// //     #[path = "a::b::c"]
-    /// //
-    /// // or returns `None` if the input is some other attribute.
-    /// fn get_path(attr: &Attribute) -> Result<Option<Path>> {
-    ///     if !attr.path.is_ident("path") {
-    ///         return Ok(None);
-    ///     }
-    ///
-    ///     match attr.parse_meta()? {
-    ///         Meta::NameValue(MetaNameValue { lit: Lit::Str(lit_str), .. }) => {
-    ///             lit_str.parse().map(Some)
-    ///         }
-    ///         _ => {
-    ///             let message = "expected #[path = \"...\"]";
-    ///             Err(Error::new_spanned(attr, message))
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse<T: Parse>(&self) -> Result<T> {
-        self.parse_with(T::parse)
-    }
-
-    /// Invoke parser on the content of this string literal.
-    ///
-    /// All spans in the syntax tree will point to the span of this `LitStr`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use proc_macro2::Span;
-    /// # use syn::{LitStr, Result};
-    /// #
-    /// # fn main() -> Result<()> {
-    /// #     let lit_str = LitStr::new("a::b::c", Span::call_site());
-    /// #
-    /// #     const IGNORE: &str = stringify! {
-    /// let lit_str: LitStr = /* ... */;
-    /// #     };
-    ///
-    /// // Parse a string literal like "a::b::c" into a Path, not allowing
-    /// // generic arguments on any of the path segments.
-    /// let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;
-    /// #
-    /// #     Ok(())
-    /// # }
-    /// ```
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_with<F: Parser>(&self, parser: F) -> Result<F::Output> {
-        use proc_macro2::Group;
-
-        // Token stream with every span replaced by the given one.
-        fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
-            stream
-                .into_iter()
-                .map(|token| respan_token_tree(token, span))
-                .collect()
-        }
-
-        // Token tree with every span replaced by the given one.
-        fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
-            match &mut token {
-                TokenTree::Group(g) => {
-                    let stream = respan_token_stream(g.stream(), span);
-                    *g = Group::new(g.delimiter(), stream);
-                    g.set_span(span);
-                }
-                other => other.set_span(span),
-            }
-            token
-        }
-
-        // Parse string literal into a token stream with every span equal to the
-        // original literal's span.
-        let mut tokens = crate::parse_str(&self.value())?;
-        tokens = respan_token_stream(tokens, self.span());
-
-        parser.parse2(tokens)
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-}
-
-impl LitByteStr {
-    pub fn new(value: &[u8], span: Span) -> Self {
-        let mut token = Literal::byte_string(value);
-        token.set_span(span);
-        LitByteStr {
-            repr: Box::new(LitRepr {
-                token,
-                suffix: Box::<str>::default(),
-            }),
-        }
-    }
-
-    pub fn value(&self) -> Vec<u8> {
-        let repr = self.repr.token.to_string();
-        let (value, _suffix) = value::parse_lit_byte_str(&repr);
-        value
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-}
-
-impl LitByte {
-    pub fn new(value: u8, span: Span) -> Self {
-        let mut token = Literal::u8_suffixed(value);
-        token.set_span(span);
-        LitByte {
-            repr: Box::new(LitRepr {
-                token,
-                suffix: Box::<str>::default(),
-            }),
-        }
-    }
-
-    pub fn value(&self) -> u8 {
-        let repr = self.repr.token.to_string();
-        let (value, _suffix) = value::parse_lit_byte(&repr);
-        value
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-}
-
-impl LitChar {
-    pub fn new(value: char, span: Span) -> Self {
-        let mut token = Literal::character(value);
-        token.set_span(span);
-        LitChar {
-            repr: Box::new(LitRepr {
-                token,
-                suffix: Box::<str>::default(),
-            }),
-        }
-    }
-
-    pub fn value(&self) -> char {
-        let repr = self.repr.token.to_string();
-        let (value, _suffix) = value::parse_lit_char(&repr);
-        value
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-}
-
-impl LitInt {
-    pub fn new(repr: &str, span: Span) -> Self {
-        let (digits, suffix) = match value::parse_lit_int(repr) {
-            Some(parse) => parse,
-            None => panic!("Not an integer literal: `{}`", repr),
-        };
-
-        let mut token = match value::to_literal(repr, &digits, &suffix) {
-            Some(token) => token,
-            None => panic!("Unsupported integer literal: `{}`", repr),
-        };
-
-        token.set_span(span);
-        LitInt {
-            repr: Box::new(LitIntRepr {
-                token,
-                digits,
-                suffix,
-            }),
-        }
-    }
-
-    pub fn base10_digits(&self) -> &str {
-        &self.repr.digits
-    }
-
-    /// Parses the literal into a selected number type.
-    ///
-    /// This is equivalent to `lit.base10_digits().parse()` except that the
-    /// resulting errors will be correctly spanned to point to the literal token
-    /// in the macro input.
-    ///
-    /// ```
-    /// use syn::LitInt;
-    /// use syn::parse::{Parse, ParseStream, Result};
-    ///
-    /// struct Port {
-    ///     value: u16,
-    /// }
-    ///
-    /// impl Parse for Port {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let lit: LitInt = input.parse()?;
-    ///         let value = lit.base10_parse::<u16>()?;
-    ///         Ok(Port { value })
-    ///     }
-    /// }
-    /// ```
-    pub fn base10_parse<N>(&self) -> Result<N>
-    where
-        N: FromStr,
-        N::Err: Display,
-    {
-        self.base10_digits()
-            .parse()
-            .map_err(|err| Error::new(self.span(), err))
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-}
-
-impl From<Literal> for LitInt {
-    fn from(token: Literal) -> Self {
-        let repr = token.to_string();
-        if let Some((digits, suffix)) = value::parse_lit_int(&repr) {
-            LitInt {
-                repr: Box::new(LitIntRepr {
-                    token,
-                    digits,
-                    suffix,
-                }),
-            }
-        } else {
-            panic!("Not an integer literal: `{}`", repr);
-        }
-    }
-}
-
-impl Display for LitInt {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.repr.token.fmt(formatter)
-    }
-}
-
-impl LitFloat {
-    pub fn new(repr: &str, span: Span) -> Self {
-        let (digits, suffix) = match value::parse_lit_float(repr) {
-            Some(parse) => parse,
-            None => panic!("Not a float literal: `{}`", repr),
-        };
-
-        let mut token = match value::to_literal(repr, &digits, &suffix) {
-            Some(token) => token,
-            None => panic!("Unsupported float literal: `{}`", repr),
-        };
-
-        token.set_span(span);
-        LitFloat {
-            repr: Box::new(LitFloatRepr {
-                token,
-                digits,
-                suffix,
-            }),
-        }
-    }
-
-    pub fn base10_digits(&self) -> &str {
-        &self.repr.digits
-    }
-
-    pub fn base10_parse<N>(&self) -> Result<N>
-    where
-        N: FromStr,
-        N::Err: Display,
-    {
-        self.base10_digits()
-            .parse()
-            .map_err(|err| Error::new(self.span(), err))
-    }
-
-    pub fn suffix(&self) -> &str {
-        &self.repr.suffix
-    }
-
-    pub fn span(&self) -> Span {
-        self.repr.token.span()
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span);
-    }
-}
-
-impl From<Literal> for LitFloat {
-    fn from(token: Literal) -> Self {
-        let repr = token.to_string();
-        if let Some((digits, suffix)) = value::parse_lit_float(&repr) {
-            LitFloat {
-                repr: Box::new(LitFloatRepr {
-                    token,
-                    digits,
-                    suffix,
-                }),
-            }
-        } else {
-            panic!("Not a float literal: `{}`", repr);
-        }
-    }
-}
-
-impl Display for LitFloat {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.repr.token.fmt(formatter)
-    }
-}
-
-impl LitBool {
-    pub fn new(value: bool, span: Span) -> Self {
-        LitBool { value, span }
-    }
-
-    pub fn value(&self) -> bool {
-        self.value
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-mod debug_impls {
-    use super::*;
-    use std::fmt::{self, Debug};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitStr {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitStr")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitByteStr {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitByteStr")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitByte {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitByte")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitChar {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitChar")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitInt {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitInt")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitFloat {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitFloat")
-                .field("token", &format_args!("{}", self.repr.token))
-                .finish()
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-    impl Debug for LitBool {
-        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter
-                .debug_struct("LitBool")
-                .field("value", &self.value)
-                .finish()
-        }
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LitRepr {
-    fn clone(&self) -> Self {
-        LitRepr {
-            token: self.token.clone(),
-            suffix: self.suffix.clone(),
-        }
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LitIntRepr {
-    fn clone(&self) -> Self {
-        LitIntRepr {
-            token: self.token.clone(),
-            digits: self.digits.clone(),
-            suffix: self.suffix.clone(),
-        }
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LitFloatRepr {
-    fn clone(&self) -> Self {
-        LitFloatRepr {
-            token: self.token.clone(),
-            digits: self.digits.clone(),
-            suffix: self.suffix.clone(),
-        }
-    }
-}
-
-macro_rules! lit_extra_traits {
-    ($ty:ident) => {
-        #[cfg(feature = "clone-impls")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-        impl Clone for $ty {
-            fn clone(&self) -> Self {
-                $ty {
-                    repr: self.repr.clone(),
-                }
-            }
-        }
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl PartialEq for $ty {
-            fn eq(&self, other: &Self) -> bool {
-                self.repr.token.to_string() == other.repr.token.to_string()
-            }
-        }
-
-        #[cfg(feature = "extra-traits")]
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-        impl Hash for $ty {
-            fn hash<H>(&self, state: &mut H)
-            where
-                H: Hasher,
-            {
-                self.repr.token.to_string().hash(state);
-            }
-        }
-
-        #[cfg(feature = "parsing")]
-        #[doc(hidden)]
-        #[allow(non_snake_case)]
-        pub fn $ty(marker: lookahead::TokenMarker) -> $ty {
-            match marker {}
-        }
-    };
-}
-
-lit_extra_traits!(LitStr);
-lit_extra_traits!(LitByteStr);
-lit_extra_traits!(LitByte);
-lit_extra_traits!(LitChar);
-lit_extra_traits!(LitInt);
-lit_extra_traits!(LitFloat);
-
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[allow(non_snake_case)]
-pub fn LitBool(marker: lookahead::TokenMarker) -> LitBool {
-    match marker {}
-}
-
-ast_enum! {
-    /// The style of a string literal, either plain quoted or a raw string like
-    /// `r##"data"##`.
-    pub enum StrStyle #no_visit {
-        /// An ordinary string like `"data"`.
-        Cooked,
-        /// A raw string like `r##"data"##`.
-        ///
-        /// The unsigned integer is the number of `#` symbols used.
-        Raw(usize),
-    }
-}
-
-#[cfg(feature = "parsing")]
-#[doc(hidden)]
-#[allow(non_snake_case)]
-pub fn Lit(marker: lookahead::TokenMarker) -> Lit {
-    match marker {}
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::buffer::Cursor;
-    use crate::parse::{Parse, ParseStream, Result};
-    use proc_macro2::Punct;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Lit {
-        fn parse(input: ParseStream) -> Result<Self> {
-            input.step(|cursor| {
-                if let Some((lit, rest)) = cursor.literal() {
-                    return Ok((Lit::new(lit), rest));
-                }
-
-                if let Some((ident, rest)) = cursor.ident() {
-                    let value = ident == "true";
-                    if value || ident == "false" {
-                        let lit_bool = LitBool {
-                            value,
-                            span: ident.span(),
-                        };
-                        return Ok((Lit::Bool(lit_bool), rest));
-                    }
-                }
-
-                if let Some((punct, rest)) = cursor.punct() {
-                    if punct.as_char() == '-' {
-                        if let Some((lit, rest)) = parse_negative_lit(punct, rest) {
-                            return Ok((lit, rest));
-                        }
-                    }
-                }
-
-                Err(cursor.error("expected literal"))
-            })
-        }
-    }
-
-    fn parse_negative_lit(neg: Punct, cursor: Cursor) -> Option<(Lit, Cursor)> {
-        let (lit, rest) = cursor.literal()?;
-
-        let mut span = neg.span();
-        span = span.join(lit.span()).unwrap_or(span);
-
-        let mut repr = lit.to_string();
-        repr.insert(0, '-');
-
-        if let Some((digits, suffix)) = value::parse_lit_int(&repr) {
-            if let Some(mut token) = value::to_literal(&repr, &digits, &suffix) {
-                token.set_span(span);
-                return Some((
-                    Lit::Int(LitInt {
-                        repr: Box::new(LitIntRepr {
-                            token,
-                            digits,
-                            suffix,
-                        }),
-                    }),
-                    rest,
-                ));
-            }
-        }
-
-        let (digits, suffix) = value::parse_lit_float(&repr)?;
-        let mut token = value::to_literal(&repr, &digits, &suffix)?;
-        token.set_span(span);
-        Some((
-            Lit::Float(LitFloat {
-                repr: Box::new(LitFloatRepr {
-                    token,
-                    digits,
-                    suffix,
-                }),
-            }),
-            rest,
-        ))
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitStr {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Str(lit)) => Ok(lit),
-                _ => Err(head.error("expected string literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitByteStr {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::ByteStr(lit)) => Ok(lit),
-                _ => Err(head.error("expected byte string literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitByte {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Byte(lit)) => Ok(lit),
-                _ => Err(head.error("expected byte literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitChar {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Char(lit)) => Ok(lit),
-                _ => Err(head.error("expected character literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitInt {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Int(lit)) => Ok(lit),
-                _ => Err(head.error("expected integer literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitFloat {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Float(lit)) => Ok(lit),
-                _ => Err(head.error("expected floating point literal")),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for LitBool {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let head = input.fork();
-            match input.parse() {
-                Ok(Lit::Bool(lit)) => Ok(lit),
-                _ => Err(head.error("expected boolean literal")),
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitStr {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitByteStr {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitByte {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitChar {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitInt {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitFloat {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.repr.token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for LitBool {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            let s = if self.value { "true" } else { "false" };
-            tokens.append(Ident::new(s, self.span));
-        }
-    }
-}
-
-mod value {
-    use super::*;
-    use crate::bigint::BigInt;
-    use proc_macro2::TokenStream;
-    use std::char;
-    use std::ops::{Index, RangeFrom};
-
-    impl Lit {
-        /// Interpret a Syn literal from a proc-macro2 literal.
-        pub fn new(token: Literal) -> Self {
-            let repr = token.to_string();
-
-            match byte(&repr, 0) {
-                b'"' | b'r' => {
-                    let (_, suffix) = parse_lit_str(&repr);
-                    return Lit::Str(LitStr {
-                        repr: Box::new(LitRepr { token, suffix }),
-                    });
-                }
-                b'b' => match byte(&repr, 1) {
-                    b'"' | b'r' => {
-                        let (_, suffix) = parse_lit_byte_str(&repr);
-                        return Lit::ByteStr(LitByteStr {
-                            repr: Box::new(LitRepr { token, suffix }),
-                        });
-                    }
-                    b'\'' => {
-                        let (_, suffix) = parse_lit_byte(&repr);
-                        return Lit::Byte(LitByte {
-                            repr: Box::new(LitRepr { token, suffix }),
-                        });
-                    }
-                    _ => {}
-                },
-                b'\'' => {
-                    let (_, suffix) = parse_lit_char(&repr);
-                    return Lit::Char(LitChar {
-                        repr: Box::new(LitRepr { token, suffix }),
-                    });
-                }
-                b'0'..=b'9' | b'-' => {
-                    if let Some((digits, suffix)) = parse_lit_int(&repr) {
-                        return Lit::Int(LitInt {
-                            repr: Box::new(LitIntRepr {
-                                token,
-                                digits,
-                                suffix,
-                            }),
-                        });
-                    }
-                    if let Some((digits, suffix)) = parse_lit_float(&repr) {
-                        return Lit::Float(LitFloat {
-                            repr: Box::new(LitFloatRepr {
-                                token,
-                                digits,
-                                suffix,
-                            }),
-                        });
-                    }
-                }
-                b't' | b'f' => {
-                    if repr == "true" || repr == "false" {
-                        return Lit::Bool(LitBool {
-                            value: repr == "true",
-                            span: token.span(),
-                        });
-                    }
-                }
-                _ => {}
-            }
-
-            panic!("Unrecognized literal: `{}`", repr);
-        }
-
-        pub fn suffix(&self) -> &str {
-            match self {
-                Lit::Str(lit) => lit.suffix(),
-                Lit::ByteStr(lit) => lit.suffix(),
-                Lit::Byte(lit) => lit.suffix(),
-                Lit::Char(lit) => lit.suffix(),
-                Lit::Int(lit) => lit.suffix(),
-                Lit::Float(lit) => lit.suffix(),
-                Lit::Bool(_) | Lit::Verbatim(_) => "",
-            }
-        }
-
-        pub fn span(&self) -> Span {
-            match self {
-                Lit::Str(lit) => lit.span(),
-                Lit::ByteStr(lit) => lit.span(),
-                Lit::Byte(lit) => lit.span(),
-                Lit::Char(lit) => lit.span(),
-                Lit::Int(lit) => lit.span(),
-                Lit::Float(lit) => lit.span(),
-                Lit::Bool(lit) => lit.span,
-                Lit::Verbatim(lit) => lit.span(),
-            }
-        }
-
-        pub fn set_span(&mut self, span: Span) {
-            match self {
-                Lit::Str(lit) => lit.set_span(span),
-                Lit::ByteStr(lit) => lit.set_span(span),
-                Lit::Byte(lit) => lit.set_span(span),
-                Lit::Char(lit) => lit.set_span(span),
-                Lit::Int(lit) => lit.set_span(span),
-                Lit::Float(lit) => lit.set_span(span),
-                Lit::Bool(lit) => lit.span = span,
-                Lit::Verbatim(lit) => lit.set_span(span),
-            }
-        }
-    }
-
-    /// Get the byte at offset idx, or a default of `b'\0'` if we're looking
-    /// past the end of the input buffer.
-    pub fn byte<S: AsRef<[u8]> + ?Sized>(s: &S, idx: usize) -> u8 {
-        let s = s.as_ref();
-        if idx < s.len() {
-            s[idx]
-        } else {
-            0
-        }
-    }
-
-    fn next_chr(s: &str) -> char {
-        s.chars().next().unwrap_or('\0')
-    }
-
-    // Returns (content, suffix).
-    pub fn parse_lit_str(s: &str) -> (Box<str>, Box<str>) {
-        match byte(s, 0) {
-            b'"' => parse_lit_str_cooked(s),
-            b'r' => parse_lit_str_raw(s),
-            _ => unreachable!(),
-        }
-    }
-
-    // Clippy false positive
-    // https://github.com/rust-lang-nursery/rust-clippy/issues/2329
-    #[allow(clippy::needless_continue)]
-    fn parse_lit_str_cooked(mut s: &str) -> (Box<str>, Box<str>) {
-        assert_eq!(byte(s, 0), b'"');
-        s = &s[1..];
-
-        let mut content = String::new();
-        'outer: loop {
-            let ch = match byte(s, 0) {
-                b'"' => break,
-                b'\\' => {
-                    let b = byte(s, 1);
-                    s = &s[2..];
-                    match b {
-                        b'x' => {
-                            let (byte, rest) = backslash_x(s);
-                            s = rest;
-                            assert!(byte <= 0x80, "Invalid \\x byte in string literal");
-                            char::from_u32(u32::from(byte)).unwrap()
-                        }
-                        b'u' => {
-                            let (chr, rest) = backslash_u(s);
-                            s = rest;
-                            chr
-                        }
-                        b'n' => '\n',
-                        b'r' => '\r',
-                        b't' => '\t',
-                        b'\\' => '\\',
-                        b'0' => '\0',
-                        b'\'' => '\'',
-                        b'"' => '"',
-                        b'\r' | b'\n' => loop {
-                            let ch = next_chr(s);
-                            if ch.is_whitespace() {
-                                s = &s[ch.len_utf8()..];
-                            } else {
-                                continue 'outer;
-                            }
-                        },
-                        b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
-                    }
-                }
-                b'\r' => {
-                    assert_eq!(byte(s, 1), b'\n', "Bare CR not allowed in string");
-                    s = &s[2..];
-                    '\n'
-                }
-                _ => {
-                    let ch = next_chr(s);
-                    s = &s[ch.len_utf8()..];
-                    ch
-                }
-            };
-            content.push(ch);
-        }
-
-        assert!(s.starts_with('"'));
-        let content = content.into_boxed_str();
-        let suffix = s[1..].to_owned().into_boxed_str();
-        (content, suffix)
-    }
-
-    fn parse_lit_str_raw(mut s: &str) -> (Box<str>, Box<str>) {
-        assert_eq!(byte(s, 0), b'r');
-        s = &s[1..];
-
-        let mut pounds = 0;
-        while byte(s, pounds) == b'#' {
-            pounds += 1;
-        }
-        assert_eq!(byte(s, pounds), b'"');
-        let close = s.rfind('"').unwrap();
-        for end in s[close + 1..close + 1 + pounds].bytes() {
-            assert_eq!(end, b'#');
-        }
-
-        let content = s[pounds + 1..close].to_owned().into_boxed_str();
-        let suffix = s[close + 1 + pounds..].to_owned().into_boxed_str();
-        (content, suffix)
-    }
-
-    // Returns (content, suffix).
-    pub fn parse_lit_byte_str(s: &str) -> (Vec<u8>, Box<str>) {
-        assert_eq!(byte(s, 0), b'b');
-        match byte(s, 1) {
-            b'"' => parse_lit_byte_str_cooked(s),
-            b'r' => parse_lit_byte_str_raw(s),
-            _ => unreachable!(),
-        }
-    }
-
-    // Clippy false positive
-    // https://github.com/rust-lang-nursery/rust-clippy/issues/2329
-    #[allow(clippy::needless_continue)]
-    fn parse_lit_byte_str_cooked(mut s: &str) -> (Vec<u8>, Box<str>) {
-        assert_eq!(byte(s, 0), b'b');
-        assert_eq!(byte(s, 1), b'"');
-        s = &s[2..];
-
-        // We're going to want to have slices which don't respect codepoint boundaries.
-        let mut v = s.as_bytes();
-
-        let mut out = Vec::new();
-        'outer: loop {
-            let byte = match byte(v, 0) {
-                b'"' => break,
-                b'\\' => {
-                    let b = byte(v, 1);
-                    v = &v[2..];
-                    match b {
-                        b'x' => {
-                            let (b, rest) = backslash_x(v);
-                            v = rest;
-                            b
-                        }
-                        b'n' => b'\n',
-                        b'r' => b'\r',
-                        b't' => b'\t',
-                        b'\\' => b'\\',
-                        b'0' => b'\0',
-                        b'\'' => b'\'',
-                        b'"' => b'"',
-                        b'\r' | b'\n' => loop {
-                            let byte = byte(v, 0);
-                            let ch = char::from_u32(u32::from(byte)).unwrap();
-                            if ch.is_whitespace() {
-                                v = &v[1..];
-                            } else {
-                                continue 'outer;
-                            }
-                        },
-                        b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
-                    }
-                }
-                b'\r' => {
-                    assert_eq!(byte(v, 1), b'\n', "Bare CR not allowed in string");
-                    v = &v[2..];
-                    b'\n'
-                }
-                b => {
-                    v = &v[1..];
-                    b
-                }
-            };
-            out.push(byte);
-        }
-
-        assert_eq!(byte(v, 0), b'"');
-        let suffix = s[s.len() - v.len() + 1..].to_owned().into_boxed_str();
-        (out, suffix)
-    }
-
-    fn parse_lit_byte_str_raw(s: &str) -> (Vec<u8>, Box<str>) {
-        assert_eq!(byte(s, 0), b'b');
-        let (value, suffix) = parse_lit_str_raw(&s[1..]);
-        (String::from(value).into_bytes(), suffix)
-    }
-
-    // Returns (value, suffix).
-    pub fn parse_lit_byte(s: &str) -> (u8, Box<str>) {
-        assert_eq!(byte(s, 0), b'b');
-        assert_eq!(byte(s, 1), b'\'');
-
-        // We're going to want to have slices which don't respect codepoint boundaries.
-        let mut v = s[2..].as_bytes();
-
-        let b = match byte(v, 0) {
-            b'\\' => {
-                let b = byte(v, 1);
-                v = &v[2..];
-                match b {
-                    b'x' => {
-                        let (b, rest) = backslash_x(v);
-                        v = rest;
-                        b
-                    }
-                    b'n' => b'\n',
-                    b'r' => b'\r',
-                    b't' => b'\t',
-                    b'\\' => b'\\',
-                    b'0' => b'\0',
-                    b'\'' => b'\'',
-                    b'"' => b'"',
-                    b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
-                }
-            }
-            b => {
-                v = &v[1..];
-                b
-            }
-        };
-
-        assert_eq!(byte(v, 0), b'\'');
-        let suffix = s[s.len() - v.len() + 1..].to_owned().into_boxed_str();
-        (b, suffix)
-    }
-
-    // Returns (value, suffix).
-    pub fn parse_lit_char(mut s: &str) -> (char, Box<str>) {
-        assert_eq!(byte(s, 0), b'\'');
-        s = &s[1..];
-
-        let ch = match byte(s, 0) {
-            b'\\' => {
-                let b = byte(s, 1);
-                s = &s[2..];
-                match b {
-                    b'x' => {
-                        let (byte, rest) = backslash_x(s);
-                        s = rest;
-                        assert!(byte <= 0x80, "Invalid \\x byte in string literal");
-                        char::from_u32(u32::from(byte)).unwrap()
-                    }
-                    b'u' => {
-                        let (chr, rest) = backslash_u(s);
-                        s = rest;
-                        chr
-                    }
-                    b'n' => '\n',
-                    b'r' => '\r',
-                    b't' => '\t',
-                    b'\\' => '\\',
-                    b'0' => '\0',
-                    b'\'' => '\'',
-                    b'"' => '"',
-                    b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
-                }
-            }
-            _ => {
-                let ch = next_chr(s);
-                s = &s[ch.len_utf8()..];
-                ch
-            }
-        };
-        assert_eq!(byte(s, 0), b'\'');
-        let suffix = s[1..].to_owned().into_boxed_str();
-        (ch, suffix)
-    }
-
-    fn backslash_x<S>(s: &S) -> (u8, &S)
-    where
-        S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized,
-    {
-        let mut ch = 0;
-        let b0 = byte(s, 0);
-        let b1 = byte(s, 1);
-        ch += 0x10
-            * match b0 {
-                b'0'..=b'9' => b0 - b'0',
-                b'a'..=b'f' => 10 + (b0 - b'a'),
-                b'A'..=b'F' => 10 + (b0 - b'A'),
-                _ => panic!("unexpected non-hex character after \\x"),
-            };
-        ch += match b1 {
-            b'0'..=b'9' => b1 - b'0',
-            b'a'..=b'f' => 10 + (b1 - b'a'),
-            b'A'..=b'F' => 10 + (b1 - b'A'),
-            _ => panic!("unexpected non-hex character after \\x"),
-        };
-        (ch, &s[2..])
-    }
-
-    fn backslash_u(mut s: &str) -> (char, &str) {
-        if byte(s, 0) != b'{' {
-            panic!("{}", "expected { after \\u");
-        }
-        s = &s[1..];
-
-        let mut ch = 0;
-        let mut digits = 0;
-        loop {
-            let b = byte(s, 0);
-            let digit = match b {
-                b'0'..=b'9' => b - b'0',
-                b'a'..=b'f' => 10 + b - b'a',
-                b'A'..=b'F' => 10 + b - b'A',
-                b'_' if digits > 0 => {
-                    s = &s[1..];
-                    continue;
-                }
-                b'}' if digits == 0 => panic!("invalid empty unicode escape"),
-                b'}' => break,
-                _ => panic!("unexpected non-hex character after \\u"),
-            };
-            if digits == 6 {
-                panic!("overlong unicode escape (must have at most 6 hex digits)");
-            }
-            ch *= 0x10;
-            ch += u32::from(digit);
-            digits += 1;
-            s = &s[1..];
-        }
-        assert!(byte(s, 0) == b'}');
-        s = &s[1..];
-
-        if let Some(ch) = char::from_u32(ch) {
-            (ch, s)
-        } else {
-            panic!("character code {:x} is not a valid unicode character", ch);
-        }
-    }
-
-    // Returns base 10 digits and suffix.
-    pub fn parse_lit_int(mut s: &str) -> Option<(Box<str>, Box<str>)> {
-        let negative = byte(s, 0) == b'-';
-        if negative {
-            s = &s[1..];
-        }
-
-        let base = match (byte(s, 0), byte(s, 1)) {
-            (b'0', b'x') => {
-                s = &s[2..];
-                16
-            }
-            (b'0', b'o') => {
-                s = &s[2..];
-                8
-            }
-            (b'0', b'b') => {
-                s = &s[2..];
-                2
-            }
-            (b'0'..=b'9', _) => 10,
-            _ => return None,
-        };
-
-        let mut value = BigInt::new();
-        'outer: loop {
-            let b = byte(s, 0);
-            let digit = match b {
-                b'0'..=b'9' => b - b'0',
-                b'a'..=b'f' if base > 10 => b - b'a' + 10,
-                b'A'..=b'F' if base > 10 => b - b'A' + 10,
-                b'_' => {
-                    s = &s[1..];
-                    continue;
-                }
-                // If looking at a floating point literal, we don't want to
-                // consider it an integer.
-                b'.' if base == 10 => return None,
-                b'e' | b'E' if base == 10 => {
-                    let mut has_exp = false;
-                    for (i, b) in s[1..].bytes().enumerate() {
-                        match b {
-                            b'_' => {}
-                            b'-' | b'+' => return None,
-                            b'0'..=b'9' => has_exp = true,
-                            _ => {
-                                let suffix = &s[1 + i..];
-                                if has_exp && crate::ident::xid_ok(suffix) {
-                                    return None;
-                                } else {
-                                    break 'outer;
-                                }
-                            }
-                        }
-                    }
-                    if has_exp {
-                        return None;
-                    } else {
-                        break;
-                    }
-                }
-                _ => break,
-            };
-
-            if digit >= base {
-                return None;
-            }
-
-            value *= base;
-            value += digit;
-            s = &s[1..];
-        }
-
-        let suffix = s;
-        if suffix.is_empty() || crate::ident::xid_ok(suffix) {
-            let mut repr = value.to_string();
-            if negative {
-                repr.insert(0, '-');
-            }
-            Some((repr.into_boxed_str(), suffix.to_owned().into_boxed_str()))
-        } else {
-            None
-        }
-    }
-
-    // Returns base 10 digits and suffix.
-    pub fn parse_lit_float(input: &str) -> Option<(Box<str>, Box<str>)> {
-        // Rust's floating point literals are very similar to the ones parsed by
-        // the standard library, except that rust's literals can contain
-        // ignorable underscores. Let's remove those underscores.
-
-        let mut bytes = input.to_owned().into_bytes();
-
-        let start = (*bytes.get(0)? == b'-') as usize;
-        match bytes.get(start)? {
-            b'0'..=b'9' => {}
-            _ => return None,
-        }
-
-        let mut read = start;
-        let mut write = start;
-        let mut has_dot = false;
-        let mut has_e = false;
-        let mut has_sign = false;
-        let mut has_exponent = false;
-        while read < bytes.len() {
-            match bytes[read] {
-                b'_' => {
-                    // Don't increase write
-                    read += 1;
-                    continue;
-                }
-                b'0'..=b'9' => {
-                    if has_e {
-                        has_exponent = true;
-                    }
-                    bytes[write] = bytes[read];
-                }
-                b'.' => {
-                    if has_e || has_dot {
-                        return None;
-                    }
-                    has_dot = true;
-                    bytes[write] = b'.';
-                }
-                b'e' | b'E' => {
-                    match bytes[read + 1..]
-                        .iter()
-                        .find(|b| **b != b'_')
-                        .unwrap_or(&b'\0')
-                    {
-                        b'-' | b'+' | b'0'..=b'9' => {}
-                        _ => break,
-                    }
-                    if has_e {
-                        if has_exponent {
-                            break;
-                        } else {
-                            return None;
-                        }
-                    }
-                    has_e = true;
-                    bytes[write] = b'e';
-                }
-                b'-' | b'+' => {
-                    if has_sign || has_exponent || !has_e {
-                        return None;
-                    }
-                    has_sign = true;
-                    if bytes[read] == b'-' {
-                        bytes[write] = bytes[read];
-                    } else {
-                        // Omit '+'
-                        read += 1;
-                        continue;
-                    }
-                }
-                _ => break,
-            }
-            read += 1;
-            write += 1;
-        }
-
-        if has_e && !has_exponent {
-            return None;
-        }
-
-        let mut digits = String::from_utf8(bytes).unwrap();
-        let suffix = digits.split_off(read);
-        digits.truncate(write);
-        if suffix.is_empty() || crate::ident::xid_ok(&suffix) {
-            Some((digits.into_boxed_str(), suffix.into_boxed_str()))
-        } else {
-            None
-        }
-    }
-
-    pub fn to_literal(repr: &str, digits: &str, suffix: &str) -> Option<Literal> {
-        if repr.starts_with('-') {
-            let f64_parse_finite = || digits.parse().ok().filter(|x: &f64| x.is_finite());
-            let f32_parse_finite = || digits.parse().ok().filter(|x: &f32| x.is_finite());
-            if suffix == "f64" {
-                f64_parse_finite().map(Literal::f64_suffixed)
-            } else if suffix == "f32" {
-                f32_parse_finite().map(Literal::f32_suffixed)
-            } else if suffix == "i64" {
-                digits.parse().ok().map(Literal::i64_suffixed)
-            } else if suffix == "i32" {
-                digits.parse().ok().map(Literal::i32_suffixed)
-            } else if suffix == "i16" {
-                digits.parse().ok().map(Literal::i16_suffixed)
-            } else if suffix == "i8" {
-                digits.parse().ok().map(Literal::i8_suffixed)
-            } else if !suffix.is_empty() {
-                None
-            } else if digits.contains('.') {
-                f64_parse_finite().map(Literal::f64_unsuffixed)
-            } else {
-                digits.parse().ok().map(Literal::i64_unsuffixed)
-            }
-        } else {
-            let stream = repr.parse::<TokenStream>().unwrap();
-            match stream.into_iter().next().unwrap() {
-                TokenTree::Literal(l) => Some(l),
-                _ => unreachable!(),
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/lookahead.rs b/vendor/syn/src/lookahead.rs
deleted file mode 100644
index f0ed628e..00000000
--- a/vendor/syn/src/lookahead.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use crate::buffer::Cursor;
-use crate::error::{self, Error};
-use crate::sealed::lookahead::Sealed;
-use crate::span::IntoSpans;
-use crate::token::Token;
-use proc_macro2::{Delimiter, Span};
-use std::cell::RefCell;
-
-/// Support for checking the next token in a stream to decide how to parse.
-///
-/// An important advantage over [`ParseStream::peek`] is that here we
-/// automatically construct an appropriate error message based on the token
-/// alternatives that get peeked. If you are producing your own error message,
-/// go ahead and use `ParseStream::peek` instead.
-///
-/// Use [`ParseStream::lookahead1`] to construct this object.
-///
-/// [`ParseStream::peek`]: crate::parse::ParseBuffer::peek
-/// [`ParseStream::lookahead1`]: crate::parse::ParseBuffer::lookahead1
-///
-/// # Example
-///
-/// ```
-/// use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam};
-/// use syn::parse::{Parse, ParseStream};
-///
-/// // A generic parameter, a single one of the comma-separated elements inside
-/// // angle brackets in:
-/// //
-/// //     fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... }
-/// //
-/// // On invalid input, lookahead gives us a reasonable error message.
-/// //
-/// //     error: expected one of: identifier, lifetime, `const`
-/// //       |
-/// //     5 |     fn f<!Sized>() {}
-/// //       |          ^
-/// enum GenericParam {
-///     Type(TypeParam),
-///     Lifetime(LifetimeDef),
-///     Const(ConstParam),
-/// }
-///
-/// impl Parse for GenericParam {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         let lookahead = input.lookahead1();
-///         if lookahead.peek(Ident) {
-///             input.parse().map(GenericParam::Type)
-///         } else if lookahead.peek(Lifetime) {
-///             input.parse().map(GenericParam::Lifetime)
-///         } else if lookahead.peek(Token![const]) {
-///             input.parse().map(GenericParam::Const)
-///         } else {
-///             Err(lookahead.error())
-///         }
-///     }
-/// }
-/// ```
-pub struct Lookahead1<'a> {
-    scope: Span,
-    cursor: Cursor<'a>,
-    comparisons: RefCell<Vec<&'static str>>,
-}
-
-pub fn new(scope: Span, cursor: Cursor) -> Lookahead1 {
-    Lookahead1 {
-        scope,
-        cursor,
-        comparisons: RefCell::new(Vec::new()),
-    }
-}
-
-fn peek_impl(
-    lookahead: &Lookahead1,
-    peek: fn(Cursor) -> bool,
-    display: fn() -> &'static str,
-) -> bool {
-    if peek(lookahead.cursor) {
-        return true;
-    }
-    lookahead.comparisons.borrow_mut().push(display());
-    false
-}
-
-impl<'a> Lookahead1<'a> {
-    /// Looks at the next token in the parse stream to determine whether it
-    /// matches the requested type of token.
-    ///
-    /// # Syntax
-    ///
-    /// Note that this method does not use turbofish syntax. Pass the peek type
-    /// inside of parentheses.
-    ///
-    /// - `input.peek(Token![struct])`
-    /// - `input.peek(Token![==])`
-    /// - `input.peek(Ident)`&emsp;*(does not accept keywords)*
-    /// - `input.peek(Ident::peek_any)`
-    /// - `input.peek(Lifetime)`
-    /// - `input.peek(token::Brace)`
-    pub fn peek<T: Peek>(&self, token: T) -> bool {
-        let _ = token;
-        peek_impl(self, T::Token::peek, T::Token::display)
-    }
-
-    /// Triggers an error at the current position of the parse stream.
-    ///
-    /// The error message will identify all of the expected token types that
-    /// have been peeked against this lookahead instance.
-    pub fn error(self) -> Error {
-        let comparisons = self.comparisons.borrow();
-        match comparisons.len() {
-            0 => {
-                if self.cursor.eof() {
-                    Error::new(self.scope, "unexpected end of input")
-                } else {
-                    Error::new(self.cursor.span(), "unexpected token")
-                }
-            }
-            1 => {
-                let message = format!("expected {}", comparisons[0]);
-                error::new_at(self.scope, self.cursor, message)
-            }
-            2 => {
-                let message = format!("expected {} or {}", comparisons[0], comparisons[1]);
-                error::new_at(self.scope, self.cursor, message)
-            }
-            _ => {
-                let join = comparisons.join(", ");
-                let message = format!("expected one of: {}", join);
-                error::new_at(self.scope, self.cursor, message)
-            }
-        }
-    }
-}
-
-/// Types that can be parsed by looking at just one token.
-///
-/// Use [`ParseStream::peek`] to peek one of these types in a parse stream
-/// without consuming it from the stream.
-///
-/// This trait is sealed and cannot be implemented for types outside of Syn.
-///
-/// [`ParseStream::peek`]: crate::parse::ParseBuffer::peek
-pub trait Peek: Sealed {
-    // Not public API.
-    #[doc(hidden)]
-    type Token: Token;
-}
-
-impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Peek for F {
-    type Token = T;
-}
-
-pub enum TokenMarker {}
-
-impl<S> IntoSpans<S> for TokenMarker {
-    fn into_spans(self) -> S {
-        match self {}
-    }
-}
-
-pub fn is_delimiter(cursor: Cursor, delimiter: Delimiter) -> bool {
-    cursor.group(delimiter).is_some()
-}
-
-impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Sealed for F {}
diff --git a/vendor/syn/src/mac.rs b/vendor/syn/src/mac.rs
deleted file mode 100644
index 3d84f8e4..00000000
--- a/vendor/syn/src/mac.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-use super::*;
-use crate::token::{Brace, Bracket, Paren};
-use proc_macro2::TokenStream;
-#[cfg(feature = "parsing")]
-use proc_macro2::{Delimiter, Group, Span, TokenTree};
-
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, ParseStream, Parser, Result};
-
-ast_struct! {
-    /// A macro invocation: `println!("{}", mac)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Macro {
-        pub path: Path,
-        pub bang_token: Token![!],
-        pub delimiter: MacroDelimiter,
-        pub tokens: TokenStream,
-    }
-}
-
-ast_enum! {
-    /// A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum MacroDelimiter {
-        Paren(Paren),
-        Brace(Brace),
-        Bracket(Bracket),
-    }
-}
-
-#[cfg(feature = "parsing")]
-fn delimiter_span_close(macro_delimiter: &MacroDelimiter) -> Span {
-    let delimiter = match macro_delimiter {
-        MacroDelimiter::Paren(_) => Delimiter::Parenthesis,
-        MacroDelimiter::Brace(_) => Delimiter::Brace,
-        MacroDelimiter::Bracket(_) => Delimiter::Bracket,
-    };
-    let mut group = Group::new(delimiter, TokenStream::new());
-    group.set_span(match macro_delimiter {
-        MacroDelimiter::Paren(token) => token.span,
-        MacroDelimiter::Brace(token) => token.span,
-        MacroDelimiter::Bracket(token) => token.span,
-    });
-    group.span_close()
-}
-
-impl Macro {
-    /// Parse the tokens within the macro invocation's delimiters into a syntax
-    /// tree.
-    ///
-    /// This is equivalent to `syn::parse2::<T>(mac.tokens)` except that it
-    /// produces a more useful span when `tokens` is empty.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{parse_quote, Expr, ExprLit, Ident, Lit, LitStr, Macro, Token};
-    /// use syn::ext::IdentExt;
-    /// use syn::parse::{Error, Parse, ParseStream, Result};
-    /// use syn::punctuated::Punctuated;
-    ///
-    /// // The arguments expected by libcore's format_args macro, and as a
-    /// // result most other formatting and printing macros like println.
-    /// //
-    /// //     println!("{} is {number:.prec$}", "x", prec=5, number=0.01)
-    /// struct FormatArgs {
-    ///     format_string: Expr,
-    ///     positional_args: Vec<Expr>,
-    ///     named_args: Vec<(Ident, Expr)>,
-    /// }
-    ///
-    /// impl Parse for FormatArgs {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let format_string: Expr;
-    ///         let mut positional_args = Vec::new();
-    ///         let mut named_args = Vec::new();
-    ///
-    ///         format_string = input.parse()?;
-    ///         while !input.is_empty() {
-    ///             input.parse::<Token![,]>()?;
-    ///             if input.is_empty() {
-    ///                 break;
-    ///             }
-    ///             if input.peek(Ident::peek_any) && input.peek2(Token![=]) {
-    ///                 while !input.is_empty() {
-    ///                     let name: Ident = input.call(Ident::parse_any)?;
-    ///                     input.parse::<Token![=]>()?;
-    ///                     let value: Expr = input.parse()?;
-    ///                     named_args.push((name, value));
-    ///                     if input.is_empty() {
-    ///                         break;
-    ///                     }
-    ///                     input.parse::<Token![,]>()?;
-    ///                 }
-    ///                 break;
-    ///             }
-    ///             positional_args.push(input.parse()?);
-    ///         }
-    ///
-    ///         Ok(FormatArgs {
-    ///             format_string,
-    ///             positional_args,
-    ///             named_args,
-    ///         })
-    ///     }
-    /// }
-    ///
-    /// // Extract the first argument, the format string literal, from an
-    /// // invocation of a formatting or printing macro.
-    /// fn get_format_string(m: &Macro) -> Result<LitStr> {
-    ///     let args: FormatArgs = m.parse_body()?;
-    ///     match args.format_string {
-    ///         Expr::Lit(ExprLit { lit: Lit::Str(lit), .. }) => Ok(lit),
-    ///         other => {
-    ///             // First argument was not a string literal expression.
-    ///             // Maybe something like: println!(concat!(...), ...)
-    ///             Err(Error::new_spanned(other, "format string must be a string literal"))
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let invocation = parse_quote! {
-    ///         println!("{:?}", Instant::now())
-    ///     };
-    ///     let lit = get_format_string(&invocation).unwrap();
-    ///     assert_eq!(lit.value(), "{:?}");
-    /// }
-    /// ```
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_body<T: Parse>(&self) -> Result<T> {
-        self.parse_body_with(T::parse)
-    }
-
-    /// Parse the tokens within the macro invocation's delimiters using the
-    /// given parser.
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output> {
-        let scope = delimiter_span_close(&self.delimiter);
-        crate::parse::parse_scoped(parser, scope, self.tokens.clone())
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub fn parse_delimiter(input: ParseStream) -> Result<(MacroDelimiter, TokenStream)> {
-    input.step(|cursor| {
-        if let Some((TokenTree::Group(g), rest)) = cursor.token_tree() {
-            let span = g.span();
-            let delimiter = match g.delimiter() {
-                Delimiter::Parenthesis => MacroDelimiter::Paren(Paren(span)),
-                Delimiter::Brace => MacroDelimiter::Brace(Brace(span)),
-                Delimiter::Bracket => MacroDelimiter::Bracket(Bracket(span)),
-                Delimiter::None => {
-                    return Err(cursor.error("expected delimiter"));
-                }
-            };
-            Ok(((delimiter, g.stream()), rest))
-        } else {
-            Err(cursor.error("expected delimiter"))
-        }
-    })
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Macro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let tokens;
-            Ok(Macro {
-                path: input.call(Path::parse_mod_style)?,
-                bang_token: input.parse()?,
-                delimiter: {
-                    let (delimiter, content) = parse_delimiter(input)?;
-                    tokens = content;
-                    delimiter
-                },
-                tokens,
-            })
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::ToTokens;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Macro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.path.to_tokens(tokens);
-            self.bang_token.to_tokens(tokens);
-            match &self.delimiter {
-                MacroDelimiter::Paren(paren) => {
-                    paren.surround(tokens, |tokens| self.tokens.to_tokens(tokens));
-                }
-                MacroDelimiter::Brace(brace) => {
-                    brace.surround(tokens, |tokens| self.tokens.to_tokens(tokens));
-                }
-                MacroDelimiter::Bracket(bracket) => {
-                    bracket.surround(tokens, |tokens| self.tokens.to_tokens(tokens));
-                }
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/macros.rs b/vendor/syn/src/macros.rs
deleted file mode 100644
index 5097da94..00000000
--- a/vendor/syn/src/macros.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-macro_rules! ast_struct {
-    (
-        [$($attrs_pub:tt)*]
-        struct $name:ident #full $($rest:tt)*
-    ) => {
-        #[cfg(feature = "full")]
-        $($attrs_pub)* struct $name $($rest)*
-
-        #[cfg(not(feature = "full"))]
-        $($attrs_pub)* struct $name {
-            _noconstruct: ::std::marker::PhantomData<::proc_macro2::Span>,
-        }
-
-        #[cfg(all(not(feature = "full"), feature = "printing"))]
-        impl ::quote::ToTokens for $name {
-            fn to_tokens(&self, _: &mut ::proc_macro2::TokenStream) {
-                unreachable!()
-            }
-        }
-    };
-
-    (
-        [$($attrs_pub:tt)*]
-        struct $name:ident $($rest:tt)*
-    ) => {
-        $($attrs_pub)* struct $name $($rest)*
-    };
-
-    ($($t:tt)*) => {
-        strip_attrs_pub!(ast_struct!($($t)*));
-    };
-}
-
-macro_rules! ast_enum {
-    // Drop the `#no_visit` attribute, if present.
-    (
-        [$($attrs_pub:tt)*]
-        enum $name:ident #no_visit $($rest:tt)*
-    ) => (
-        ast_enum!([$($attrs_pub)*] enum $name $($rest)*);
-    );
-
-    (
-        [$($attrs_pub:tt)*]
-        enum $name:ident $($rest:tt)*
-    ) => (
-        $($attrs_pub)* enum $name $($rest)*
-    );
-
-    ($($t:tt)*) => {
-        strip_attrs_pub!(ast_enum!($($t)*));
-    };
-}
-
-macro_rules! ast_enum_of_structs {
-    (
-        $(#[$enum_attr:meta])*
-        $pub:ident $enum:ident $name:ident #$tag:ident $body:tt
-        $($remaining:tt)*
-    ) => {
-        ast_enum!($(#[$enum_attr])* $pub $enum $name #$tag $body);
-        ast_enum_of_structs_impl!($pub $enum $name $body $($remaining)*);
-    };
-
-    (
-        $(#[$enum_attr:meta])*
-        $pub:ident $enum:ident $name:ident $body:tt
-        $($remaining:tt)*
-    ) => {
-        ast_enum!($(#[$enum_attr])* $pub $enum $name $body);
-        ast_enum_of_structs_impl!($pub $enum $name $body $($remaining)*);
-    };
-}
-
-macro_rules! ast_enum_of_structs_impl {
-    (
-        $pub:ident $enum:ident $name:ident {
-            $(
-                $(#[$variant_attr:meta])*
-                $variant:ident $( ($($member:ident)::+) )*,
-            )*
-        }
-
-        $($remaining:tt)*
-    ) => {
-        check_keyword_matches!(pub $pub);
-        check_keyword_matches!(enum $enum);
-
-        $($(
-            ast_enum_from_struct!($name::$variant, $($member)::+);
-        )*)*
-
-        #[cfg(feature = "printing")]
-        generate_to_tokens! {
-            $($remaining)*
-            ()
-            tokens
-            $name { $($variant $($($member)::+)*,)* }
-        }
-    };
-}
-
-macro_rules! ast_enum_from_struct {
-    // No From<TokenStream> for verbatim variants.
-    ($name:ident::Verbatim, $member:ident) => {};
-
-    // No From<TokenStream> for private variants.
-    ($name:ident::$variant:ident, crate::private) => {};
-
-    ($name:ident::$variant:ident, $member:ident) => {
-        impl From<$member> for $name {
-            fn from(e: $member) -> $name {
-                $name::$variant(e)
-            }
-        }
-    };
-}
-
-#[cfg(feature = "printing")]
-macro_rules! generate_to_tokens {
-    (do_not_generate_to_tokens $($foo:tt)*) => ();
-
-    (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident, $($next:tt)*}) => {
-        generate_to_tokens!(
-            ($($arms)* $name::$variant => {})
-            $tokens $name { $($next)* }
-        );
-    };
-
-    (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident $member:ident, $($next:tt)*}) => {
-        generate_to_tokens!(
-            ($($arms)* $name::$variant(_e) => _e.to_tokens($tokens),)
-            $tokens $name { $($next)* }
-        );
-    };
-
-    (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident crate::private, $($next:tt)*}) => {
-        generate_to_tokens!(
-            ($($arms)* $name::$variant(_) => unreachable!(),)
-            $tokens $name { $($next)* }
-        );
-    };
-
-    (($($arms:tt)*) $tokens:ident $name:ident {}) => {
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-        impl ::quote::ToTokens for $name {
-            fn to_tokens(&self, $tokens: &mut ::proc_macro2::TokenStream) {
-                match self {
-                    $($arms)*
-                }
-            }
-        }
-    };
-}
-
-macro_rules! strip_attrs_pub {
-    ($mac:ident!($(#[$m:meta])* $pub:ident $($t:tt)*)) => {
-        check_keyword_matches!(pub $pub);
-
-        $mac!([$(#[$m])* $pub] $($t)*);
-    };
-}
-
-macro_rules! check_keyword_matches {
-    (struct struct) => {};
-    (enum enum) => {};
-    (pub pub) => {};
-}
diff --git a/vendor/syn/src/op.rs b/vendor/syn/src/op.rs
deleted file mode 100644
index b8ef9a7f..00000000
--- a/vendor/syn/src/op.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-ast_enum! {
-    /// A binary operator: `+`, `+=`, `&`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum BinOp {
-        /// The `+` operator (addition)
-        Add(Token![+]),
-        /// The `-` operator (subtraction)
-        Sub(Token![-]),
-        /// The `*` operator (multiplication)
-        Mul(Token![*]),
-        /// The `/` operator (division)
-        Div(Token![/]),
-        /// The `%` operator (modulus)
-        Rem(Token![%]),
-        /// The `&&` operator (logical and)
-        And(Token![&&]),
-        /// The `||` operator (logical or)
-        Or(Token![||]),
-        /// The `^` operator (bitwise xor)
-        BitXor(Token![^]),
-        /// The `&` operator (bitwise and)
-        BitAnd(Token![&]),
-        /// The `|` operator (bitwise or)
-        BitOr(Token![|]),
-        /// The `<<` operator (shift left)
-        Shl(Token![<<]),
-        /// The `>>` operator (shift right)
-        Shr(Token![>>]),
-        /// The `==` operator (equality)
-        Eq(Token![==]),
-        /// The `<` operator (less than)
-        Lt(Token![<]),
-        /// The `<=` operator (less than or equal to)
-        Le(Token![<=]),
-        /// The `!=` operator (not equal to)
-        Ne(Token![!=]),
-        /// The `>=` operator (greater than or equal to)
-        Ge(Token![>=]),
-        /// The `>` operator (greater than)
-        Gt(Token![>]),
-        /// The `+=` operator
-        AddEq(Token![+=]),
-        /// The `-=` operator
-        SubEq(Token![-=]),
-        /// The `*=` operator
-        MulEq(Token![*=]),
-        /// The `/=` operator
-        DivEq(Token![/=]),
-        /// The `%=` operator
-        RemEq(Token![%=]),
-        /// The `^=` operator
-        BitXorEq(Token![^=]),
-        /// The `&=` operator
-        BitAndEq(Token![&=]),
-        /// The `|=` operator
-        BitOrEq(Token![|=]),
-        /// The `<<=` operator
-        ShlEq(Token![<<=]),
-        /// The `>>=` operator
-        ShrEq(Token![>>=]),
-    }
-}
-
-ast_enum! {
-    /// A unary operator: `*`, `!`, `-`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum UnOp {
-        /// The `*` operator for dereferencing
-        Deref(Token![*]),
-        /// The `!` operator for logical inversion
-        Not(Token![!]),
-        /// The `-` operator for negation
-        Neg(Token![-]),
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    fn parse_binop(input: ParseStream) -> Result<BinOp> {
-        if input.peek(Token![&&]) {
-            input.parse().map(BinOp::And)
-        } else if input.peek(Token![||]) {
-            input.parse().map(BinOp::Or)
-        } else if input.peek(Token![<<]) {
-            input.parse().map(BinOp::Shl)
-        } else if input.peek(Token![>>]) {
-            input.parse().map(BinOp::Shr)
-        } else if input.peek(Token![==]) {
-            input.parse().map(BinOp::Eq)
-        } else if input.peek(Token![<=]) {
-            input.parse().map(BinOp::Le)
-        } else if input.peek(Token![!=]) {
-            input.parse().map(BinOp::Ne)
-        } else if input.peek(Token![>=]) {
-            input.parse().map(BinOp::Ge)
-        } else if input.peek(Token![+]) {
-            input.parse().map(BinOp::Add)
-        } else if input.peek(Token![-]) {
-            input.parse().map(BinOp::Sub)
-        } else if input.peek(Token![*]) {
-            input.parse().map(BinOp::Mul)
-        } else if input.peek(Token![/]) {
-            input.parse().map(BinOp::Div)
-        } else if input.peek(Token![%]) {
-            input.parse().map(BinOp::Rem)
-        } else if input.peek(Token![^]) {
-            input.parse().map(BinOp::BitXor)
-        } else if input.peek(Token![&]) {
-            input.parse().map(BinOp::BitAnd)
-        } else if input.peek(Token![|]) {
-            input.parse().map(BinOp::BitOr)
-        } else if input.peek(Token![<]) {
-            input.parse().map(BinOp::Lt)
-        } else if input.peek(Token![>]) {
-            input.parse().map(BinOp::Gt)
-        } else {
-            Err(input.error("expected binary operator"))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for BinOp {
-        #[cfg(not(feature = "full"))]
-        fn parse(input: ParseStream) -> Result<Self> {
-            parse_binop(input)
-        }
-
-        #[cfg(feature = "full")]
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Token![+=]) {
-                input.parse().map(BinOp::AddEq)
-            } else if input.peek(Token![-=]) {
-                input.parse().map(BinOp::SubEq)
-            } else if input.peek(Token![*=]) {
-                input.parse().map(BinOp::MulEq)
-            } else if input.peek(Token![/=]) {
-                input.parse().map(BinOp::DivEq)
-            } else if input.peek(Token![%=]) {
-                input.parse().map(BinOp::RemEq)
-            } else if input.peek(Token![^=]) {
-                input.parse().map(BinOp::BitXorEq)
-            } else if input.peek(Token![&=]) {
-                input.parse().map(BinOp::BitAndEq)
-            } else if input.peek(Token![|=]) {
-                input.parse().map(BinOp::BitOrEq)
-            } else if input.peek(Token![<<=]) {
-                input.parse().map(BinOp::ShlEq)
-            } else if input.peek(Token![>>=]) {
-                input.parse().map(BinOp::ShrEq)
-            } else {
-                parse_binop(input)
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for UnOp {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let lookahead = input.lookahead1();
-            if lookahead.peek(Token![*]) {
-                input.parse().map(UnOp::Deref)
-            } else if lookahead.peek(Token![!]) {
-                input.parse().map(UnOp::Not)
-            } else if lookahead.peek(Token![-]) {
-                input.parse().map(UnOp::Neg)
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::ToTokens;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for BinOp {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                BinOp::Add(t) => t.to_tokens(tokens),
-                BinOp::Sub(t) => t.to_tokens(tokens),
-                BinOp::Mul(t) => t.to_tokens(tokens),
-                BinOp::Div(t) => t.to_tokens(tokens),
-                BinOp::Rem(t) => t.to_tokens(tokens),
-                BinOp::And(t) => t.to_tokens(tokens),
-                BinOp::Or(t) => t.to_tokens(tokens),
-                BinOp::BitXor(t) => t.to_tokens(tokens),
-                BinOp::BitAnd(t) => t.to_tokens(tokens),
-                BinOp::BitOr(t) => t.to_tokens(tokens),
-                BinOp::Shl(t) => t.to_tokens(tokens),
-                BinOp::Shr(t) => t.to_tokens(tokens),
-                BinOp::Eq(t) => t.to_tokens(tokens),
-                BinOp::Lt(t) => t.to_tokens(tokens),
-                BinOp::Le(t) => t.to_tokens(tokens),
-                BinOp::Ne(t) => t.to_tokens(tokens),
-                BinOp::Ge(t) => t.to_tokens(tokens),
-                BinOp::Gt(t) => t.to_tokens(tokens),
-                BinOp::AddEq(t) => t.to_tokens(tokens),
-                BinOp::SubEq(t) => t.to_tokens(tokens),
-                BinOp::MulEq(t) => t.to_tokens(tokens),
-                BinOp::DivEq(t) => t.to_tokens(tokens),
-                BinOp::RemEq(t) => t.to_tokens(tokens),
-                BinOp::BitXorEq(t) => t.to_tokens(tokens),
-                BinOp::BitAndEq(t) => t.to_tokens(tokens),
-                BinOp::BitOrEq(t) => t.to_tokens(tokens),
-                BinOp::ShlEq(t) => t.to_tokens(tokens),
-                BinOp::ShrEq(t) => t.to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for UnOp {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                UnOp::Deref(t) => t.to_tokens(tokens),
-                UnOp::Not(t) => t.to_tokens(tokens),
-                UnOp::Neg(t) => t.to_tokens(tokens),
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/parse.rs b/vendor/syn/src/parse.rs
deleted file mode 100644
index d85968bd..00000000
--- a/vendor/syn/src/parse.rs
+++ /dev/null
@@ -1,1287 +0,0 @@
-//! Parsing interface for parsing a token stream into a syntax tree node.
-//!
-//! Parsing in Syn is built on parser functions that take in a [`ParseStream`]
-//! and produce a [`Result<T>`] where `T` is some syntax tree node. Underlying
-//! these parser functions is a lower level mechanism built around the
-//! [`Cursor`] type. `Cursor` is a cheaply copyable cursor over a range of
-//! tokens in a token stream.
-//!
-//! [`Result<T>`]: Result
-//! [`Cursor`]: crate::buffer::Cursor
-//!
-//! # Example
-//!
-//! Here is a snippet of parsing code to get a feel for the style of the
-//! library. We define data structures for a subset of Rust syntax including
-//! enums (not shown) and structs, then provide implementations of the [`Parse`]
-//! trait to parse these syntax tree data structures from a token stream.
-//!
-//! Once `Parse` impls have been defined, they can be called conveniently from a
-//! procedural macro through [`parse_macro_input!`] as shown at the bottom of
-//! the snippet. If the caller provides syntactically invalid input to the
-//! procedural macro, they will receive a helpful compiler error message
-//! pointing out the exact token that triggered the failure to parse.
-//!
-//! [`parse_macro_input!`]: crate::parse_macro_input!
-//!
-//! ```
-//! # extern crate proc_macro;
-//! #
-//! use proc_macro::TokenStream;
-//! use syn::{braced, parse_macro_input, token, Field, Ident, Result, Token};
-//! use syn::parse::{Parse, ParseStream};
-//! use syn::punctuated::Punctuated;
-//!
-//! enum Item {
-//!     Struct(ItemStruct),
-//!     Enum(ItemEnum),
-//! }
-//!
-//! struct ItemStruct {
-//!     struct_token: Token![struct],
-//!     ident: Ident,
-//!     brace_token: token::Brace,
-//!     fields: Punctuated<Field, Token![,]>,
-//! }
-//! #
-//! # enum ItemEnum {}
-//!
-//! impl Parse for Item {
-//!     fn parse(input: ParseStream) -> Result<Self> {
-//!         let lookahead = input.lookahead1();
-//!         if lookahead.peek(Token![struct]) {
-//!             input.parse().map(Item::Struct)
-//!         } else if lookahead.peek(Token![enum]) {
-//!             input.parse().map(Item::Enum)
-//!         } else {
-//!             Err(lookahead.error())
-//!         }
-//!     }
-//! }
-//!
-//! impl Parse for ItemStruct {
-//!     fn parse(input: ParseStream) -> Result<Self> {
-//!         let content;
-//!         Ok(ItemStruct {
-//!             struct_token: input.parse()?,
-//!             ident: input.parse()?,
-//!             brace_token: braced!(content in input),
-//!             fields: content.parse_terminated(Field::parse_named)?,
-//!         })
-//!     }
-//! }
-//! #
-//! # impl Parse for ItemEnum {
-//! #     fn parse(input: ParseStream) -> Result<Self> {
-//! #         unimplemented!()
-//! #     }
-//! # }
-//!
-//! # const IGNORE: &str = stringify! {
-//! #[proc_macro]
-//! # };
-//! pub fn my_macro(tokens: TokenStream) -> TokenStream {
-//!     let input = parse_macro_input!(tokens as Item);
-//!
-//!     /* ... */
-//! #   "".parse().unwrap()
-//! }
-//! ```
-//!
-//! # The `syn::parse*` functions
-//!
-//! The [`syn::parse`], [`syn::parse2`], and [`syn::parse_str`] functions serve
-//! as an entry point for parsing syntax tree nodes that can be parsed in an
-//! obvious default way. These functions can return any syntax tree node that
-//! implements the [`Parse`] trait, which includes most types in Syn.
-//!
-//! [`syn::parse`]: crate::parse()
-//! [`syn::parse2`]: crate::parse2()
-//! [`syn::parse_str`]: crate::parse_str()
-//!
-//! ```
-//! use syn::Type;
-//!
-//! # fn run_parser() -> syn::Result<()> {
-//! let t: Type = syn::parse_str("std::collections::HashMap<String, Value>")?;
-//! #     Ok(())
-//! # }
-//! #
-//! # run_parser().unwrap();
-//! ```
-//!
-//! The [`parse_quote!`] macro also uses this approach.
-//!
-//! [`parse_quote!`]: crate::parse_quote!
-//!
-//! # The `Parser` trait
-//!
-//! Some types can be parsed in several ways depending on context. For example
-//! an [`Attribute`] can be either "outer" like `#[...]` or "inner" like
-//! `#![...]` and parsing the wrong one would be a bug. Similarly [`Punctuated`]
-//! may or may not allow trailing punctuation, and parsing it the wrong way
-//! would either reject valid input or accept invalid input.
-//!
-//! [`Attribute`]: crate::Attribute
-//! [`Punctuated`]: crate::punctuated
-//!
-//! The `Parse` trait is not implemented in these cases because there is no good
-//! behavior to consider the default.
-//!
-//! ```compile_fail
-//! # extern crate proc_macro;
-//! #
-//! # use syn::punctuated::Punctuated;
-//! # use syn::{PathSegment, Result, Token};
-//! #
-//! # fn f(tokens: proc_macro::TokenStream) -> Result<()> {
-//! #
-//! // Can't parse `Punctuated` without knowing whether trailing punctuation
-//! // should be allowed in this context.
-//! let path: Punctuated<PathSegment, Token![::]> = syn::parse(tokens)?;
-//! #
-//! #     Ok(())
-//! # }
-//! ```
-//!
-//! In these cases the types provide a choice of parser functions rather than a
-//! single `Parse` implementation, and those parser functions can be invoked
-//! through the [`Parser`] trait.
-//!
-//!
-//! ```
-//! # extern crate proc_macro;
-//! #
-//! use proc_macro::TokenStream;
-//! use syn::parse::Parser;
-//! use syn::punctuated::Punctuated;
-//! use syn::{Attribute, Expr, PathSegment, Result, Token};
-//!
-//! fn call_some_parser_methods(input: TokenStream) -> Result<()> {
-//!     // Parse a nonempty sequence of path segments separated by `::` punctuation
-//!     // with no trailing punctuation.
-//!     let tokens = input.clone();
-//!     let parser = Punctuated::<PathSegment, Token![::]>::parse_separated_nonempty;
-//!     let _path = parser.parse(tokens)?;
-//!
-//!     // Parse a possibly empty sequence of expressions terminated by commas with
-//!     // an optional trailing punctuation.
-//!     let tokens = input.clone();
-//!     let parser = Punctuated::<Expr, Token![,]>::parse_terminated;
-//!     let _args = parser.parse(tokens)?;
-//!
-//!     // Parse zero or more outer attributes but not inner attributes.
-//!     let tokens = input.clone();
-//!     let parser = Attribute::parse_outer;
-//!     let _attrs = parser.parse(tokens)?;
-//!
-//!     Ok(())
-//! }
-//! ```
-//!
-//! ---
-//!
-//! *This module is available only if Syn is built with the `"parsing"` feature.*
-
-#[path = "discouraged.rs"]
-pub mod discouraged;
-
-use crate::buffer::{Cursor, TokenBuffer};
-use crate::error;
-use crate::lookahead;
-#[cfg(all(
-    not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-    feature = "proc-macro"
-))]
-use crate::proc_macro;
-use crate::punctuated::Punctuated;
-use crate::token::Token;
-use proc_macro2::{self, Delimiter, Group, Literal, Punct, Span, TokenStream, TokenTree};
-use std::cell::Cell;
-use std::fmt::{self, Debug, Display};
-use std::marker::PhantomData;
-use std::mem;
-use std::ops::Deref;
-use std::rc::Rc;
-use std::str::FromStr;
-
-pub use crate::error::{Error, Result};
-pub use crate::lookahead::{Lookahead1, Peek};
-
-/// Parsing interface implemented by all types that can be parsed in a default
-/// way from a token stream.
-///
-/// Refer to the [module documentation] for details about implementing and using
-/// the `Parse` trait.
-///
-/// [module documentation]: self
-pub trait Parse: Sized {
-    fn parse(input: ParseStream) -> Result<Self>;
-}
-
-/// Input to a Syn parser function.
-///
-/// See the methods of this type under the documentation of [`ParseBuffer`]. For
-/// an overview of parsing in Syn, refer to the [module documentation].
-///
-/// [module documentation]: self
-pub type ParseStream<'a> = &'a ParseBuffer<'a>;
-
-/// Cursor position within a buffered token stream.
-///
-/// This type is more commonly used through the type alias [`ParseStream`] which
-/// is an alias for `&ParseBuffer`.
-///
-/// `ParseStream` is the input type for all parser functions in Syn. They have
-/// the signature `fn(ParseStream) -> Result<T>`.
-///
-/// ## Calling a parser function
-///
-/// There is no public way to construct a `ParseBuffer`. Instead, if you are
-/// looking to invoke a parser function that requires `ParseStream` as input,
-/// you will need to go through one of the public parsing entry points.
-///
-/// - The [`parse_macro_input!`] macro if parsing input of a procedural macro;
-/// - One of [the `syn::parse*` functions][syn-parse]; or
-/// - A method of the [`Parser`] trait.
-///
-/// [syn-parse]: self#the-synparse-functions
-pub struct ParseBuffer<'a> {
-    scope: Span,
-    // Instead of Cell<Cursor<'a>> so that ParseBuffer<'a> is covariant in 'a.
-    // The rest of the code in this module needs to be careful that only a
-    // cursor derived from this `cell` is ever assigned to this `cell`.
-    //
-    // Cell<Cursor<'a>> cannot be covariant in 'a because then we could take a
-    // ParseBuffer<'a>, upcast to ParseBuffer<'short> for some lifetime shorter
-    // than 'a, and then assign a Cursor<'short> into the Cell.
-    //
-    // By extension, it would not be safe to expose an API that accepts a
-    // Cursor<'a> and trusts that it lives as long as the cursor currently in
-    // the cell.
-    cell: Cell<Cursor<'static>>,
-    marker: PhantomData<Cursor<'a>>,
-    unexpected: Cell<Option<Rc<Cell<Unexpected>>>>,
-}
-
-impl<'a> Drop for ParseBuffer<'a> {
-    fn drop(&mut self) {
-        if let Some(unexpected_span) = span_of_unexpected_ignoring_nones(self.cursor()) {
-            let (inner, old_span) = inner_unexpected(self);
-            if old_span.is_none() {
-                inner.set(Unexpected::Some(unexpected_span));
-            }
-        }
-    }
-}
-
-impl<'a> Display for ParseBuffer<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.cursor().token_stream(), f)
-    }
-}
-
-impl<'a> Debug for ParseBuffer<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.cursor().token_stream(), f)
-    }
-}
-
-/// Cursor state associated with speculative parsing.
-///
-/// This type is the input of the closure provided to [`ParseStream::step`].
-///
-/// [`ParseStream::step`]: ParseBuffer::step
-///
-/// # Example
-///
-/// ```
-/// use proc_macro2::TokenTree;
-/// use syn::Result;
-/// use syn::parse::ParseStream;
-///
-/// // This function advances the stream past the next occurrence of `@`. If
-/// // no `@` is present in the stream, the stream position is unchanged and
-/// // an error is returned.
-/// fn skip_past_next_at(input: ParseStream) -> Result<()> {
-///     input.step(|cursor| {
-///         let mut rest = *cursor;
-///         while let Some((tt, next)) = rest.token_tree() {
-///             match &tt {
-///                 TokenTree::Punct(punct) if punct.as_char() == '@' => {
-///                     return Ok(((), next));
-///                 }
-///                 _ => rest = next,
-///             }
-///         }
-///         Err(cursor.error("no `@` was found after this point"))
-///     })
-/// }
-/// #
-/// # fn remainder_after_skipping_past_next_at(
-/// #     input: ParseStream,
-/// # ) -> Result<proc_macro2::TokenStream> {
-/// #     skip_past_next_at(input)?;
-/// #     input.parse()
-/// # }
-/// #
-/// # use syn::parse::Parser;
-/// # let remainder = remainder_after_skipping_past_next_at
-/// #     .parse_str("a @ b c")
-/// #     .unwrap();
-/// # assert_eq!(remainder.to_string(), "b c");
-/// ```
-pub struct StepCursor<'c, 'a> {
-    scope: Span,
-    // This field is covariant in 'c.
-    cursor: Cursor<'c>,
-    // This field is contravariant in 'c. Together these make StepCursor
-    // invariant in 'c. Also covariant in 'a. The user cannot cast 'c to a
-    // different lifetime but can upcast into a StepCursor with a shorter
-    // lifetime 'a.
-    //
-    // As long as we only ever construct a StepCursor for which 'c outlives 'a,
-    // this means if ever a StepCursor<'c, 'a> exists we are guaranteed that 'c
-    // outlives 'a.
-    marker: PhantomData<fn(Cursor<'c>) -> Cursor<'a>>,
-}
-
-impl<'c, 'a> Deref for StepCursor<'c, 'a> {
-    type Target = Cursor<'c>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.cursor
-    }
-}
-
-impl<'c, 'a> Copy for StepCursor<'c, 'a> {}
-
-impl<'c, 'a> Clone for StepCursor<'c, 'a> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<'c, 'a> StepCursor<'c, 'a> {
-    /// Triggers an error at the current position of the parse stream.
-    ///
-    /// The `ParseStream::step` invocation will return this same error without
-    /// advancing the stream state.
-    pub fn error<T: Display>(self, message: T) -> Error {
-        error::new_at(self.scope, self.cursor, message)
-    }
-}
-
-pub(crate) fn advance_step_cursor<'c, 'a>(proof: StepCursor<'c, 'a>, to: Cursor<'c>) -> Cursor<'a> {
-    // Refer to the comments within the StepCursor definition. We use the
-    // fact that a StepCursor<'c, 'a> exists as proof that 'c outlives 'a.
-    // Cursor is covariant in its lifetime parameter so we can cast a
-    // Cursor<'c> to one with the shorter lifetime Cursor<'a>.
-    let _ = proof;
-    unsafe { mem::transmute::<Cursor<'c>, Cursor<'a>>(to) }
-}
-
-pub(crate) fn new_parse_buffer(
-    scope: Span,
-    cursor: Cursor,
-    unexpected: Rc<Cell<Unexpected>>,
-) -> ParseBuffer {
-    ParseBuffer {
-        scope,
-        // See comment on `cell` in the struct definition.
-        cell: Cell::new(unsafe { mem::transmute::<Cursor, Cursor<'static>>(cursor) }),
-        marker: PhantomData,
-        unexpected: Cell::new(Some(unexpected)),
-    }
-}
-
-pub(crate) enum Unexpected {
-    None,
-    Some(Span),
-    Chain(Rc<Cell<Unexpected>>),
-}
-
-impl Default for Unexpected {
-    fn default() -> Self {
-        Unexpected::None
-    }
-}
-
-impl Clone for Unexpected {
-    fn clone(&self) -> Self {
-        match self {
-            Unexpected::None => Unexpected::None,
-            Unexpected::Some(span) => Unexpected::Some(*span),
-            Unexpected::Chain(next) => Unexpected::Chain(next.clone()),
-        }
-    }
-}
-
-// We call this on Cell<Unexpected> and Cell<Option<T>> where temporarily
-// swapping in a None is cheap.
-fn cell_clone<T: Default + Clone>(cell: &Cell<T>) -> T {
-    let prev = cell.take();
-    let ret = prev.clone();
-    cell.set(prev);
-    ret
-}
-
-fn inner_unexpected(buffer: &ParseBuffer) -> (Rc<Cell<Unexpected>>, Option<Span>) {
-    let mut unexpected = get_unexpected(buffer);
-    loop {
-        match cell_clone(&unexpected) {
-            Unexpected::None => return (unexpected, None),
-            Unexpected::Some(span) => return (unexpected, Some(span)),
-            Unexpected::Chain(next) => unexpected = next,
-        }
-    }
-}
-
-pub(crate) fn get_unexpected(buffer: &ParseBuffer) -> Rc<Cell<Unexpected>> {
-    cell_clone(&buffer.unexpected).unwrap()
-}
-
-fn span_of_unexpected_ignoring_nones(mut cursor: Cursor) -> Option<Span> {
-    if cursor.eof() {
-        return None;
-    }
-    while let Some((inner, _span, rest)) = cursor.group(Delimiter::None) {
-        if let Some(unexpected) = span_of_unexpected_ignoring_nones(inner) {
-            return Some(unexpected);
-        }
-        cursor = rest;
-    }
-    if cursor.eof() {
-        None
-    } else {
-        Some(cursor.span())
-    }
-}
-
-impl<'a> ParseBuffer<'a> {
-    /// Parses a syntax tree node of type `T`, advancing the position of our
-    /// parse stream past it.
-    pub fn parse<T: Parse>(&self) -> Result<T> {
-        T::parse(self)
-    }
-
-    /// Calls the given parser function to parse a syntax tree node of type `T`
-    /// from this stream.
-    ///
-    /// # Example
-    ///
-    /// The parser below invokes [`Attribute::parse_outer`] to parse a vector of
-    /// zero or more outer attributes.
-    ///
-    /// [`Attribute::parse_outer`]: crate::Attribute::parse_outer
-    ///
-    /// ```
-    /// use syn::{Attribute, Ident, Result, Token};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // Parses a unit struct with attributes.
-    /// //
-    /// //     #[path = "s.tmpl"]
-    /// //     struct S;
-    /// struct UnitStruct {
-    ///     attrs: Vec<Attribute>,
-    ///     struct_token: Token![struct],
-    ///     name: Ident,
-    ///     semi_token: Token![;],
-    /// }
-    ///
-    /// impl Parse for UnitStruct {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         Ok(UnitStruct {
-    ///             attrs: input.call(Attribute::parse_outer)?,
-    ///             struct_token: input.parse()?,
-    ///             name: input.parse()?,
-    ///             semi_token: input.parse()?,
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    pub fn call<T>(&self, function: fn(ParseStream) -> Result<T>) -> Result<T> {
-        function(self)
-    }
-
-    /// Looks at the next token in the parse stream to determine whether it
-    /// matches the requested type of token.
-    ///
-    /// Does not advance the position of the parse stream.
-    ///
-    /// # Syntax
-    ///
-    /// Note that this method does not use turbofish syntax. Pass the peek type
-    /// inside of parentheses.
-    ///
-    /// - `input.peek(Token![struct])`
-    /// - `input.peek(Token![==])`
-    /// - `input.peek(Ident)`&emsp;*(does not accept keywords)*
-    /// - `input.peek(Ident::peek_any)`
-    /// - `input.peek(Lifetime)`
-    /// - `input.peek(token::Brace)`
-    ///
-    /// # Example
-    ///
-    /// In this example we finish parsing the list of supertraits when the next
-    /// token in the input is either `where` or an opening curly brace.
-    ///
-    /// ```
-    /// use syn::{braced, token, Generics, Ident, Result, Token, TypeParamBound};
-    /// use syn::parse::{Parse, ParseStream};
-    /// use syn::punctuated::Punctuated;
-    ///
-    /// // Parses a trait definition containing no associated items.
-    /// //
-    /// //     trait Marker<'de, T>: A + B<'de> where Box<T>: Clone {}
-    /// struct MarkerTrait {
-    ///     trait_token: Token![trait],
-    ///     ident: Ident,
-    ///     generics: Generics,
-    ///     colon_token: Option<Token![:]>,
-    ///     supertraits: Punctuated<TypeParamBound, Token![+]>,
-    ///     brace_token: token::Brace,
-    /// }
-    ///
-    /// impl Parse for MarkerTrait {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let trait_token: Token![trait] = input.parse()?;
-    ///         let ident: Ident = input.parse()?;
-    ///         let mut generics: Generics = input.parse()?;
-    ///         let colon_token: Option<Token![:]> = input.parse()?;
-    ///
-    ///         let mut supertraits = Punctuated::new();
-    ///         if colon_token.is_some() {
-    ///             loop {
-    ///                 supertraits.push_value(input.parse()?);
-    ///                 if input.peek(Token![where]) || input.peek(token::Brace) {
-    ///                     break;
-    ///                 }
-    ///                 supertraits.push_punct(input.parse()?);
-    ///             }
-    ///         }
-    ///
-    ///         generics.where_clause = input.parse()?;
-    ///         let content;
-    ///         let empty_brace_token = braced!(content in input);
-    ///
-    ///         Ok(MarkerTrait {
-    ///             trait_token,
-    ///             ident,
-    ///             generics,
-    ///             colon_token,
-    ///             supertraits,
-    ///             brace_token: empty_brace_token,
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    pub fn peek<T: Peek>(&self, token: T) -> bool {
-        let _ = token;
-        T::Token::peek(self.cursor())
-    }
-
-    /// Looks at the second-next token in the parse stream.
-    ///
-    /// This is commonly useful as a way to implement contextual keywords.
-    ///
-    /// # Example
-    ///
-    /// This example needs to use `peek2` because the symbol `union` is not a
-    /// keyword in Rust. We can't use just `peek` and decide to parse a union if
-    /// the very next token is `union`, because someone is free to write a `mod
-    /// union` and a macro invocation that looks like `union::some_macro! { ...
-    /// }`. In other words `union` is a contextual keyword.
-    ///
-    /// ```
-    /// use syn::{Ident, ItemUnion, Macro, Result, Token};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // Parses either a union or a macro invocation.
-    /// enum UnionOrMacro {
-    ///     // union MaybeUninit<T> { uninit: (), value: T }
-    ///     Union(ItemUnion),
-    ///     // lazy_static! { ... }
-    ///     Macro(Macro),
-    /// }
-    ///
-    /// impl Parse for UnionOrMacro {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         if input.peek(Token![union]) && input.peek2(Ident) {
-    ///             input.parse().map(UnionOrMacro::Union)
-    ///         } else {
-    ///             input.parse().map(UnionOrMacro::Macro)
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    pub fn peek2<T: Peek>(&self, token: T) -> bool {
-        fn peek2(buffer: &ParseBuffer, peek: fn(Cursor) -> bool) -> bool {
-            if let Some(group) = buffer.cursor().group(Delimiter::None) {
-                if group.0.skip().map_or(false, peek) {
-                    return true;
-                }
-            }
-            buffer.cursor().skip().map_or(false, peek)
-        }
-
-        let _ = token;
-        peek2(self, T::Token::peek)
-    }
-
-    /// Looks at the third-next token in the parse stream.
-    pub fn peek3<T: Peek>(&self, token: T) -> bool {
-        fn peek3(buffer: &ParseBuffer, peek: fn(Cursor) -> bool) -> bool {
-            if let Some(group) = buffer.cursor().group(Delimiter::None) {
-                if group.0.skip().and_then(Cursor::skip).map_or(false, peek) {
-                    return true;
-                }
-            }
-            buffer
-                .cursor()
-                .skip()
-                .and_then(Cursor::skip)
-                .map_or(false, peek)
-        }
-
-        let _ = token;
-        peek3(self, T::Token::peek)
-    }
-
-    /// Parses zero or more occurrences of `T` separated by punctuation of type
-    /// `P`, with optional trailing punctuation.
-    ///
-    /// Parsing continues until the end of this parse stream. The entire content
-    /// of this parse stream must consist of `T` and `P`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use quote::quote;
-    /// #
-    /// use syn::{parenthesized, token, Ident, Result, Token, Type};
-    /// use syn::parse::{Parse, ParseStream};
-    /// use syn::punctuated::Punctuated;
-    ///
-    /// // Parse a simplified tuple struct syntax like:
-    /// //
-    /// //     struct S(A, B);
-    /// struct TupleStruct {
-    ///     struct_token: Token![struct],
-    ///     ident: Ident,
-    ///     paren_token: token::Paren,
-    ///     fields: Punctuated<Type, Token![,]>,
-    ///     semi_token: Token![;],
-    /// }
-    ///
-    /// impl Parse for TupleStruct {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let content;
-    ///         Ok(TupleStruct {
-    ///             struct_token: input.parse()?,
-    ///             ident: input.parse()?,
-    ///             paren_token: parenthesized!(content in input),
-    ///             fields: content.parse_terminated(Type::parse)?,
-    ///             semi_token: input.parse()?,
-    ///         })
-    ///     }
-    /// }
-    /// #
-    /// # let input = quote! {
-    /// #     struct S(A, B);
-    /// # };
-    /// # syn::parse2::<TupleStruct>(input).unwrap();
-    /// ```
-    pub fn parse_terminated<T, P: Parse>(
-        &self,
-        parser: fn(ParseStream) -> Result<T>,
-    ) -> Result<Punctuated<T, P>> {
-        Punctuated::parse_terminated_with(self, parser)
-    }
-
-    /// Returns whether there are tokens remaining in this stream.
-    ///
-    /// This method returns true at the end of the content of a set of
-    /// delimiters, as well as at the very end of the complete macro input.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{braced, token, Ident, Item, Result, Token};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // Parses a Rust `mod m { ... }` containing zero or more items.
-    /// struct Mod {
-    ///     mod_token: Token![mod],
-    ///     name: Ident,
-    ///     brace_token: token::Brace,
-    ///     items: Vec<Item>,
-    /// }
-    ///
-    /// impl Parse for Mod {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let content;
-    ///         Ok(Mod {
-    ///             mod_token: input.parse()?,
-    ///             name: input.parse()?,
-    ///             brace_token: braced!(content in input),
-    ///             items: {
-    ///                 let mut items = Vec::new();
-    ///                 while !content.is_empty() {
-    ///                     items.push(content.parse()?);
-    ///                 }
-    ///                 items
-    ///             },
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    pub fn is_empty(&self) -> bool {
-        self.cursor().eof()
-    }
-
-    /// Constructs a helper for peeking at the next token in this stream and
-    /// building an error message if it is not one of a set of expected tokens.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // A generic parameter, a single one of the comma-separated elements inside
-    /// // angle brackets in:
-    /// //
-    /// //     fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... }
-    /// //
-    /// // On invalid input, lookahead gives us a reasonable error message.
-    /// //
-    /// //     error: expected one of: identifier, lifetime, `const`
-    /// //       |
-    /// //     5 |     fn f<!Sized>() {}
-    /// //       |          ^
-    /// enum GenericParam {
-    ///     Type(TypeParam),
-    ///     Lifetime(LifetimeDef),
-    ///     Const(ConstParam),
-    /// }
-    ///
-    /// impl Parse for GenericParam {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let lookahead = input.lookahead1();
-    ///         if lookahead.peek(Ident) {
-    ///             input.parse().map(GenericParam::Type)
-    ///         } else if lookahead.peek(Lifetime) {
-    ///             input.parse().map(GenericParam::Lifetime)
-    ///         } else if lookahead.peek(Token![const]) {
-    ///             input.parse().map(GenericParam::Const)
-    ///         } else {
-    ///             Err(lookahead.error())
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    pub fn lookahead1(&self) -> Lookahead1<'a> {
-        lookahead::new(self.scope, self.cursor())
-    }
-
-    /// Forks a parse stream so that parsing tokens out of either the original
-    /// or the fork does not advance the position of the other.
-    ///
-    /// # Performance
-    ///
-    /// Forking a parse stream is a cheap fixed amount of work and does not
-    /// involve copying token buffers. Where you might hit performance problems
-    /// is if your macro ends up parsing a large amount of content more than
-    /// once.
-    ///
-    /// ```
-    /// # use syn::{Expr, Result};
-    /// # use syn::parse::ParseStream;
-    /// #
-    /// # fn bad(input: ParseStream) -> Result<Expr> {
-    /// // Do not do this.
-    /// if input.fork().parse::<Expr>().is_ok() {
-    ///     return input.parse::<Expr>();
-    /// }
-    /// # unimplemented!()
-    /// # }
-    /// ```
-    ///
-    /// As a rule, avoid parsing an unbounded amount of tokens out of a forked
-    /// parse stream. Only use a fork when the amount of work performed against
-    /// the fork is small and bounded.
-    ///
-    /// When complex speculative parsing against the forked stream is
-    /// unavoidable, use [`parse::discouraged::Speculative`] to advance the
-    /// original stream once the fork's parse is determined to have been
-    /// successful.
-    ///
-    /// For a lower level way to perform speculative parsing at the token level,
-    /// consider using [`ParseStream::step`] instead.
-    ///
-    /// [`parse::discouraged::Speculative`]: discouraged::Speculative
-    /// [`ParseStream::step`]: ParseBuffer::step
-    ///
-    /// # Example
-    ///
-    /// The parse implementation shown here parses possibly restricted `pub`
-    /// visibilities.
-    ///
-    /// - `pub`
-    /// - `pub(crate)`
-    /// - `pub(self)`
-    /// - `pub(super)`
-    /// - `pub(in some::path)`
-    ///
-    /// To handle the case of visibilities inside of tuple structs, the parser
-    /// needs to distinguish parentheses that specify visibility restrictions
-    /// from parentheses that form part of a tuple type.
-    ///
-    /// ```
-    /// # struct A;
-    /// # struct B;
-    /// # struct C;
-    /// #
-    /// struct S(pub(crate) A, pub (B, C));
-    /// ```
-    ///
-    /// In this example input the first tuple struct element of `S` has
-    /// `pub(crate)` visibility while the second tuple struct element has `pub`
-    /// visibility; the parentheses around `(B, C)` are part of the type rather
-    /// than part of a visibility restriction.
-    ///
-    /// The parser uses a forked parse stream to check the first token inside of
-    /// parentheses after the `pub` keyword. This is a small bounded amount of
-    /// work performed against the forked parse stream.
-    ///
-    /// ```
-    /// use syn::{parenthesized, token, Ident, Path, Result, Token};
-    /// use syn::ext::IdentExt;
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// struct PubVisibility {
-    ///     pub_token: Token![pub],
-    ///     restricted: Option<Restricted>,
-    /// }
-    ///
-    /// struct Restricted {
-    ///     paren_token: token::Paren,
-    ///     in_token: Option<Token![in]>,
-    ///     path: Path,
-    /// }
-    ///
-    /// impl Parse for PubVisibility {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         let pub_token: Token![pub] = input.parse()?;
-    ///
-    ///         if input.peek(token::Paren) {
-    ///             let ahead = input.fork();
-    ///             let mut content;
-    ///             parenthesized!(content in ahead);
-    ///
-    ///             if content.peek(Token![crate])
-    ///                 || content.peek(Token![self])
-    ///                 || content.peek(Token![super])
-    ///             {
-    ///                 return Ok(PubVisibility {
-    ///                     pub_token,
-    ///                     restricted: Some(Restricted {
-    ///                         paren_token: parenthesized!(content in input),
-    ///                         in_token: None,
-    ///                         path: Path::from(content.call(Ident::parse_any)?),
-    ///                     }),
-    ///                 });
-    ///             } else if content.peek(Token![in]) {
-    ///                 return Ok(PubVisibility {
-    ///                     pub_token,
-    ///                     restricted: Some(Restricted {
-    ///                         paren_token: parenthesized!(content in input),
-    ///                         in_token: Some(content.parse()?),
-    ///                         path: content.call(Path::parse_mod_style)?,
-    ///                     }),
-    ///                 });
-    ///             }
-    ///         }
-    ///
-    ///         Ok(PubVisibility {
-    ///             pub_token,
-    ///             restricted: None,
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    pub fn fork(&self) -> Self {
-        ParseBuffer {
-            scope: self.scope,
-            cell: self.cell.clone(),
-            marker: PhantomData,
-            // Not the parent's unexpected. Nothing cares whether the clone
-            // parses all the way unless we `advance_to`.
-            unexpected: Cell::new(Some(Rc::new(Cell::new(Unexpected::None)))),
-        }
-    }
-
-    /// Triggers an error at the current position of the parse stream.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use syn::{Expr, Result, Token};
-    /// use syn::parse::{Parse, ParseStream};
-    ///
-    /// // Some kind of loop: `while` or `for` or `loop`.
-    /// struct Loop {
-    ///     expr: Expr,
-    /// }
-    ///
-    /// impl Parse for Loop {
-    ///     fn parse(input: ParseStream) -> Result<Self> {
-    ///         if input.peek(Token![while])
-    ///             || input.peek(Token![for])
-    ///             || input.peek(Token![loop])
-    ///         {
-    ///             Ok(Loop {
-    ///                 expr: input.parse()?,
-    ///             })
-    ///         } else {
-    ///             Err(input.error("expected some kind of loop"))
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    pub fn error<T: Display>(&self, message: T) -> Error {
-        error::new_at(self.scope, self.cursor(), message)
-    }
-
-    /// Speculatively parses tokens from this parse stream, advancing the
-    /// position of this stream only if parsing succeeds.
-    ///
-    /// This is a powerful low-level API used for defining the `Parse` impls of
-    /// the basic built-in token types. It is not something that will be used
-    /// widely outside of the Syn codebase.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use proc_macro2::TokenTree;
-    /// use syn::Result;
-    /// use syn::parse::ParseStream;
-    ///
-    /// // This function advances the stream past the next occurrence of `@`. If
-    /// // no `@` is present in the stream, the stream position is unchanged and
-    /// // an error is returned.
-    /// fn skip_past_next_at(input: ParseStream) -> Result<()> {
-    ///     input.step(|cursor| {
-    ///         let mut rest = *cursor;
-    ///         while let Some((tt, next)) = rest.token_tree() {
-    ///             match &tt {
-    ///                 TokenTree::Punct(punct) if punct.as_char() == '@' => {
-    ///                     return Ok(((), next));
-    ///                 }
-    ///                 _ => rest = next,
-    ///             }
-    ///         }
-    ///         Err(cursor.error("no `@` was found after this point"))
-    ///     })
-    /// }
-    /// #
-    /// # fn remainder_after_skipping_past_next_at(
-    /// #     input: ParseStream,
-    /// # ) -> Result<proc_macro2::TokenStream> {
-    /// #     skip_past_next_at(input)?;
-    /// #     input.parse()
-    /// # }
-    /// #
-    /// # use syn::parse::Parser;
-    /// # let remainder = remainder_after_skipping_past_next_at
-    /// #     .parse_str("a @ b c")
-    /// #     .unwrap();
-    /// # assert_eq!(remainder.to_string(), "b c");
-    /// ```
-    pub fn step<F, R>(&self, function: F) -> Result<R>
-    where
-        F: for<'c> FnOnce(StepCursor<'c, 'a>) -> Result<(R, Cursor<'c>)>,
-    {
-        // Since the user's function is required to work for any 'c, we know
-        // that the Cursor<'c> they return is either derived from the input
-        // StepCursor<'c, 'a> or from a Cursor<'static>.
-        //
-        // It would not be legal to write this function without the invariant
-        // lifetime 'c in StepCursor<'c, 'a>. If this function were written only
-        // in terms of 'a, the user could take our ParseBuffer<'a>, upcast it to
-        // a ParseBuffer<'short> which some shorter lifetime than 'a, invoke
-        // `step` on their ParseBuffer<'short> with a closure that returns
-        // Cursor<'short>, and we would wrongly write that Cursor<'short> into
-        // the Cell intended to hold Cursor<'a>.
-        //
-        // In some cases it may be necessary for R to contain a Cursor<'a>.
-        // Within Syn we solve this using `advance_step_cursor` which uses the
-        // existence of a StepCursor<'c, 'a> as proof that it is safe to cast
-        // from Cursor<'c> to Cursor<'a>. If needed outside of Syn, it would be
-        // safe to expose that API as a method on StepCursor.
-        let (node, rest) = function(StepCursor {
-            scope: self.scope,
-            cursor: self.cell.get(),
-            marker: PhantomData,
-        })?;
-        self.cell.set(rest);
-        Ok(node)
-    }
-
-    /// Returns the `Span` of the next token in the parse stream, or
-    /// `Span::call_site()` if this parse stream has completely exhausted its
-    /// input `TokenStream`.
-    pub fn span(&self) -> Span {
-        let cursor = self.cursor();
-        if cursor.eof() {
-            self.scope
-        } else {
-            crate::buffer::open_span_of_group(cursor)
-        }
-    }
-
-    /// Provides low-level access to the token representation underlying this
-    /// parse stream.
-    ///
-    /// Cursors are immutable so no operations you perform against the cursor
-    /// will affect the state of this parse stream.
-    pub fn cursor(&self) -> Cursor<'a> {
-        self.cell.get()
-    }
-
-    fn check_unexpected(&self) -> Result<()> {
-        match inner_unexpected(self).1 {
-            Some(span) => Err(Error::new(span, "unexpected token")),
-            None => Ok(()),
-        }
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl<T: Parse> Parse for Box<T> {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.parse().map(Box::new)
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl<T: Parse + Token> Parse for Option<T> {
-    fn parse(input: ParseStream) -> Result<Self> {
-        if T::peek(input.cursor()) {
-            Ok(Some(input.parse()?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for TokenStream {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| Ok((cursor.token_stream(), Cursor::empty())))
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for TokenTree {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| match cursor.token_tree() {
-            Some((tt, rest)) => Ok((tt, rest)),
-            None => Err(cursor.error("expected token tree")),
-        })
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for Group {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| {
-            for delim in &[Delimiter::Parenthesis, Delimiter::Brace, Delimiter::Bracket] {
-                if let Some((inside, span, rest)) = cursor.group(*delim) {
-                    let mut group = Group::new(*delim, inside.token_stream());
-                    group.set_span(span);
-                    return Ok((group, rest));
-                }
-            }
-            Err(cursor.error("expected group token"))
-        })
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for Punct {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| match cursor.punct() {
-            Some((punct, rest)) => Ok((punct, rest)),
-            None => Err(cursor.error("expected punctuation token")),
-        })
-    }
-}
-
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for Literal {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| match cursor.literal() {
-            Some((literal, rest)) => Ok((literal, rest)),
-            None => Err(cursor.error("expected literal token")),
-        })
-    }
-}
-
-/// Parser that can parse Rust tokens into a particular syntax tree node.
-///
-/// Refer to the [module documentation] for details about parsing in Syn.
-///
-/// [module documentation]: self
-///
-/// *This trait is available only if Syn is built with the `"parsing"` feature.*
-pub trait Parser: Sized {
-    type Output;
-
-    /// Parse a proc-macro2 token stream into the chosen syntax tree node.
-    ///
-    /// This function will check that the input is fully parsed. If there are
-    /// any unparsed tokens at the end of the stream, an error is returned.
-    fn parse2(self, tokens: TokenStream) -> Result<Self::Output>;
-
-    /// Parse tokens of source code into the chosen syntax tree node.
-    ///
-    /// This function will check that the input is fully parsed. If there are
-    /// any unparsed tokens at the end of the stream, an error is returned.
-    ///
-    /// *This method is available only if Syn is built with both the `"parsing"` and
-    /// `"proc-macro"` features.*
-    #[cfg(all(
-        not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))),
-        feature = "proc-macro"
-    ))]
-    fn parse(self, tokens: proc_macro::TokenStream) -> Result<Self::Output> {
-        self.parse2(proc_macro2::TokenStream::from(tokens))
-    }
-
-    /// Parse a string of Rust code into the chosen syntax tree node.
-    ///
-    /// This function will check that the input is fully parsed. If there are
-    /// any unparsed tokens at the end of the string, an error is returned.
-    ///
-    /// # Hygiene
-    ///
-    /// Every span in the resulting syntax tree will be set to resolve at the
-    /// macro call site.
-    fn parse_str(self, s: &str) -> Result<Self::Output> {
-        self.parse2(proc_macro2::TokenStream::from_str(s)?)
-    }
-
-    // Not public API.
-    #[doc(hidden)]
-    #[cfg(any(feature = "full", feature = "derive"))]
-    fn __parse_scoped(self, scope: Span, tokens: TokenStream) -> Result<Self::Output> {
-        let _ = scope;
-        self.parse2(tokens)
-    }
-
-    // Not public API.
-    #[doc(hidden)]
-    #[cfg(any(feature = "full", feature = "derive"))]
-    fn __parse_stream(self, input: ParseStream) -> Result<Self::Output> {
-        input.parse().and_then(|tokens| self.parse2(tokens))
-    }
-}
-
-fn tokens_to_parse_buffer(tokens: &TokenBuffer) -> ParseBuffer {
-    let scope = Span::call_site();
-    let cursor = tokens.begin();
-    let unexpected = Rc::new(Cell::new(Unexpected::None));
-    new_parse_buffer(scope, cursor, unexpected)
-}
-
-impl<F, T> Parser for F
-where
-    F: FnOnce(ParseStream) -> Result<T>,
-{
-    type Output = T;
-
-    fn parse2(self, tokens: TokenStream) -> Result<T> {
-        let buf = TokenBuffer::new2(tokens);
-        let state = tokens_to_parse_buffer(&buf);
-        let node = self(&state)?;
-        state.check_unexpected()?;
-        if let Some(unexpected_span) = span_of_unexpected_ignoring_nones(state.cursor()) {
-            Err(Error::new(unexpected_span, "unexpected token"))
-        } else {
-            Ok(node)
-        }
-    }
-
-    #[doc(hidden)]
-    #[cfg(any(feature = "full", feature = "derive"))]
-    fn __parse_scoped(self, scope: Span, tokens: TokenStream) -> Result<Self::Output> {
-        let buf = TokenBuffer::new2(tokens);
-        let cursor = buf.begin();
-        let unexpected = Rc::new(Cell::new(Unexpected::None));
-        let state = new_parse_buffer(scope, cursor, unexpected);
-        let node = self(&state)?;
-        state.check_unexpected()?;
-        if let Some(unexpected_span) = span_of_unexpected_ignoring_nones(state.cursor()) {
-            Err(Error::new(unexpected_span, "unexpected token"))
-        } else {
-            Ok(node)
-        }
-    }
-
-    #[doc(hidden)]
-    #[cfg(any(feature = "full", feature = "derive"))]
-    fn __parse_stream(self, input: ParseStream) -> Result<Self::Output> {
-        self(input)
-    }
-}
-
-#[cfg(any(feature = "full", feature = "derive"))]
-pub(crate) fn parse_scoped<F: Parser>(f: F, scope: Span, tokens: TokenStream) -> Result<F::Output> {
-    f.__parse_scoped(scope, tokens)
-}
-
-#[cfg(any(feature = "full", feature = "derive"))]
-pub(crate) fn parse_stream<F: Parser>(f: F, input: ParseStream) -> Result<F::Output> {
-    f.__parse_stream(input)
-}
-
-/// An empty syntax tree node that consumes no tokens when parsed.
-///
-/// This is useful for attribute macros that want to ensure they are not
-/// provided any attribute args.
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// use proc_macro::TokenStream;
-/// use syn::parse_macro_input;
-/// use syn::parse::Nothing;
-///
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro_attribute]
-/// # };
-/// pub fn my_attr(args: TokenStream, input: TokenStream) -> TokenStream {
-///     parse_macro_input!(args as Nothing);
-///
-///     /* ... */
-/// #   "".parse().unwrap()
-/// }
-/// ```
-///
-/// ```text
-/// error: unexpected token
-///  --> src/main.rs:3:19
-///   |
-/// 3 | #[my_attr(asdf)]
-///   |           ^^^^
-/// ```
-pub struct Nothing;
-
-impl Parse for Nothing {
-    fn parse(_input: ParseStream) -> Result<Self> {
-        Ok(Nothing)
-    }
-}
diff --git a/vendor/syn/src/parse_macro_input.rs b/vendor/syn/src/parse_macro_input.rs
deleted file mode 100644
index 8e1a5ec6..00000000
--- a/vendor/syn/src/parse_macro_input.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-/// Parse the input TokenStream of a macro, triggering a compile error if the
-/// tokens fail to parse.
-///
-/// Refer to the [`parse` module] documentation for more details about parsing
-/// in Syn.
-///
-/// [`parse` module]: crate::rustdoc_workaround::parse_module
-///
-/// <br>
-///
-/// # Intended usage
-///
-/// This macro must be called from a function that returns
-/// `proc_macro::TokenStream`. Usually this will be your proc macro entry point,
-/// the function that has the #\[proc_macro\] / #\[proc_macro_derive\] /
-/// #\[proc_macro_attribute\] attribute.
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// use proc_macro::TokenStream;
-/// use syn::{parse_macro_input, Result};
-/// use syn::parse::{Parse, ParseStream};
-///
-/// struct MyMacroInput {
-///     /* ... */
-/// }
-///
-/// impl Parse for MyMacroInput {
-///     fn parse(input: ParseStream) -> Result<Self> {
-///         /* ... */
-/// #       Ok(MyMacroInput {})
-///     }
-/// }
-///
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro]
-/// # };
-/// pub fn my_macro(tokens: TokenStream) -> TokenStream {
-///     let input = parse_macro_input!(tokens as MyMacroInput);
-///
-///     /* ... */
-/// #   "".parse().unwrap()
-/// }
-/// ```
-///
-/// <br>
-///
-/// # Usage with Parser
-///
-/// This macro can also be used with the [`Parser` trait] for types that have
-/// multiple ways that they can be parsed.
-///
-/// [`Parser` trait]: crate::rustdoc_workaround::parse_module::Parser
-///
-/// ```
-/// # extern crate proc_macro;
-/// #
-/// # use proc_macro::TokenStream;
-/// # use syn::{parse_macro_input, Result};
-/// # use syn::parse::ParseStream;
-/// #
-/// # struct MyMacroInput {}
-/// #
-/// impl MyMacroInput {
-///     fn parse_alternate(input: ParseStream) -> Result<Self> {
-///         /* ... */
-/// #       Ok(MyMacroInput {})
-///     }
-/// }
-///
-/// # const IGNORE: &str = stringify! {
-/// #[proc_macro]
-/// # };
-/// pub fn my_macro(tokens: TokenStream) -> TokenStream {
-///     let input = parse_macro_input!(tokens with MyMacroInput::parse_alternate);
-///
-///     /* ... */
-/// #   "".parse().unwrap()
-/// }
-/// ```
-///
-/// <br>
-///
-/// # Expansion
-///
-/// `parse_macro_input!($variable as $Type)` expands to something like:
-///
-/// ```no_run
-/// # extern crate proc_macro;
-/// #
-/// # macro_rules! doc_test {
-/// #     ($variable:ident as $Type:ty) => {
-/// match syn::parse::<$Type>($variable) {
-///     Ok(syntax_tree) => syntax_tree,
-///     Err(err) => return proc_macro::TokenStream::from(err.to_compile_error()),
-/// }
-/// #     };
-/// # }
-/// #
-/// # fn test(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-/// #     let _ = doc_test!(input as syn::Ident);
-/// #     proc_macro::TokenStream::new()
-/// # }
-/// ```
-#[macro_export]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "proc-macro"))))]
-macro_rules! parse_macro_input {
-    ($tokenstream:ident as $ty:ty) => {
-        match $crate::parse_macro_input::parse::<$ty>($tokenstream) {
-            $crate::__private::Ok(data) => data,
-            $crate::__private::Err(err) => {
-                return $crate::__private::TokenStream::from(err.to_compile_error());
-            }
-        }
-    };
-    ($tokenstream:ident with $parser:path) => {
-        match $crate::parse::Parser::parse($parser, $tokenstream) {
-            $crate::__private::Ok(data) => data,
-            $crate::__private::Err(err) => {
-                return $crate::__private::TokenStream::from(err.to_compile_error());
-            }
-        }
-    };
-    ($tokenstream:ident) => {
-        $crate::parse_macro_input!($tokenstream as _)
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Can parse any type that implements Parse.
-
-use crate::parse::{Parse, ParseStream, Parser, Result};
-use proc_macro::TokenStream;
-
-// Not public API.
-#[doc(hidden)]
-pub fn parse<T: ParseMacroInput>(token_stream: TokenStream) -> Result<T> {
-    T::parse.parse(token_stream)
-}
-
-// Not public API.
-#[doc(hidden)]
-pub trait ParseMacroInput: Sized {
-    fn parse(input: ParseStream) -> Result<Self>;
-}
-
-impl<T: Parse> ParseMacroInput for T {
-    fn parse(input: ParseStream) -> Result<Self> {
-        <T as Parse>::parse(input)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Any other types that we want `parse_macro_input!` to be able to parse.
-
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::AttributeArgs;
-
-#[cfg(any(feature = "full", feature = "derive"))]
-impl ParseMacroInput for AttributeArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let mut metas = Vec::new();
-
-        loop {
-            if input.is_empty() {
-                break;
-            }
-            let value = input.parse()?;
-            metas.push(value);
-            if input.is_empty() {
-                break;
-            }
-            input.parse::<Token![,]>()?;
-        }
-
-        Ok(metas)
-    }
-}
diff --git a/vendor/syn/src/parse_quote.rs b/vendor/syn/src/parse_quote.rs
deleted file mode 100644
index ec551ef9..00000000
--- a/vendor/syn/src/parse_quote.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-/// Quasi-quotation macro that accepts input like the [`quote!`] macro but uses
-/// type inference to figure out a return type for those tokens.
-///
-/// [`quote!`]: https://docs.rs/quote/1.0/quote/index.html
-///
-/// The return type can be any syntax tree node that implements the [`Parse`]
-/// trait.
-///
-/// [`Parse`]: crate::parse::Parse
-///
-/// ```
-/// use quote::quote;
-/// use syn::{parse_quote, Stmt};
-///
-/// fn main() {
-///     let name = quote!(v);
-///     let ty = quote!(u8);
-///
-///     let stmt: Stmt = parse_quote! {
-///         let #name: #ty = Default::default();
-///     };
-///
-///     println!("{:#?}", stmt);
-/// }
-/// ```
-///
-/// *This macro is available only if Syn is built with the `"parsing"` feature,
-/// although interpolation of syntax tree nodes into the quoted tokens is only
-/// supported if Syn is built with the `"printing"` feature as well.*
-///
-/// # Example
-///
-/// The following helper function adds a bound `T: HeapSize` to every type
-/// parameter `T` in the input generics.
-///
-/// ```
-/// use syn::{parse_quote, Generics, GenericParam};
-///
-/// // Add a bound `T: HeapSize` to every type parameter T.
-/// fn add_trait_bounds(mut generics: Generics) -> Generics {
-///     for param in &mut generics.params {
-///         if let GenericParam::Type(type_param) = param {
-///             type_param.bounds.push(parse_quote!(HeapSize));
-///         }
-///     }
-///     generics
-/// }
-/// ```
-///
-/// # Special cases
-///
-/// This macro can parse the following additional types as a special case even
-/// though they do not implement the `Parse` trait.
-///
-/// - [`Attribute`] — parses one attribute, allowing either outer like `#[...]`
-///   or inner like `#![...]`
-/// - [`Punctuated<T, P>`] — parses zero or more `T` separated by punctuation
-///   `P` with optional trailing punctuation
-/// - [`Vec<Stmt>`] — parses the same as `Block::parse_within`
-///
-/// [`Punctuated<T, P>`]: crate::punctuated::Punctuated
-/// [`Vec<Stmt>`]: Block::parse_within
-///
-/// # Panics
-///
-/// Panics if the tokens fail to parse as the expected syntax tree type. The
-/// caller is responsible for ensuring that the input tokens are syntactically
-/// valid.
-//
-// TODO: allow Punctuated to be inferred as intra doc link, currently blocked on
-// https://github.com/rust-lang/rust/issues/62834
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "printing"))))]
-#[macro_export]
-macro_rules! parse_quote {
-    ($($tt:tt)*) => {
-        $crate::parse_quote::parse(
-            $crate::__private::From::from(
-                $crate::__private::quote::quote!($($tt)*)
-            )
-        )
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Can parse any type that implements Parse.
-
-use crate::parse::{Parse, ParseStream, Parser, Result};
-use proc_macro2::TokenStream;
-
-// Not public API.
-#[doc(hidden)]
-pub fn parse<T: ParseQuote>(token_stream: TokenStream) -> T {
-    let parser = T::parse;
-    match parser.parse2(token_stream) {
-        Ok(t) => t,
-        Err(err) => panic!("{}", err),
-    }
-}
-
-// Not public API.
-#[doc(hidden)]
-pub trait ParseQuote: Sized {
-    fn parse(input: ParseStream) -> Result<Self>;
-}
-
-impl<T: Parse> ParseQuote for T {
-    fn parse(input: ParseStream) -> Result<Self> {
-        <T as Parse>::parse(input)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Any other types that we want `parse_quote!` to be able to parse.
-
-use crate::punctuated::Punctuated;
-#[cfg(any(feature = "full", feature = "derive"))]
-use crate::{attr, Attribute};
-#[cfg(feature = "full")]
-use crate::{Block, Stmt};
-
-#[cfg(any(feature = "full", feature = "derive"))]
-impl ParseQuote for Attribute {
-    fn parse(input: ParseStream) -> Result<Self> {
-        if input.peek(Token![#]) && input.peek2(Token![!]) {
-            attr::parsing::single_parse_inner(input)
-        } else {
-            attr::parsing::single_parse_outer(input)
-        }
-    }
-}
-
-impl<T: Parse, P: Parse> ParseQuote for Punctuated<T, P> {
-    fn parse(input: ParseStream) -> Result<Self> {
-        Self::parse_terminated(input)
-    }
-}
-
-#[cfg(feature = "full")]
-impl ParseQuote for Vec<Stmt> {
-    fn parse(input: ParseStream) -> Result<Self> {
-        Block::parse_within(input)
-    }
-}
diff --git a/vendor/syn/src/pat.rs b/vendor/syn/src/pat.rs
deleted file mode 100644
index d25843fc..00000000
--- a/vendor/syn/src/pat.rs
+++ /dev/null
@@ -1,932 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-use proc_macro2::TokenStream;
-
-ast_enum_of_structs! {
-    /// A pattern in a local binding, function signature, match expression, or
-    /// various other places.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum Pat {
-        /// A box pattern: `box v`.
-        Box(PatBox),
-
-        /// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
-        Ident(PatIdent),
-
-        /// A literal pattern: `0`.
-        ///
-        /// This holds an `Expr` rather than a `Lit` because negative numbers
-        /// are represented as an `Expr::Unary`.
-        Lit(PatLit),
-
-        /// A macro in pattern position.
-        Macro(PatMacro),
-
-        /// A pattern that matches any one of a set of cases.
-        Or(PatOr),
-
-        /// A path pattern like `Color::Red`, optionally qualified with a
-        /// self-type.
-        ///
-        /// Unqualified path patterns can legally refer to variants, structs,
-        /// constants or associated constants. Qualified path patterns like
-        /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
-        /// associated constants.
-        Path(PatPath),
-
-        /// A range pattern: `1..=2`.
-        Range(PatRange),
-
-        /// A reference pattern: `&mut var`.
-        Reference(PatReference),
-
-        /// The dots in a tuple or slice pattern: `[0, 1, ..]`
-        Rest(PatRest),
-
-        /// A dynamically sized slice pattern: `[a, b, ref i @ .., y, z]`.
-        Slice(PatSlice),
-
-        /// A struct or struct variant pattern: `Variant { x, y, .. }`.
-        Struct(PatStruct),
-
-        /// A tuple pattern: `(a, b)`.
-        Tuple(PatTuple),
-
-        /// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
-        TupleStruct(PatTupleStruct),
-
-        /// A type ascription pattern: `foo: f64`.
-        Type(PatType),
-
-        /// Tokens in pattern position not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        /// A pattern that matches any value: `_`.
-        Wild(PatWild),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         Pat::Box(e) => {...}
-        //         Pat::Ident(e) => {...}
-        //         ...
-        //         Pat::Wild(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         Pat::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, Pat will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// A box pattern: `box v`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatBox {
-        pub attrs: Vec<Attribute>,
-        pub box_token: Token![box],
-        pub pat: Box<Pat>,
-    }
-}
-
-ast_struct! {
-    /// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
-    ///
-    /// It may also be a unit struct or struct variant (e.g. `None`), or a
-    /// constant; these cannot be distinguished syntactically.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatIdent {
-        pub attrs: Vec<Attribute>,
-        pub by_ref: Option<Token![ref]>,
-        pub mutability: Option<Token![mut]>,
-        pub ident: Ident,
-        pub subpat: Option<(Token![@], Box<Pat>)>,
-    }
-}
-
-ast_struct! {
-    /// A literal pattern: `0`.
-    ///
-    /// This holds an `Expr` rather than a `Lit` because negative numbers
-    /// are represented as an `Expr::Unary`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatLit {
-        pub attrs: Vec<Attribute>,
-        pub expr: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A macro in pattern position.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatMacro {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-    }
-}
-
-ast_struct! {
-    /// A pattern that matches any one of a set of cases.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatOr {
-        pub attrs: Vec<Attribute>,
-        pub leading_vert: Option<Token![|]>,
-        pub cases: Punctuated<Pat, Token![|]>,
-    }
-}
-
-ast_struct! {
-    /// A path pattern like `Color::Red`, optionally qualified with a
-    /// self-type.
-    ///
-    /// Unqualified path patterns can legally refer to variants, structs,
-    /// constants or associated constants. Qualified path patterns like
-    /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
-    /// associated constants.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatPath {
-        pub attrs: Vec<Attribute>,
-        pub qself: Option<QSelf>,
-        pub path: Path,
-    }
-}
-
-ast_struct! {
-    /// A range pattern: `1..=2`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatRange {
-        pub attrs: Vec<Attribute>,
-        pub lo: Box<Expr>,
-        pub limits: RangeLimits,
-        pub hi: Box<Expr>,
-    }
-}
-
-ast_struct! {
-    /// A reference pattern: `&mut var`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatReference {
-        pub attrs: Vec<Attribute>,
-        pub and_token: Token![&],
-        pub mutability: Option<Token![mut]>,
-        pub pat: Box<Pat>,
-    }
-}
-
-ast_struct! {
-    /// The dots in a tuple or slice pattern: `[0, 1, ..]`
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatRest {
-        pub attrs: Vec<Attribute>,
-        pub dot2_token: Token![..],
-    }
-}
-
-ast_struct! {
-    /// A dynamically sized slice pattern: `[a, b, ref i @ .., y, z]`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatSlice {
-        pub attrs: Vec<Attribute>,
-        pub bracket_token: token::Bracket,
-        pub elems: Punctuated<Pat, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A struct or struct variant pattern: `Variant { x, y, .. }`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatStruct {
-        pub attrs: Vec<Attribute>,
-        pub path: Path,
-        pub brace_token: token::Brace,
-        pub fields: Punctuated<FieldPat, Token![,]>,
-        pub dot2_token: Option<Token![..]>,
-    }
-}
-
-ast_struct! {
-    /// A tuple pattern: `(a, b)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatTuple {
-        pub attrs: Vec<Attribute>,
-        pub paren_token: token::Paren,
-        pub elems: Punctuated<Pat, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatTupleStruct {
-        pub attrs: Vec<Attribute>,
-        pub path: Path,
-        pub pat: PatTuple,
-    }
-}
-
-ast_struct! {
-    /// A type ascription pattern: `foo: f64`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatType {
-        pub attrs: Vec<Attribute>,
-        pub pat: Box<Pat>,
-        pub colon_token: Token![:],
-        pub ty: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A pattern that matches any value: `_`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct PatWild {
-        pub attrs: Vec<Attribute>,
-        pub underscore_token: Token![_],
-    }
-}
-
-ast_struct! {
-    /// A single field in a struct pattern.
-    ///
-    /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` are treated
-    /// the same as `x: x, y: ref y, z: ref mut z` but there is no colon token.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct FieldPat {
-        pub attrs: Vec<Attribute>,
-        pub member: Member,
-        pub colon_token: Option<Token![:]>,
-        pub pat: Box<Pat>,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::{Parse, ParseBuffer, ParseStream, Result};
-    use crate::path;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Pat {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let begin = input.fork();
-            let lookahead = input.lookahead1();
-            if {
-                let ahead = input.fork();
-                ahead.parse::<Option<Ident>>()?.is_some()
-                    && (ahead.peek(Token![::])
-                        || ahead.peek(Token![!])
-                        || ahead.peek(token::Brace)
-                        || ahead.peek(token::Paren)
-                        || ahead.peek(Token![..])
-                            && ahead.parse::<RangeLimits>().is_ok()
-                            && !(ahead.is_empty() || ahead.peek(Token![,])))
-            } || {
-                let ahead = input.fork();
-                ahead.parse::<Option<Token![self]>>()?.is_some() && ahead.peek(Token![::])
-            } || lookahead.peek(Token![::])
-                || lookahead.peek(Token![<])
-                || input.peek(Token![Self])
-                || input.peek(Token![super])
-                || input.peek(Token![crate])
-            {
-                pat_path_or_macro_or_struct_or_range(input)
-            } else if lookahead.peek(Token![_]) {
-                input.call(pat_wild).map(Pat::Wild)
-            } else if input.peek(Token![box]) {
-                input.call(pat_box).map(Pat::Box)
-            } else if input.peek(Token![-]) || lookahead.peek(Lit) || lookahead.peek(Token![const])
-            {
-                pat_lit_or_range(input)
-            } else if lookahead.peek(Token![ref])
-                || lookahead.peek(Token![mut])
-                || input.peek(Token![self])
-                || input.peek(Ident)
-            {
-                input.call(pat_ident).map(Pat::Ident)
-            } else if lookahead.peek(Token![&]) {
-                input.call(pat_reference).map(Pat::Reference)
-            } else if lookahead.peek(token::Paren) {
-                input.call(pat_tuple).map(Pat::Tuple)
-            } else if lookahead.peek(token::Bracket) {
-                input.call(pat_slice).map(Pat::Slice)
-            } else if lookahead.peek(Token![..]) && !input.peek(Token![...]) {
-                pat_range_half_open(input, begin)
-            } else if lookahead.peek(Token![const]) {
-                input.call(pat_const).map(Pat::Verbatim)
-            } else {
-                Err(lookahead.error())
-            }
-        }
-    }
-
-    fn pat_path_or_macro_or_struct_or_range(input: ParseStream) -> Result<Pat> {
-        let begin = input.fork();
-        let (qself, path) = path::parsing::qpath(input, true)?;
-
-        if input.peek(Token![..]) {
-            return pat_range(input, begin, qself, path);
-        }
-
-        if qself.is_some() {
-            return Ok(Pat::Path(PatPath {
-                attrs: Vec::new(),
-                qself,
-                path,
-            }));
-        }
-
-        if input.peek(Token![!]) && !input.peek(Token![!=]) {
-            let mut contains_arguments = false;
-            for segment in &path.segments {
-                match segment.arguments {
-                    PathArguments::None => {}
-                    PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => {
-                        contains_arguments = true;
-                    }
-                }
-            }
-
-            if !contains_arguments {
-                let bang_token: Token![!] = input.parse()?;
-                let (delimiter, tokens) = mac::parse_delimiter(input)?;
-                return Ok(Pat::Macro(PatMacro {
-                    attrs: Vec::new(),
-                    mac: Macro {
-                        path,
-                        bang_token,
-                        delimiter,
-                        tokens,
-                    },
-                }));
-            }
-        }
-
-        if input.peek(token::Brace) {
-            pat_struct(input, path).map(Pat::Struct)
-        } else if input.peek(token::Paren) {
-            pat_tuple_struct(input, path).map(Pat::TupleStruct)
-        } else if input.peek(Token![..]) {
-            pat_range(input, begin, qself, path)
-        } else {
-            Ok(Pat::Path(PatPath {
-                attrs: Vec::new(),
-                qself,
-                path,
-            }))
-        }
-    }
-
-    fn pat_wild(input: ParseStream) -> Result<PatWild> {
-        Ok(PatWild {
-            attrs: Vec::new(),
-            underscore_token: input.parse()?,
-        })
-    }
-
-    fn pat_box(input: ParseStream) -> Result<PatBox> {
-        Ok(PatBox {
-            attrs: Vec::new(),
-            box_token: input.parse()?,
-            pat: input.parse()?,
-        })
-    }
-
-    fn pat_ident(input: ParseStream) -> Result<PatIdent> {
-        Ok(PatIdent {
-            attrs: Vec::new(),
-            by_ref: input.parse()?,
-            mutability: input.parse()?,
-            ident: input.call(Ident::parse_any)?,
-            subpat: {
-                if input.peek(Token![@]) {
-                    let at_token: Token![@] = input.parse()?;
-                    let subpat: Pat = input.parse()?;
-                    Some((at_token, Box::new(subpat)))
-                } else {
-                    None
-                }
-            },
-        })
-    }
-
-    fn pat_tuple_struct(input: ParseStream, path: Path) -> Result<PatTupleStruct> {
-        Ok(PatTupleStruct {
-            attrs: Vec::new(),
-            path,
-            pat: input.call(pat_tuple)?,
-        })
-    }
-
-    fn pat_struct(input: ParseStream, path: Path) -> Result<PatStruct> {
-        let content;
-        let brace_token = braced!(content in input);
-
-        let mut fields = Punctuated::new();
-        while !content.is_empty() && !content.peek(Token![..]) {
-            let value = content.call(field_pat)?;
-            fields.push_value(value);
-            if content.is_empty() {
-                break;
-            }
-            let punct: Token![,] = content.parse()?;
-            fields.push_punct(punct);
-        }
-
-        let dot2_token = if fields.empty_or_trailing() && content.peek(Token![..]) {
-            Some(content.parse()?)
-        } else {
-            None
-        };
-
-        Ok(PatStruct {
-            attrs: Vec::new(),
-            path,
-            brace_token,
-            fields,
-            dot2_token,
-        })
-    }
-
-    impl Member {
-        fn is_unnamed(&self) -> bool {
-            match *self {
-                Member::Named(_) => false,
-                Member::Unnamed(_) => true,
-            }
-        }
-    }
-
-    fn field_pat(input: ParseStream) -> Result<FieldPat> {
-        let attrs = input.call(Attribute::parse_outer)?;
-        let boxed: Option<Token![box]> = input.parse()?;
-        let by_ref: Option<Token![ref]> = input.parse()?;
-        let mutability: Option<Token![mut]> = input.parse()?;
-        let member: Member = input.parse()?;
-
-        if boxed.is_none() && by_ref.is_none() && mutability.is_none() && input.peek(Token![:])
-            || member.is_unnamed()
-        {
-            return Ok(FieldPat {
-                attrs,
-                member,
-                colon_token: input.parse()?,
-                pat: Box::new(multi_pat_with_leading_vert(input)?),
-            });
-        }
-
-        let ident = match member {
-            Member::Named(ident) => ident,
-            Member::Unnamed(_) => unreachable!(),
-        };
-
-        let mut pat = Pat::Ident(PatIdent {
-            attrs: Vec::new(),
-            by_ref,
-            mutability,
-            ident: ident.clone(),
-            subpat: None,
-        });
-
-        if let Some(boxed) = boxed {
-            pat = Pat::Box(PatBox {
-                attrs: Vec::new(),
-                box_token: boxed,
-                pat: Box::new(pat),
-            });
-        }
-
-        Ok(FieldPat {
-            attrs,
-            member: Member::Named(ident),
-            colon_token: None,
-            pat: Box::new(pat),
-        })
-    }
-
-    fn pat_range(
-        input: ParseStream,
-        begin: ParseBuffer,
-        qself: Option<QSelf>,
-        path: Path,
-    ) -> Result<Pat> {
-        let limits: RangeLimits = input.parse()?;
-        let hi = input.call(pat_lit_expr)?;
-        if let Some(hi) = hi {
-            Ok(Pat::Range(PatRange {
-                attrs: Vec::new(),
-                lo: Box::new(Expr::Path(ExprPath {
-                    attrs: Vec::new(),
-                    qself,
-                    path,
-                })),
-                limits,
-                hi,
-            }))
-        } else {
-            Ok(Pat::Verbatim(verbatim::between(begin, input)))
-        }
-    }
-
-    fn pat_range_half_open(input: ParseStream, begin: ParseBuffer) -> Result<Pat> {
-        let limits: RangeLimits = input.parse()?;
-        let hi = input.call(pat_lit_expr)?;
-        if hi.is_some() {
-            Ok(Pat::Verbatim(verbatim::between(begin, input)))
-        } else {
-            match limits {
-                RangeLimits::HalfOpen(dot2_token) => Ok(Pat::Rest(PatRest {
-                    attrs: Vec::new(),
-                    dot2_token,
-                })),
-                RangeLimits::Closed(_) => Err(input.error("expected range upper bound")),
-            }
-        }
-    }
-
-    fn pat_tuple(input: ParseStream) -> Result<PatTuple> {
-        let content;
-        let paren_token = parenthesized!(content in input);
-
-        let mut elems = Punctuated::new();
-        while !content.is_empty() {
-            let value = multi_pat_with_leading_vert(&content)?;
-            elems.push_value(value);
-            if content.is_empty() {
-                break;
-            }
-            let punct = content.parse()?;
-            elems.push_punct(punct);
-        }
-
-        Ok(PatTuple {
-            attrs: Vec::new(),
-            paren_token,
-            elems,
-        })
-    }
-
-    fn pat_reference(input: ParseStream) -> Result<PatReference> {
-        Ok(PatReference {
-            attrs: Vec::new(),
-            and_token: input.parse()?,
-            mutability: input.parse()?,
-            pat: input.parse()?,
-        })
-    }
-
-    fn pat_lit_or_range(input: ParseStream) -> Result<Pat> {
-        let begin = input.fork();
-        let lo = input.call(pat_lit_expr)?.unwrap();
-        if input.peek(Token![..]) {
-            let limits: RangeLimits = input.parse()?;
-            let hi = input.call(pat_lit_expr)?;
-            if let Some(hi) = hi {
-                Ok(Pat::Range(PatRange {
-                    attrs: Vec::new(),
-                    lo,
-                    limits,
-                    hi,
-                }))
-            } else {
-                Ok(Pat::Verbatim(verbatim::between(begin, input)))
-            }
-        } else if let Expr::Verbatim(verbatim) = *lo {
-            Ok(Pat::Verbatim(verbatim))
-        } else {
-            Ok(Pat::Lit(PatLit {
-                attrs: Vec::new(),
-                expr: lo,
-            }))
-        }
-    }
-
-    fn pat_lit_expr(input: ParseStream) -> Result<Option<Box<Expr>>> {
-        if input.is_empty()
-            || input.peek(Token![|])
-            || input.peek(Token![=>])
-            || input.peek(Token![:]) && !input.peek(Token![::])
-            || input.peek(Token![,])
-            || input.peek(Token![;])
-        {
-            return Ok(None);
-        }
-
-        let neg: Option<Token![-]> = input.parse()?;
-
-        let lookahead = input.lookahead1();
-        let expr = if lookahead.peek(Lit) {
-            Expr::Lit(input.parse()?)
-        } else if lookahead.peek(Ident)
-            || lookahead.peek(Token![::])
-            || lookahead.peek(Token![<])
-            || lookahead.peek(Token![self])
-            || lookahead.peek(Token![Self])
-            || lookahead.peek(Token![super])
-            || lookahead.peek(Token![crate])
-        {
-            Expr::Path(input.parse()?)
-        } else if lookahead.peek(Token![const]) {
-            Expr::Verbatim(input.call(expr::parsing::expr_const)?)
-        } else {
-            return Err(lookahead.error());
-        };
-
-        Ok(Some(Box::new(if let Some(neg) = neg {
-            Expr::Unary(ExprUnary {
-                attrs: Vec::new(),
-                op: UnOp::Neg(neg),
-                expr: Box::new(expr),
-            })
-        } else {
-            expr
-        })))
-    }
-
-    fn pat_slice(input: ParseStream) -> Result<PatSlice> {
-        let content;
-        let bracket_token = bracketed!(content in input);
-
-        let mut elems = Punctuated::new();
-        while !content.is_empty() {
-            let value = multi_pat_with_leading_vert(&content)?;
-            elems.push_value(value);
-            if content.is_empty() {
-                break;
-            }
-            let punct = content.parse()?;
-            elems.push_punct(punct);
-        }
-
-        Ok(PatSlice {
-            attrs: Vec::new(),
-            bracket_token,
-            elems,
-        })
-    }
-
-    fn pat_const(input: ParseStream) -> Result<TokenStream> {
-        let begin = input.fork();
-        input.parse::<Token![const]>()?;
-
-        let content;
-        braced!(content in input);
-        content.call(Attribute::parse_inner)?;
-        content.call(Block::parse_within)?;
-
-        Ok(verbatim::between(begin, input))
-    }
-
-    pub fn multi_pat(input: ParseStream) -> Result<Pat> {
-        multi_pat_impl(input, None)
-    }
-
-    pub fn multi_pat_with_leading_vert(input: ParseStream) -> Result<Pat> {
-        let leading_vert: Option<Token![|]> = input.parse()?;
-        multi_pat_impl(input, leading_vert)
-    }
-
-    fn multi_pat_impl(input: ParseStream, leading_vert: Option<Token![|]>) -> Result<Pat> {
-        let mut pat: Pat = input.parse()?;
-        if leading_vert.is_some()
-            || input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=])
-        {
-            let mut cases = Punctuated::new();
-            cases.push_value(pat);
-            while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
-                let punct = input.parse()?;
-                cases.push_punct(punct);
-                let pat: Pat = input.parse()?;
-                cases.push_value(pat);
-            }
-            pat = Pat::Or(PatOr {
-                attrs: Vec::new(),
-                leading_vert,
-                cases,
-            });
-        }
-        Ok(pat)
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatWild {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.underscore_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatIdent {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.by_ref.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.ident.to_tokens(tokens);
-            if let Some((at_token, subpat)) = &self.subpat {
-                at_token.to_tokens(tokens);
-                subpat.to_tokens(tokens);
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatStruct {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.path.to_tokens(tokens);
-            self.brace_token.surround(tokens, |tokens| {
-                self.fields.to_tokens(tokens);
-                // NOTE: We need a comma before the dot2 token if it is present.
-                if !self.fields.empty_or_trailing() && self.dot2_token.is_some() {
-                    <Token![,]>::default().to_tokens(tokens);
-                }
-                self.dot2_token.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatTupleStruct {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.path.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.pat.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatPath {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            private::print_path(tokens, &self.qself, &self.path);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatTuple {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.paren_token.surround(tokens, |tokens| {
-                self.elems.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatBox {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.box_token.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatReference {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.and_token.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatRest {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.dot2_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatLit {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.expr.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatRange {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.lo.to_tokens(tokens);
-            match &self.limits {
-                RangeLimits::HalfOpen(t) => t.to_tokens(tokens),
-                RangeLimits::Closed(t) => t.to_tokens(tokens),
-            }
-            self.hi.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatSlice {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.bracket_token.surround(tokens, |tokens| {
-                self.elems.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.mac.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PatOr {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.leading_vert.to_tokens(tokens);
-            self.cases.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for FieldPat {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            if let Some(colon_token) = &self.colon_token {
-                self.member.to_tokens(tokens);
-                colon_token.to_tokens(tokens);
-            }
-            self.pat.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/path.rs b/vendor/syn/src/path.rs
deleted file mode 100644
index 37e41bc4..00000000
--- a/vendor/syn/src/path.rs
+++ /dev/null
@@ -1,842 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-
-ast_struct! {
-    /// A path at which a named item is exported (e.g. `std::collections::HashMap`).
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Path {
-        pub leading_colon: Option<Token![::]>,
-        pub segments: Punctuated<PathSegment, Token![::]>,
-    }
-}
-
-impl<T> From<T> for Path
-where
-    T: Into<PathSegment>,
-{
-    fn from(segment: T) -> Self {
-        let mut path = Path {
-            leading_colon: None,
-            segments: Punctuated::new(),
-        };
-        path.segments.push_value(segment.into());
-        path
-    }
-}
-
-ast_struct! {
-    /// A segment of a path together with any path arguments on that segment.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct PathSegment {
-        pub ident: Ident,
-        pub arguments: PathArguments,
-    }
-}
-
-impl<T> From<T> for PathSegment
-where
-    T: Into<Ident>,
-{
-    fn from(ident: T) -> Self {
-        PathSegment {
-            ident: ident.into(),
-            arguments: PathArguments::None,
-        }
-    }
-}
-
-ast_enum! {
-    /// Angle bracketed or parenthesized arguments of a path segment.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// ## Angle bracketed
-    ///
-    /// The `<'a, T>` in `std::slice::iter<'a, T>`.
-    ///
-    /// ## Parenthesized
-    ///
-    /// The `(A, B) -> C` in `Fn(A, B) -> C`.
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum PathArguments {
-        None,
-        /// The `<'a, T>` in `std::slice::iter<'a, T>`.
-        AngleBracketed(AngleBracketedGenericArguments),
-        /// The `(A, B) -> C` in `Fn(A, B) -> C`.
-        Parenthesized(ParenthesizedGenericArguments),
-    }
-}
-
-impl Default for PathArguments {
-    fn default() -> Self {
-        PathArguments::None
-    }
-}
-
-impl PathArguments {
-    pub fn is_empty(&self) -> bool {
-        match self {
-            PathArguments::None => true,
-            PathArguments::AngleBracketed(bracketed) => bracketed.args.is_empty(),
-            PathArguments::Parenthesized(_) => false,
-        }
-    }
-
-    #[cfg(feature = "parsing")]
-    fn is_none(&self) -> bool {
-        match *self {
-            PathArguments::None => true,
-            PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => false,
-        }
-    }
-}
-
-ast_enum! {
-    /// An individual generic argument, like `'a`, `T`, or `Item = T`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum GenericArgument {
-        /// A lifetime argument.
-        Lifetime(Lifetime),
-        /// A type argument.
-        Type(Type),
-        /// A binding (equality constraint) on an associated type: the `Item =
-        /// u8` in `Iterator<Item = u8>`.
-        Binding(Binding),
-        /// An associated type bound: `Iterator<Item: Display>`.
-        Constraint(Constraint),
-        /// A const expression. Must be inside of a block.
-        ///
-        /// NOTE: Identity expressions are represented as Type arguments, as
-        /// they are indistinguishable syntactically.
-        Const(Expr),
-    }
-}
-
-ast_struct! {
-    /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,
-    /// V>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct AngleBracketedGenericArguments {
-        pub colon2_token: Option<Token![::]>,
-        pub lt_token: Token![<],
-        pub args: Punctuated<GenericArgument, Token![,]>,
-        pub gt_token: Token![>],
-    }
-}
-
-ast_struct! {
-    /// A binding (equality constraint) on an associated type: `Item = u8`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Binding {
-        pub ident: Ident,
-        pub eq_token: Token![=],
-        pub ty: Type,
-    }
-}
-
-ast_struct! {
-    /// An associated type bound: `Iterator<Item: Display>`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Constraint {
-        pub ident: Ident,
-        pub colon_token: Token![:],
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->
-    /// C`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct ParenthesizedGenericArguments {
-        pub paren_token: token::Paren,
-        /// `(A, B)`
-        pub inputs: Punctuated<Type, Token![,]>,
-        /// `C`
-        pub output: ReturnType,
-    }
-}
-
-ast_struct! {
-    /// The explicit Self type in a qualified path: the `T` in `<T as
-    /// Display>::fmt`.
-    ///
-    /// The actual path, including the trait and the associated item, is stored
-    /// separately. The `position` field represents the index of the associated
-    /// item qualified with this Self type.
-    ///
-    /// ```text
-    /// <Vec<T> as a::b::Trait>::AssociatedItem
-    ///  ^~~~~~    ~~~~~~~~~~~~~~^
-    ///  ty        position = 3
-    ///
-    /// <Vec<T>>::AssociatedItem
-    ///  ^~~~~~   ^
-    ///  ty       position = 0
-    /// ```
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct QSelf {
-        pub lt_token: Token![<],
-        pub ty: Box<Type>,
-        pub position: usize,
-        pub as_token: Option<Token![as]>,
-        pub gt_token: Token![>],
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-
-    use crate::ext::IdentExt;
-    use crate::parse::{Parse, ParseStream, Result};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Path {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Self::parse_helper(input, false)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for GenericArgument {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Lifetime) && !input.peek2(Token![+]) {
-                return Ok(GenericArgument::Lifetime(input.parse()?));
-            }
-
-            if input.peek(Ident) && input.peek2(Token![=]) {
-                return Ok(GenericArgument::Binding(input.parse()?));
-            }
-
-            #[cfg(feature = "full")]
-            {
-                if input.peek(Ident) && input.peek2(Token![:]) && !input.peek2(Token![::]) {
-                    return Ok(GenericArgument::Constraint(input.parse()?));
-                }
-            }
-
-            if input.peek(Lit) || input.peek(token::Brace) {
-                return const_argument(input).map(GenericArgument::Const);
-            }
-
-            #[cfg(feature = "full")]
-            let begin = input.fork();
-
-            let argument: Type = input.parse()?;
-
-            #[cfg(feature = "full")]
-            {
-                if match &argument {
-                    Type::Path(argument)
-                        if argument.qself.is_none()
-                            && argument.path.leading_colon.is_none()
-                            && argument.path.segments.len() == 1 =>
-                    {
-                        match argument.path.segments[0].arguments {
-                            PathArguments::AngleBracketed(_) => true,
-                            _ => false,
-                        }
-                    }
-                    _ => false,
-                } && if input.peek(Token![=]) {
-                    input.parse::<Token![=]>()?;
-                    input.parse::<Type>()?;
-                    true
-                } else if input.peek(Token![:]) {
-                    input.parse::<Token![:]>()?;
-                    input.call(constraint_bounds)?;
-                    true
-                } else {
-                    false
-                } {
-                    let verbatim = verbatim::between(begin, input);
-                    return Ok(GenericArgument::Type(Type::Verbatim(verbatim)));
-                }
-            }
-
-            Ok(GenericArgument::Type(argument))
-        }
-    }
-
-    pub fn const_argument(input: ParseStream) -> Result<Expr> {
-        let lookahead = input.lookahead1();
-
-        if input.peek(Lit) {
-            let lit = input.parse()?;
-            return Ok(Expr::Lit(lit));
-        }
-
-        #[cfg(feature = "full")]
-        {
-            if input.peek(Ident) {
-                let ident: Ident = input.parse()?;
-                return Ok(Expr::Path(ExprPath {
-                    attrs: Vec::new(),
-                    qself: None,
-                    path: Path::from(ident),
-                }));
-            }
-        }
-
-        if input.peek(token::Brace) {
-            #[cfg(feature = "full")]
-            {
-                let block: ExprBlock = input.parse()?;
-                return Ok(Expr::Block(block));
-            }
-
-            #[cfg(not(feature = "full"))]
-            {
-                let begin = input.fork();
-                let content;
-                braced!(content in input);
-                content.parse::<Expr>()?;
-                let verbatim = verbatim::between(begin, input);
-                return Ok(Expr::Verbatim(verbatim));
-            }
-        }
-
-        Err(lookahead.error())
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for AngleBracketedGenericArguments {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(AngleBracketedGenericArguments {
-                colon2_token: input.parse()?,
-                lt_token: input.parse()?,
-                args: {
-                    let mut args = Punctuated::new();
-                    loop {
-                        if input.peek(Token![>]) {
-                            break;
-                        }
-                        let value = input.parse()?;
-                        args.push_value(value);
-                        if input.peek(Token![>]) {
-                            break;
-                        }
-                        let punct = input.parse()?;
-                        args.push_punct(punct);
-                    }
-                    args
-                },
-                gt_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ParenthesizedGenericArguments {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(ParenthesizedGenericArguments {
-                paren_token: parenthesized!(content in input),
-                inputs: content.parse_terminated(Type::parse)?,
-                output: input.call(ReturnType::without_plus)?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for PathSegment {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Self::parse_helper(input, false)
-        }
-    }
-
-    impl PathSegment {
-        fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
-            if input.peek(Token![super]) || input.peek(Token![self]) || input.peek(Token![crate]) {
-                let ident = input.call(Ident::parse_any)?;
-                return Ok(PathSegment::from(ident));
-            }
-
-            let ident = if input.peek(Token![Self]) {
-                input.call(Ident::parse_any)?
-            } else {
-                input.parse()?
-            };
-
-            if !expr_style && input.peek(Token![<]) && !input.peek(Token![<=])
-                || input.peek(Token![::]) && input.peek3(Token![<])
-            {
-                Ok(PathSegment {
-                    ident,
-                    arguments: PathArguments::AngleBracketed(input.parse()?),
-                })
-            } else {
-                Ok(PathSegment::from(ident))
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Binding {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(Binding {
-                ident: input.parse()?,
-                eq_token: input.parse()?,
-                ty: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Constraint {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(Constraint {
-                ident: input.parse()?,
-                colon_token: input.parse()?,
-                bounds: constraint_bounds(input)?,
-            })
-        }
-    }
-
-    #[cfg(feature = "full")]
-    fn constraint_bounds(input: ParseStream) -> Result<Punctuated<TypeParamBound, Token![+]>> {
-        let mut bounds = Punctuated::new();
-        loop {
-            if input.peek(Token![,]) || input.peek(Token![>]) {
-                break;
-            }
-            let value = input.parse()?;
-            bounds.push_value(value);
-            if !input.peek(Token![+]) {
-                break;
-            }
-            let punct = input.parse()?;
-            bounds.push_punct(punct);
-        }
-        Ok(bounds)
-    }
-
-    impl Path {
-        /// Parse a `Path` containing no path arguments on any of its segments.
-        ///
-        /// *This function is available only if Syn is built with the `"parsing"`
-        /// feature.*
-        ///
-        /// # Example
-        ///
-        /// ```
-        /// use syn::{Path, Result, Token};
-        /// use syn::parse::{Parse, ParseStream};
-        ///
-        /// // A simplified single `use` statement like:
-        /// //
-        /// //     use std::collections::HashMap;
-        /// //
-        /// // Note that generic parameters are not allowed in a `use` statement
-        /// // so the following must not be accepted.
-        /// //
-        /// //     use a::<b>::c;
-        /// struct SingleUse {
-        ///     use_token: Token![use],
-        ///     path: Path,
-        /// }
-        ///
-        /// impl Parse for SingleUse {
-        ///     fn parse(input: ParseStream) -> Result<Self> {
-        ///         Ok(SingleUse {
-        ///             use_token: input.parse()?,
-        ///             path: input.call(Path::parse_mod_style)?,
-        ///         })
-        ///     }
-        /// }
-        /// ```
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn parse_mod_style(input: ParseStream) -> Result<Self> {
-            Ok(Path {
-                leading_colon: input.parse()?,
-                segments: {
-                    let mut segments = Punctuated::new();
-                    loop {
-                        if !input.peek(Ident)
-                            && !input.peek(Token![super])
-                            && !input.peek(Token![self])
-                            && !input.peek(Token![Self])
-                            && !input.peek(Token![crate])
-                        {
-                            break;
-                        }
-                        let ident = Ident::parse_any(input)?;
-                        segments.push_value(PathSegment::from(ident));
-                        if !input.peek(Token![::]) {
-                            break;
-                        }
-                        let punct = input.parse()?;
-                        segments.push_punct(punct);
-                    }
-                    if segments.is_empty() {
-                        return Err(input.error("expected path"));
-                    } else if segments.trailing_punct() {
-                        return Err(input.error("expected path segment"));
-                    }
-                    segments
-                },
-            })
-        }
-
-        /// Determines whether this is a path of length 1 equal to the given
-        /// ident.
-        ///
-        /// For them to compare equal, it must be the case that:
-        ///
-        /// - the path has no leading colon,
-        /// - the number of path segments is 1,
-        /// - the first path segment has no angle bracketed or parenthesized
-        ///   path arguments, and
-        /// - the ident of the first path segment is equal to the given one.
-        ///
-        /// *This function is available only if Syn is built with the `"parsing"`
-        /// feature.*
-        ///
-        /// # Example
-        ///
-        /// ```
-        /// use syn::{Attribute, Error, Meta, NestedMeta, Result};
-        /// # use std::iter::FromIterator;
-        ///
-        /// fn get_serde_meta_items(attr: &Attribute) -> Result<Vec<NestedMeta>> {
-        ///     if attr.path.is_ident("serde") {
-        ///         match attr.parse_meta()? {
-        ///             Meta::List(meta) => Ok(Vec::from_iter(meta.nested)),
-        ///             bad => Err(Error::new_spanned(bad, "unrecognized attribute")),
-        ///         }
-        ///     } else {
-        ///         Ok(Vec::new())
-        ///     }
-        /// }
-        /// ```
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn is_ident<I: ?Sized>(&self, ident: &I) -> bool
-        where
-            Ident: PartialEq<I>,
-        {
-            match self.get_ident() {
-                Some(id) => id == ident,
-                None => false,
-            }
-        }
-
-        /// If this path consists of a single ident, returns the ident.
-        ///
-        /// A path is considered an ident if:
-        ///
-        /// - the path has no leading colon,
-        /// - the number of path segments is 1, and
-        /// - the first path segment has no angle bracketed or parenthesized
-        ///   path arguments.
-        ///
-        /// *This function is available only if Syn is built with the `"parsing"`
-        /// feature.*
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn get_ident(&self) -> Option<&Ident> {
-            if self.leading_colon.is_none()
-                && self.segments.len() == 1
-                && self.segments[0].arguments.is_none()
-            {
-                Some(&self.segments[0].ident)
-            } else {
-                None
-            }
-        }
-
-        pub(crate) fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
-            let mut path = Path {
-                leading_colon: input.parse()?,
-                segments: {
-                    let mut segments = Punctuated::new();
-                    let value = PathSegment::parse_helper(input, expr_style)?;
-                    segments.push_value(value);
-                    segments
-                },
-            };
-            Path::parse_rest(input, &mut path, expr_style)?;
-            Ok(path)
-        }
-
-        pub(crate) fn parse_rest(
-            input: ParseStream,
-            path: &mut Self,
-            expr_style: bool,
-        ) -> Result<()> {
-            while input.peek(Token![::]) {
-                let punct: Token![::] = input.parse()?;
-                path.segments.push_punct(punct);
-                let value = PathSegment::parse_helper(input, expr_style)?;
-                path.segments.push_value(value);
-            }
-            Ok(())
-        }
-    }
-
-    pub fn qpath(input: ParseStream, expr_style: bool) -> Result<(Option<QSelf>, Path)> {
-        if input.peek(Token![<]) {
-            let lt_token: Token![<] = input.parse()?;
-            let this: Type = input.parse()?;
-            let path = if input.peek(Token![as]) {
-                let as_token: Token![as] = input.parse()?;
-                let path: Path = input.parse()?;
-                Some((as_token, path))
-            } else {
-                None
-            };
-            let gt_token: Token![>] = input.parse()?;
-            let colon2_token: Token![::] = input.parse()?;
-            let mut rest = Punctuated::new();
-            loop {
-                let path = PathSegment::parse_helper(input, expr_style)?;
-                rest.push_value(path);
-                if !input.peek(Token![::]) {
-                    break;
-                }
-                let punct: Token![::] = input.parse()?;
-                rest.push_punct(punct);
-            }
-            let (position, as_token, path) = match path {
-                Some((as_token, mut path)) => {
-                    let pos = path.segments.len();
-                    path.segments.push_punct(colon2_token);
-                    path.segments.extend(rest.into_pairs());
-                    (pos, Some(as_token), path)
-                }
-                None => {
-                    let path = Path {
-                        leading_colon: Some(colon2_token),
-                        segments: rest,
-                    };
-                    (0, None, path)
-                }
-            };
-            let qself = QSelf {
-                lt_token,
-                ty: Box::new(this),
-                position,
-                as_token,
-                gt_token,
-            };
-            Ok((Some(qself), path))
-        } else {
-            let path = Path::parse_helper(input, expr_style)?;
-            Ok((None, path))
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::print::TokensOrDefault;
-    use proc_macro2::TokenStream;
-    use quote::ToTokens;
-    use std::cmp;
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Path {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.leading_colon.to_tokens(tokens);
-            self.segments.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PathSegment {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-            self.arguments.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for PathArguments {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                PathArguments::None => {}
-                PathArguments::AngleBracketed(arguments) => {
-                    arguments.to_tokens(tokens);
-                }
-                PathArguments::Parenthesized(arguments) => {
-                    arguments.to_tokens(tokens);
-                }
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for GenericArgument {
-        #[allow(clippy::match_same_arms)]
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                GenericArgument::Lifetime(lt) => lt.to_tokens(tokens),
-                GenericArgument::Type(ty) => ty.to_tokens(tokens),
-                GenericArgument::Binding(tb) => tb.to_tokens(tokens),
-                GenericArgument::Constraint(tc) => tc.to_tokens(tokens),
-                GenericArgument::Const(e) => match *e {
-                    Expr::Lit(_) => e.to_tokens(tokens),
-
-                    // NOTE: We should probably support parsing blocks with only
-                    // expressions in them without the full feature for const
-                    // generics.
-                    #[cfg(feature = "full")]
-                    Expr::Block(_) => e.to_tokens(tokens),
-
-                    // ERROR CORRECTION: Add braces to make sure that the
-                    // generated code is valid.
-                    _ => token::Brace::default().surround(tokens, |tokens| {
-                        e.to_tokens(tokens);
-                    }),
-                },
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for AngleBracketedGenericArguments {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.colon2_token.to_tokens(tokens);
-            self.lt_token.to_tokens(tokens);
-
-            // Print lifetimes before types and consts, all before bindings,
-            // regardless of their order in self.args.
-            //
-            // TODO: ordering rules for const arguments vs type arguments have
-            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
-            let mut trailing_or_empty = true;
-            for param in self.args.pairs() {
-                match **param.value() {
-                    GenericArgument::Lifetime(_) => {
-                        param.to_tokens(tokens);
-                        trailing_or_empty = param.punct().is_some();
-                    }
-                    GenericArgument::Type(_)
-                    | GenericArgument::Binding(_)
-                    | GenericArgument::Constraint(_)
-                    | GenericArgument::Const(_) => {}
-                }
-            }
-            for param in self.args.pairs() {
-                match **param.value() {
-                    GenericArgument::Type(_) | GenericArgument::Const(_) => {
-                        if !trailing_or_empty {
-                            <Token![,]>::default().to_tokens(tokens);
-                        }
-                        param.to_tokens(tokens);
-                        trailing_or_empty = param.punct().is_some();
-                    }
-                    GenericArgument::Lifetime(_)
-                    | GenericArgument::Binding(_)
-                    | GenericArgument::Constraint(_) => {}
-                }
-            }
-            for param in self.args.pairs() {
-                match **param.value() {
-                    GenericArgument::Binding(_) | GenericArgument::Constraint(_) => {
-                        if !trailing_or_empty {
-                            <Token![,]>::default().to_tokens(tokens);
-                        }
-                        param.to_tokens(tokens);
-                        trailing_or_empty = param.punct().is_some();
-                    }
-                    GenericArgument::Lifetime(_)
-                    | GenericArgument::Type(_)
-                    | GenericArgument::Const(_) => {}
-                }
-            }
-
-            self.gt_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Binding {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Constraint {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.ident.to_tokens(tokens);
-            self.colon_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ParenthesizedGenericArguments {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.paren_token.surround(tokens, |tokens| {
-                self.inputs.to_tokens(tokens);
-            });
-            self.output.to_tokens(tokens);
-        }
-    }
-
-    impl private {
-        pub(crate) fn print_path(tokens: &mut TokenStream, qself: &Option<QSelf>, path: &Path) {
-            let qself = match qself {
-                Some(qself) => qself,
-                None => {
-                    path.to_tokens(tokens);
-                    return;
-                }
-            };
-            qself.lt_token.to_tokens(tokens);
-            qself.ty.to_tokens(tokens);
-
-            let pos = cmp::min(qself.position, path.segments.len());
-            let mut segments = path.segments.pairs();
-            if pos > 0 {
-                TokensOrDefault(&qself.as_token).to_tokens(tokens);
-                path.leading_colon.to_tokens(tokens);
-                for (i, segment) in segments.by_ref().take(pos).enumerate() {
-                    if i + 1 == pos {
-                        segment.value().to_tokens(tokens);
-                        qself.gt_token.to_tokens(tokens);
-                        segment.punct().to_tokens(tokens);
-                    } else {
-                        segment.to_tokens(tokens);
-                    }
-                }
-            } else {
-                qself.gt_token.to_tokens(tokens);
-                path.leading_colon.to_tokens(tokens);
-            }
-            for segment in segments {
-                segment.to_tokens(tokens);
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/print.rs b/vendor/syn/src/print.rs
deleted file mode 100644
index da4e07e3..00000000
--- a/vendor/syn/src/print.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-
-pub struct TokensOrDefault<'a, T: 'a>(pub &'a Option<T>);
-
-impl<'a, T> ToTokens for TokensOrDefault<'a, T>
-where
-    T: ToTokens + Default,
-{
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        match self.0 {
-            Some(t) => t.to_tokens(tokens),
-            None => T::default().to_tokens(tokens),
-        }
-    }
-}
diff --git a/vendor/syn/src/punctuated.rs b/vendor/syn/src/punctuated.rs
deleted file mode 100644
index 5cf5235e..00000000
--- a/vendor/syn/src/punctuated.rs
+++ /dev/null
@@ -1,1040 +0,0 @@
-//! A punctuated sequence of syntax tree nodes separated by punctuation.
-//!
-//! Lots of things in Rust are punctuated sequences.
-//!
-//! - The fields of a struct are `Punctuated<Field, Token![,]>`.
-//! - The segments of a path are `Punctuated<PathSegment, Token![::]>`.
-//! - The bounds on a generic parameter are `Punctuated<TypeParamBound,
-//!   Token![+]>`.
-//! - The arguments to a function call are `Punctuated<Expr, Token![,]>`.
-//!
-//! This module provides a common representation for these punctuated sequences
-//! in the form of the [`Punctuated<T, P>`] type. We store a vector of pairs of
-//! syntax tree node + punctuation, where every node in the sequence is followed
-//! by punctuation except for possibly the final one.
-//!
-//! [`Punctuated<T, P>`]: Punctuated
-//!
-//! ```text
-//! a_function_call(arg1, arg2, arg3);
-//!                 ~~~~^ ~~~~^ ~~~~
-//! ```
-
-#[cfg(feature = "extra-traits")]
-use std::fmt::{self, Debug};
-#[cfg(feature = "extra-traits")]
-use std::hash::{Hash, Hasher};
-#[cfg(any(feature = "full", feature = "derive"))]
-use std::iter;
-use std::iter::FromIterator;
-use std::ops::{Index, IndexMut};
-use std::option;
-use std::slice;
-use std::vec;
-
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, ParseStream, Result};
-#[cfg(feature = "parsing")]
-use crate::token::Token;
-
-/// A punctuated sequence of syntax tree nodes of type `T` separated by
-/// punctuation of type `P`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct Punctuated<T, P> {
-    inner: Vec<(T, P)>,
-    last: Option<Box<T>>,
-}
-
-impl<T, P> Punctuated<T, P> {
-    /// Creates an empty punctuated sequence.
-    #[cfg(not(syn_no_const_vec_new))]
-    pub const fn new() -> Self {
-        Punctuated {
-            inner: Vec::new(),
-            last: None,
-        }
-    }
-
-    /// Creates an empty punctuated sequence.
-    #[cfg(syn_no_const_vec_new)]
-    pub fn new() -> Self {
-        Punctuated {
-            inner: Vec::new(),
-            last: None,
-        }
-    }
-
-    /// Determines whether this punctuated sequence is empty, meaning it
-    /// contains no syntax tree nodes or punctuation.
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0 && self.last.is_none()
-    }
-
-    /// Returns the number of syntax tree nodes in this punctuated sequence.
-    ///
-    /// This is the number of nodes of type `T`, not counting the punctuation of
-    /// type `P`.
-    pub fn len(&self) -> usize {
-        self.inner.len() + if self.last.is_some() { 1 } else { 0 }
-    }
-
-    /// Borrows the first element in this sequence.
-    pub fn first(&self) -> Option<&T> {
-        self.iter().next()
-    }
-
-    /// Mutably borrows the first element in this sequence.
-    pub fn first_mut(&mut self) -> Option<&mut T> {
-        self.iter_mut().next()
-    }
-
-    /// Borrows the last element in this sequence.
-    pub fn last(&self) -> Option<&T> {
-        self.iter().next_back()
-    }
-
-    /// Mutably borrows the last element in this sequence.
-    pub fn last_mut(&mut self) -> Option<&mut T> {
-        self.iter_mut().next_back()
-    }
-
-    /// Returns an iterator over borrowed syntax tree nodes of type `&T`.
-    pub fn iter(&self) -> Iter<T> {
-        Iter {
-            inner: Box::new(PrivateIter {
-                inner: self.inner.iter(),
-                last: self.last.as_ref().map(Box::as_ref).into_iter(),
-            }),
-        }
-    }
-
-    /// Returns an iterator over mutably borrowed syntax tree nodes of type
-    /// `&mut T`.
-    pub fn iter_mut(&mut self) -> IterMut<T> {
-        IterMut {
-            inner: Box::new(PrivateIterMut {
-                inner: self.inner.iter_mut(),
-                last: self.last.as_mut().map(Box::as_mut).into_iter(),
-            }),
-        }
-    }
-
-    /// Returns an iterator over the contents of this sequence as borrowed
-    /// punctuated pairs.
-    pub fn pairs(&self) -> Pairs<T, P> {
-        Pairs {
-            inner: self.inner.iter(),
-            last: self.last.as_ref().map(Box::as_ref).into_iter(),
-        }
-    }
-
-    /// Returns an iterator over the contents of this sequence as mutably
-    /// borrowed punctuated pairs.
-    pub fn pairs_mut(&mut self) -> PairsMut<T, P> {
-        PairsMut {
-            inner: self.inner.iter_mut(),
-            last: self.last.as_mut().map(Box::as_mut).into_iter(),
-        }
-    }
-
-    /// Returns an iterator over the contents of this sequence as owned
-    /// punctuated pairs.
-    pub fn into_pairs(self) -> IntoPairs<T, P> {
-        IntoPairs {
-            inner: self.inner.into_iter(),
-            last: self.last.map(|t| *t).into_iter(),
-        }
-    }
-
-    /// Appends a syntax tree node onto the end of this punctuated sequence. The
-    /// sequence must previously have a trailing punctuation.
-    ///
-    /// Use [`push`] instead if the punctuated sequence may or may not already
-    /// have trailing punctuation.
-    ///
-    /// [`push`]: Punctuated::push
-    ///
-    /// # Panics
-    ///
-    /// Panics if the sequence does not already have a trailing punctuation when
-    /// this method is called.
-    pub fn push_value(&mut self, value: T) {
-        assert!(
-            self.empty_or_trailing(),
-            "Punctuated::push_value: cannot push value if Punctuated is missing trailing punctuation",
-        );
-
-        self.last = Some(Box::new(value));
-    }
-
-    /// Appends a trailing punctuation onto the end of this punctuated sequence.
-    /// The sequence must be non-empty and must not already have trailing
-    /// punctuation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the sequence is empty or already has a trailing punctuation.
-    pub fn push_punct(&mut self, punctuation: P) {
-        assert!(
-            self.last.is_some(),
-            "Punctuated::push_punct: cannot push punctuation if Punctuated is empty or already has trailing punctuation",
-        );
-
-        let last = self.last.take().unwrap();
-        self.inner.push((*last, punctuation));
-    }
-
-    /// Removes the last punctuated pair from this sequence, or `None` if the
-    /// sequence is empty.
-    pub fn pop(&mut self) -> Option<Pair<T, P>> {
-        if self.last.is_some() {
-            self.last.take().map(|t| Pair::End(*t))
-        } else {
-            self.inner.pop().map(|(t, d)| Pair::Punctuated(t, d))
-        }
-    }
-
-    /// Determines whether this punctuated sequence ends with a trailing
-    /// punctuation.
-    pub fn trailing_punct(&self) -> bool {
-        self.last.is_none() && !self.is_empty()
-    }
-
-    /// Returns true if either this `Punctuated` is empty, or it has a trailing
-    /// punctuation.
-    ///
-    /// Equivalent to `punctuated.is_empty() || punctuated.trailing_punct()`.
-    pub fn empty_or_trailing(&self) -> bool {
-        self.last.is_none()
-    }
-
-    /// Appends a syntax tree node onto the end of this punctuated sequence.
-    ///
-    /// If there is not a trailing punctuation in this sequence when this method
-    /// is called, the default value of punctuation type `P` is inserted before
-    /// the given value of type `T`.
-    pub fn push(&mut self, value: T)
-    where
-        P: Default,
-    {
-        if !self.empty_or_trailing() {
-            self.push_punct(Default::default());
-        }
-        self.push_value(value);
-    }
-
-    /// Inserts an element at position `index`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is greater than the number of elements previously in
-    /// this punctuated sequence.
-    pub fn insert(&mut self, index: usize, value: T)
-    where
-        P: Default,
-    {
-        assert!(
-            index <= self.len(),
-            "Punctuated::insert: index out of range",
-        );
-
-        if index == self.len() {
-            self.push(value);
-        } else {
-            self.inner.insert(index, (value, Default::default()));
-        }
-    }
-
-    /// Clears the sequence of all values and punctuation, making it empty.
-    pub fn clear(&mut self) {
-        self.inner.clear();
-        self.last = None;
-    }
-
-    /// Parses zero or more occurrences of `T` separated by punctuation of type
-    /// `P`, with optional trailing punctuation.
-    ///
-    /// Parsing continues until the end of this parse stream. The entire content
-    /// of this parse stream must consist of `T` and `P`.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_terminated(input: ParseStream) -> Result<Self>
-    where
-        T: Parse,
-        P: Parse,
-    {
-        Self::parse_terminated_with(input, T::parse)
-    }
-
-    /// Parses zero or more occurrences of `T` using the given parse function,
-    /// separated by punctuation of type `P`, with optional trailing
-    /// punctuation.
-    ///
-    /// Like [`parse_terminated`], the entire content of this stream is expected
-    /// to be parsed.
-    ///
-    /// [`parse_terminated`]: Punctuated::parse_terminated
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_terminated_with(
-        input: ParseStream,
-        parser: fn(ParseStream) -> Result<T>,
-    ) -> Result<Self>
-    where
-        P: Parse,
-    {
-        let mut punctuated = Punctuated::new();
-
-        loop {
-            if input.is_empty() {
-                break;
-            }
-            let value = parser(input)?;
-            punctuated.push_value(value);
-            if input.is_empty() {
-                break;
-            }
-            let punct = input.parse()?;
-            punctuated.push_punct(punct);
-        }
-
-        Ok(punctuated)
-    }
-
-    /// Parses one or more occurrences of `T` separated by punctuation of type
-    /// `P`, not accepting trailing punctuation.
-    ///
-    /// Parsing continues as long as punctuation `P` is present at the head of
-    /// the stream. This method returns upon parsing a `T` and observing that it
-    /// is not followed by a `P`, even if there are remaining tokens in the
-    /// stream.
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_separated_nonempty(input: ParseStream) -> Result<Self>
-    where
-        T: Parse,
-        P: Token + Parse,
-    {
-        Self::parse_separated_nonempty_with(input, T::parse)
-    }
-
-    /// Parses one or more occurrences of `T` using the given parse function,
-    /// separated by punctuation of type `P`, not accepting trailing
-    /// punctuation.
-    ///
-    /// Like [`parse_separated_nonempty`], may complete early without parsing
-    /// the entire content of this stream.
-    ///
-    /// [`parse_separated_nonempty`]: Punctuated::parse_separated_nonempty
-    ///
-    /// *This function is available only if Syn is built with the `"parsing"`
-    /// feature.*
-    #[cfg(feature = "parsing")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    pub fn parse_separated_nonempty_with(
-        input: ParseStream,
-        parser: fn(ParseStream) -> Result<T>,
-    ) -> Result<Self>
-    where
-        P: Token + Parse,
-    {
-        let mut punctuated = Punctuated::new();
-
-        loop {
-            let value = parser(input)?;
-            punctuated.push_value(value);
-            if !P::peek(input.cursor()) {
-                break;
-            }
-            let punct = input.parse()?;
-            punctuated.push_punct(punct);
-        }
-
-        Ok(punctuated)
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl<T, P> Clone for Punctuated<T, P>
-where
-    T: Clone,
-    P: Clone,
-{
-    fn clone(&self) -> Self {
-        Punctuated {
-            inner: self.inner.clone(),
-            last: self.last.clone(),
-        }
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl<T, P> Eq for Punctuated<T, P>
-where
-    T: Eq,
-    P: Eq,
-{
-}
-
-#[cfg(feature = "extra-traits")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl<T, P> PartialEq for Punctuated<T, P>
-where
-    T: PartialEq,
-    P: PartialEq,
-{
-    fn eq(&self, other: &Self) -> bool {
-        let Punctuated { inner, last } = self;
-        *inner == other.inner && *last == other.last
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl<T, P> Hash for Punctuated<T, P>
-where
-    T: Hash,
-    P: Hash,
-{
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let Punctuated { inner, last } = self;
-        inner.hash(state);
-        last.hash(state);
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl<T: Debug, P: Debug> Debug for Punctuated<T, P> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut list = f.debug_list();
-        for (t, p) in &self.inner {
-            list.entry(t);
-            list.entry(p);
-        }
-        if let Some(last) = &self.last {
-            list.entry(last);
-        }
-        list.finish()
-    }
-}
-
-impl<T, P> FromIterator<T> for Punctuated<T, P>
-where
-    P: Default,
-{
-    fn from_iter<I: IntoIterator<Item = T>>(i: I) -> Self {
-        let mut ret = Punctuated::new();
-        ret.extend(i);
-        ret
-    }
-}
-
-impl<T, P> Extend<T> for Punctuated<T, P>
-where
-    P: Default,
-{
-    fn extend<I: IntoIterator<Item = T>>(&mut self, i: I) {
-        for value in i {
-            self.push(value);
-        }
-    }
-}
-
-impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P> {
-    fn from_iter<I: IntoIterator<Item = Pair<T, P>>>(i: I) -> Self {
-        let mut ret = Punctuated::new();
-        ret.extend(i);
-        ret
-    }
-}
-
-impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P> {
-    fn extend<I: IntoIterator<Item = Pair<T, P>>>(&mut self, i: I) {
-        assert!(
-            self.empty_or_trailing(),
-            "Punctuated::extend: Punctuated is not empty or does not have a trailing punctuation",
-        );
-
-        let mut nomore = false;
-        for pair in i {
-            if nomore {
-                panic!("Punctuated extended with items after a Pair::End");
-            }
-            match pair {
-                Pair::Punctuated(a, b) => self.inner.push((a, b)),
-                Pair::End(a) => {
-                    self.last = Some(Box::new(a));
-                    nomore = true;
-                }
-            }
-        }
-    }
-}
-
-impl<T, P> IntoIterator for Punctuated<T, P> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        let mut elements = Vec::with_capacity(self.len());
-        elements.extend(self.inner.into_iter().map(|pair| pair.0));
-        elements.extend(self.last.map(|t| *t));
-
-        IntoIter {
-            inner: elements.into_iter(),
-        }
-    }
-}
-
-impl<'a, T, P> IntoIterator for &'a Punctuated<T, P> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Punctuated::iter(self)
-    }
-}
-
-impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Punctuated::iter_mut(self)
-    }
-}
-
-impl<T, P> Default for Punctuated<T, P> {
-    fn default() -> Self {
-        Punctuated::new()
-    }
-}
-
-/// An iterator over borrowed pairs of type `Pair<&T, &P>`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct Pairs<'a, T: 'a, P: 'a> {
-    inner: slice::Iter<'a, (T, P)>,
-    last: option::IntoIter<&'a T>,
-}
-
-impl<'a, T, P> Iterator for Pairs<'a, T, P> {
-    type Item = Pair<&'a T, &'a P>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|(t, p)| Pair::Punctuated(t, p))
-            .or_else(|| self.last.next().map(Pair::End))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<'a, T, P> DoubleEndedIterator for Pairs<'a, T, P> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.last
-            .next()
-            .map(Pair::End)
-            .or_else(|| self.inner.next_back().map(|(t, p)| Pair::Punctuated(t, p)))
-    }
-}
-
-impl<'a, T, P> ExactSizeIterator for Pairs<'a, T, P> {
-    fn len(&self) -> usize {
-        self.inner.len() + self.last.len()
-    }
-}
-
-// No Clone bound on T or P.
-impl<'a, T, P> Clone for Pairs<'a, T, P> {
-    fn clone(&self) -> Self {
-        Pairs {
-            inner: self.inner.clone(),
-            last: self.last.clone(),
-        }
-    }
-}
-
-/// An iterator over mutably borrowed pairs of type `Pair<&mut T, &mut P>`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct PairsMut<'a, T: 'a, P: 'a> {
-    inner: slice::IterMut<'a, (T, P)>,
-    last: option::IntoIter<&'a mut T>,
-}
-
-impl<'a, T, P> Iterator for PairsMut<'a, T, P> {
-    type Item = Pair<&'a mut T, &'a mut P>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|(t, p)| Pair::Punctuated(t, p))
-            .or_else(|| self.last.next().map(Pair::End))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<'a, T, P> DoubleEndedIterator for PairsMut<'a, T, P> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.last
-            .next()
-            .map(Pair::End)
-            .or_else(|| self.inner.next_back().map(|(t, p)| Pair::Punctuated(t, p)))
-    }
-}
-
-impl<'a, T, P> ExactSizeIterator for PairsMut<'a, T, P> {
-    fn len(&self) -> usize {
-        self.inner.len() + self.last.len()
-    }
-}
-
-/// An iterator over owned pairs of type `Pair<T, P>`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct IntoPairs<T, P> {
-    inner: vec::IntoIter<(T, P)>,
-    last: option::IntoIter<T>,
-}
-
-impl<T, P> Iterator for IntoPairs<T, P> {
-    type Item = Pair<T, P>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|(t, p)| Pair::Punctuated(t, p))
-            .or_else(|| self.last.next().map(Pair::End))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<T, P> DoubleEndedIterator for IntoPairs<T, P> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.last
-            .next()
-            .map(Pair::End)
-            .or_else(|| self.inner.next_back().map(|(t, p)| Pair::Punctuated(t, p)))
-    }
-}
-
-impl<T, P> ExactSizeIterator for IntoPairs<T, P> {
-    fn len(&self) -> usize {
-        self.inner.len() + self.last.len()
-    }
-}
-
-impl<T, P> Clone for IntoPairs<T, P>
-where
-    T: Clone,
-    P: Clone,
-{
-    fn clone(&self) -> Self {
-        IntoPairs {
-            inner: self.inner.clone(),
-            last: self.last.clone(),
-        }
-    }
-}
-
-/// An iterator over owned values of type `T`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct IntoIter<T> {
-    inner: vec::IntoIter<T>,
-}
-
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.inner.next_back()
-    }
-}
-
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-impl<T> Clone for IntoIter<T>
-where
-    T: Clone,
-{
-    fn clone(&self) -> Self {
-        IntoIter {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-/// An iterator over borrowed values of type `&T`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct Iter<'a, T: 'a> {
-    // The `Item = &'a T` needs to be specified to support rustc 1.31 and older.
-    // On modern compilers we would be able to write just IterTrait<'a, T> where
-    // Item can be inferred unambiguously from the supertrait.
-    inner: Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>,
-}
-
-trait IterTrait<'a, T: 'a>:
-    DoubleEndedIterator<Item = &'a T> + ExactSizeIterator<Item = &'a T>
-{
-    fn clone_box(&self) -> Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>;
-}
-
-struct PrivateIter<'a, T: 'a, P: 'a> {
-    inner: slice::Iter<'a, (T, P)>,
-    last: option::IntoIter<&'a T>,
-}
-
-#[cfg(any(feature = "full", feature = "derive"))]
-pub(crate) fn empty_punctuated_iter<'a, T>() -> Iter<'a, T> {
-    Iter {
-        inner: Box::new(iter::empty()),
-    }
-}
-
-// No Clone bound on T.
-impl<'a, T> Clone for Iter<'a, T> {
-    fn clone(&self) -> Self {
-        Iter {
-            inner: self.inner.clone_box(),
-        }
-    }
-}
-
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.inner.next_back()
-    }
-}
-
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-impl<'a, T, P> Iterator for PrivateIter<'a, T, P> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|pair| &pair.0)
-            .or_else(|| self.last.next())
-    }
-}
-
-impl<'a, T, P> DoubleEndedIterator for PrivateIter<'a, T, P> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.last
-            .next()
-            .or_else(|| self.inner.next_back().map(|pair| &pair.0))
-    }
-}
-
-impl<'a, T, P> ExactSizeIterator for PrivateIter<'a, T, P> {
-    fn len(&self) -> usize {
-        self.inner.len() + self.last.len()
-    }
-}
-
-// No Clone bound on T or P.
-impl<'a, T, P> Clone for PrivateIter<'a, T, P> {
-    fn clone(&self) -> Self {
-        PrivateIter {
-            inner: self.inner.clone(),
-            last: self.last.clone(),
-        }
-    }
-}
-
-impl<'a, T: 'a, I: 'a> IterTrait<'a, T> for I
-where
-    I: DoubleEndedIterator<Item = &'a T> + ExactSizeIterator<Item = &'a T> + Clone,
-{
-    fn clone_box(&self) -> Box<dyn IterTrait<'a, T, Item = &'a T> + 'a> {
-        Box::new(self.clone())
-    }
-}
-
-/// An iterator over mutably borrowed values of type `&mut T`.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub struct IterMut<'a, T: 'a> {
-    inner: Box<dyn IterMutTrait<'a, T, Item = &'a mut T> + 'a>,
-}
-
-trait IterMutTrait<'a, T: 'a>:
-    DoubleEndedIterator<Item = &'a mut T> + ExactSizeIterator<Item = &'a mut T>
-{
-}
-
-struct PrivateIterMut<'a, T: 'a, P: 'a> {
-    inner: slice::IterMut<'a, (T, P)>,
-    last: option::IntoIter<&'a mut T>,
-}
-
-#[cfg(any(feature = "full", feature = "derive"))]
-pub(crate) fn empty_punctuated_iter_mut<'a, T>() -> IterMut<'a, T> {
-    IterMut {
-        inner: Box::new(iter::empty()),
-    }
-}
-
-impl<'a, T> Iterator for IterMut<'a, T> {
-    type Item = &'a mut T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-
-impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.inner.next_back()
-    }
-}
-
-impl<'a, T> ExactSizeIterator for IterMut<'a, T> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-impl<'a, T, P> Iterator for PrivateIterMut<'a, T, P> {
-    type Item = &'a mut T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.inner
-            .next()
-            .map(|pair| &mut pair.0)
-            .or_else(|| self.last.next())
-    }
-}
-
-impl<'a, T, P> DoubleEndedIterator for PrivateIterMut<'a, T, P> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.last
-            .next()
-            .or_else(|| self.inner.next_back().map(|pair| &mut pair.0))
-    }
-}
-
-impl<'a, T, P> ExactSizeIterator for PrivateIterMut<'a, T, P> {
-    fn len(&self) -> usize {
-        self.inner.len() + self.last.len()
-    }
-}
-
-impl<'a, T: 'a, I: 'a> IterMutTrait<'a, T> for I where
-    I: DoubleEndedIterator<Item = &'a mut T> + ExactSizeIterator<Item = &'a mut T>
-{
-}
-
-/// A single syntax tree node of type `T` followed by its trailing punctuation
-/// of type `P` if any.
-///
-/// Refer to the [module documentation] for details about punctuated sequences.
-///
-/// [module documentation]: self
-pub enum Pair<T, P> {
-    Punctuated(T, P),
-    End(T),
-}
-
-impl<T, P> Pair<T, P> {
-    /// Extracts the syntax tree node from this punctuated pair, discarding the
-    /// following punctuation.
-    pub fn into_value(self) -> T {
-        match self {
-            Pair::Punctuated(t, _) | Pair::End(t) => t,
-        }
-    }
-
-    /// Borrows the syntax tree node from this punctuated pair.
-    pub fn value(&self) -> &T {
-        match self {
-            Pair::Punctuated(t, _) | Pair::End(t) => t,
-        }
-    }
-
-    /// Mutably borrows the syntax tree node from this punctuated pair.
-    pub fn value_mut(&mut self) -> &mut T {
-        match self {
-            Pair::Punctuated(t, _) | Pair::End(t) => t,
-        }
-    }
-
-    /// Borrows the punctuation from this punctuated pair, unless this pair is
-    /// the final one and there is no trailing punctuation.
-    pub fn punct(&self) -> Option<&P> {
-        match self {
-            Pair::Punctuated(_, d) => Some(d),
-            Pair::End(_) => None,
-        }
-    }
-
-    /// Creates a punctuated pair out of a syntax tree node and an optional
-    /// following punctuation.
-    pub fn new(t: T, d: Option<P>) -> Self {
-        match d {
-            Some(d) => Pair::Punctuated(t, d),
-            None => Pair::End(t),
-        }
-    }
-
-    /// Produces this punctuated pair as a tuple of syntax tree node and
-    /// optional following punctuation.
-    pub fn into_tuple(self) -> (T, Option<P>) {
-        match self {
-            Pair::Punctuated(t, d) => (t, Some(d)),
-            Pair::End(t) => (t, None),
-        }
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl<T, P> Clone for Pair<T, P>
-where
-    T: Clone,
-    P: Clone,
-{
-    fn clone(&self) -> Self {
-        match self {
-            Pair::Punctuated(t, p) => Pair::Punctuated(t.clone(), p.clone()),
-            Pair::End(t) => Pair::End(t.clone()),
-        }
-    }
-}
-
-impl<T, P> Index<usize> for Punctuated<T, P> {
-    type Output = T;
-
-    fn index(&self, index: usize) -> &Self::Output {
-        if index == self.len() - 1 {
-            match &self.last {
-                Some(t) => t,
-                None => &self.inner[index].0,
-            }
-        } else {
-            &self.inner[index].0
-        }
-    }
-}
-
-impl<T, P> IndexMut<usize> for Punctuated<T, P> {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
-        if index == self.len() - 1 {
-            match &mut self.last {
-                Some(t) => t,
-                None => &mut self.inner[index].0,
-            }
-        } else {
-            &mut self.inner[index].0
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl<T, P> ToTokens for Punctuated<T, P>
-    where
-        T: ToTokens,
-        P: ToTokens,
-    {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.pairs());
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl<T, P> ToTokens for Pair<T, P>
-    where
-        T: ToTokens,
-        P: ToTokens,
-    {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                Pair::Punctuated(a, b) => {
-                    a.to_tokens(tokens);
-                    b.to_tokens(tokens);
-                }
-                Pair::End(a) => a.to_tokens(tokens),
-            }
-        }
-    }
-}
diff --git a/vendor/syn/src/reserved.rs b/vendor/syn/src/reserved.rs
deleted file mode 100644
index abfdf43a..00000000
--- a/vendor/syn/src/reserved.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Type for a syntax tree node that is reserved for future use.
-//
-// For example ExprReference contains a field `raw` of type Reserved. If `&raw
-// place` syntax becomes a thing as per https://github.com/rust-lang/rfcs/pull/2582,
-// we can backward compatibly change `raw`'s type to Option<Token![raw]> without
-// the possibility of breaking any code.
-
-use proc_macro2::Span;
-use std::marker::PhantomData;
-
-#[cfg(feature = "extra-traits")]
-use std::fmt::{self, Debug};
-
-ast_struct! {
-    pub struct Reserved {
-        _private: PhantomData<Span>,
-    }
-}
-
-impl Default for Reserved {
-    fn default() -> Self {
-        Reserved {
-            _private: PhantomData,
-        }
-    }
-}
-
-#[cfg(feature = "clone-impls")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Reserved {
-    fn clone(&self) -> Self {
-        Reserved {
-            _private: self._private,
-        }
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-impl Debug for Reserved {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.debug_struct("Reserved").finish()
-    }
-}
diff --git a/vendor/syn/src/sealed.rs b/vendor/syn/src/sealed.rs
deleted file mode 100644
index 0b11bc99..00000000
--- a/vendor/syn/src/sealed.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#[cfg(feature = "parsing")]
-pub mod lookahead {
-    pub trait Sealed: Copy {}
-}
diff --git a/vendor/syn/src/span.rs b/vendor/syn/src/span.rs
deleted file mode 100644
index 27a7fe84..00000000
--- a/vendor/syn/src/span.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use proc_macro2::Span;
-
-pub trait IntoSpans<S> {
-    fn into_spans(self) -> S;
-}
-
-impl IntoSpans<[Span; 1]> for Span {
-    fn into_spans(self) -> [Span; 1] {
-        [self]
-    }
-}
-
-impl IntoSpans<[Span; 2]> for Span {
-    fn into_spans(self) -> [Span; 2] {
-        [self, self]
-    }
-}
-
-impl IntoSpans<[Span; 3]> for Span {
-    fn into_spans(self) -> [Span; 3] {
-        [self, self, self]
-    }
-}
-
-impl IntoSpans<[Span; 1]> for [Span; 1] {
-    fn into_spans(self) -> [Span; 1] {
-        self
-    }
-}
-
-impl IntoSpans<[Span; 2]> for [Span; 2] {
-    fn into_spans(self) -> [Span; 2] {
-        self
-    }
-}
-
-impl IntoSpans<[Span; 3]> for [Span; 3] {
-    fn into_spans(self) -> [Span; 3] {
-        self
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub trait FromSpans: Sized {
-    fn from_spans(spans: &[Span]) -> Self;
-}
-
-#[cfg(feature = "parsing")]
-impl FromSpans for [Span; 1] {
-    fn from_spans(spans: &[Span]) -> Self {
-        [spans[0]]
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl FromSpans for [Span; 2] {
-    fn from_spans(spans: &[Span]) -> Self {
-        [spans[0], spans[1]]
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl FromSpans for [Span; 3] {
-    fn from_spans(spans: &[Span]) -> Self {
-        [spans[0], spans[1], spans[2]]
-    }
-}
diff --git a/vendor/syn/src/spanned.rs b/vendor/syn/src/spanned.rs
deleted file mode 100644
index d51ffb3f..00000000
--- a/vendor/syn/src/spanned.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-//! A trait that can provide the `Span` of the complete contents of a syntax
-//! tree node.
-//!
-//! *This module is available only if Syn is built with both the `"parsing"` and
-//! `"printing"` features.*
-//!
-//! <br>
-//!
-//! # Example
-//!
-//! Suppose in a procedural macro we have a [`Type`] that we want to assert
-//! implements the [`Sync`] trait. Maybe this is the type of one of the fields
-//! of a struct for which we are deriving a trait implementation, and we need to
-//! be able to pass a reference to one of those fields across threads.
-//!
-//! [`Type`]: crate::Type
-//! [`Sync`]: std::marker::Sync
-//!
-//! If the field type does *not* implement `Sync` as required, we want the
-//! compiler to report an error pointing out exactly which type it was.
-//!
-//! The following macro code takes a variable `ty` of type `Type` and produces a
-//! static assertion that `Sync` is implemented for that type.
-//!
-//! ```
-//! # extern crate proc_macro;
-//! #
-//! use proc_macro::TokenStream;
-//! use proc_macro2::Span;
-//! use quote::quote_spanned;
-//! use syn::Type;
-//! use syn::spanned::Spanned;
-//!
-//! # const IGNORE_TOKENS: &str = stringify! {
-//! #[proc_macro_derive(MyMacro)]
-//! # };
-//! pub fn my_macro(input: TokenStream) -> TokenStream {
-//!     # let ty = get_a_type();
-//!     /* ... */
-//!
-//!     let assert_sync = quote_spanned! {ty.span()=>
-//!         struct _AssertSync where #ty: Sync;
-//!     };
-//!
-//!     /* ... */
-//!     # input
-//! }
-//! #
-//! # fn get_a_type() -> Type {
-//! #     unimplemented!()
-//! # }
-//! ```
-//!
-//! By inserting this `assert_sync` fragment into the output code generated by
-//! our macro, the user's code will fail to compile if `ty` does not implement
-//! `Sync`. The errors they would see look like the following.
-//!
-//! ```text
-//! error[E0277]: the trait bound `*const i32: std::marker::Sync` is not satisfied
-//!   --> src/main.rs:10:21
-//!    |
-//! 10 |     bad_field: *const i32,
-//!    |                ^^^^^^^^^^ `*const i32` cannot be shared between threads safely
-//! ```
-//!
-//! In this technique, using the `Type`'s span for the error message makes the
-//! error appear in the correct place underlining the right type.
-//!
-//! <br>
-//!
-//! # Limitations
-//!
-//! The underlying [`proc_macro::Span::join`] method is nightly-only. When
-//! called from within a procedural macro in a nightly compiler, `Spanned` will
-//! use `join` to produce the intended span. When not using a nightly compiler,
-//! only the span of the *first token* of the syntax tree node is returned.
-//!
-//! In the common case of wanting to use the joined span as the span of a
-//! `syn::Error`, consider instead using [`syn::Error::new_spanned`] which is
-//! able to span the error correctly under the complete syntax tree node without
-//! needing the unstable `join`.
-//!
-//! [`syn::Error::new_spanned`]: crate::Error::new_spanned
-
-use proc_macro2::Span;
-use quote::spanned::Spanned as ToTokens;
-
-/// A trait that can provide the `Span` of the complete contents of a syntax
-/// tree node.
-///
-/// This trait is automatically implemented for all types that implement
-/// [`ToTokens`] from the `quote` crate, as well as for `Span` itself.
-///
-/// [`ToTokens`]: quote::ToTokens
-///
-/// See the [module documentation] for an example.
-///
-/// [module documentation]: self
-///
-/// *This trait is available only if Syn is built with both the `"parsing"` and
-/// `"printing"` features.*
-pub trait Spanned {
-    /// Returns a `Span` covering the complete contents of this syntax tree
-    /// node, or [`Span::call_site()`] if this node is empty.
-    ///
-    /// [`Span::call_site()`]: proc_macro2::Span::call_site
-    fn span(&self) -> Span;
-}
-
-impl<T: ?Sized + ToTokens> Spanned for T {
-    fn span(&self) -> Span {
-        self.__span()
-    }
-}
diff --git a/vendor/syn/src/stmt.rs b/vendor/syn/src/stmt.rs
deleted file mode 100644
index ba2b22e5..00000000
--- a/vendor/syn/src/stmt.rs
+++ /dev/null
@@ -1,322 +0,0 @@
-use super::*;
-
-ast_struct! {
-    /// A braced block containing Rust statements.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Block {
-        pub brace_token: token::Brace,
-        /// Statements in a block
-        pub stmts: Vec<Stmt>,
-    }
-}
-
-ast_enum! {
-    /// A statement, usually ending in a semicolon.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum Stmt {
-        /// A local (let) binding.
-        Local(Local),
-
-        /// An item definition.
-        Item(Item),
-
-        /// Expr without trailing semicolon.
-        Expr(Expr),
-
-        /// Expression with trailing semicolon.
-        Semi(Expr, Token![;]),
-    }
-}
-
-ast_struct! {
-    /// A local `let` binding: `let x: u64 = s.parse()?`.
-    ///
-    /// *This type is available only if Syn is built with the `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Local {
-        pub attrs: Vec<Attribute>,
-        pub let_token: Token![let],
-        pub pat: Pat,
-        pub init: Option<(Token![=], Box<Expr>)>,
-        pub semi_token: Token![;],
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::parse::discouraged::Speculative;
-    use crate::parse::{Parse, ParseStream, Result};
-    use proc_macro2::TokenStream;
-
-    impl Block {
-        /// Parse the body of a block as zero or more statements, possibly
-        /// including one trailing expression.
-        ///
-        /// *This function is available only if Syn is built with the `"parsing"`
-        /// feature.*
-        ///
-        /// # Example
-        ///
-        /// ```
-        /// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};
-        /// use syn::parse::{Parse, ParseStream};
-        ///
-        /// // Parse a function with no generics or parameter list.
-        /// //
-        /// //     fn playground {
-        /// //         let mut x = 1;
-        /// //         x += 1;
-        /// //         println!("{}", x);
-        /// //     }
-        /// struct MiniFunction {
-        ///     attrs: Vec<Attribute>,
-        ///     fn_token: Token![fn],
-        ///     name: Ident,
-        ///     brace_token: token::Brace,
-        ///     stmts: Vec<Stmt>,
-        /// }
-        ///
-        /// impl Parse for MiniFunction {
-        ///     fn parse(input: ParseStream) -> Result<Self> {
-        ///         let outer_attrs = input.call(Attribute::parse_outer)?;
-        ///         let fn_token: Token![fn] = input.parse()?;
-        ///         let name: Ident = input.parse()?;
-        ///
-        ///         let content;
-        ///         let brace_token = braced!(content in input);
-        ///         let inner_attrs = content.call(Attribute::parse_inner)?;
-        ///         let stmts = content.call(Block::parse_within)?;
-        ///
-        ///         Ok(MiniFunction {
-        ///             attrs: {
-        ///                 let mut attrs = outer_attrs;
-        ///                 attrs.extend(inner_attrs);
-        ///                 attrs
-        ///             },
-        ///             fn_token,
-        ///             name,
-        ///             brace_token,
-        ///             stmts,
-        ///         })
-        ///     }
-        /// }
-        /// ```
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn parse_within(input: ParseStream) -> Result<Vec<Stmt>> {
-            let mut stmts = Vec::new();
-            loop {
-                while let Some(semi) = input.parse::<Option<Token![;]>>()? {
-                    stmts.push(Stmt::Semi(Expr::Verbatim(TokenStream::new()), semi));
-                }
-                if input.is_empty() {
-                    break;
-                }
-                let s = parse_stmt(input, true)?;
-                let requires_semicolon = if let Stmt::Expr(s) = &s {
-                    expr::requires_terminator(s)
-                } else {
-                    false
-                };
-                stmts.push(s);
-                if input.is_empty() {
-                    break;
-                } else if requires_semicolon {
-                    return Err(input.error("unexpected token"));
-                }
-            }
-            Ok(stmts)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Block {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(Block {
-                brace_token: braced!(content in input),
-                stmts: content.call(Block::parse_within)?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Stmt {
-        fn parse(input: ParseStream) -> Result<Self> {
-            parse_stmt(input, false)
-        }
-    }
-
-    fn parse_stmt(input: ParseStream, allow_nosemi: bool) -> Result<Stmt> {
-        let mut attrs = input.call(Attribute::parse_outer)?;
-
-        // brace-style macros; paren and bracket macros get parsed as
-        // expression statements.
-        let ahead = input.fork();
-        if let Ok(path) = ahead.call(Path::parse_mod_style) {
-            if ahead.peek(Token![!]) && (ahead.peek2(token::Brace) || ahead.peek2(Ident)) {
-                input.advance_to(&ahead);
-                return stmt_mac(input, attrs, path);
-            }
-        }
-
-        if input.peek(Token![let]) {
-            stmt_local(input, attrs).map(Stmt::Local)
-        } else if input.peek(Token![pub])
-            || input.peek(Token![crate]) && !input.peek2(Token![::])
-            || input.peek(Token![extern])
-            || input.peek(Token![use])
-            || input.peek(Token![static]) && (input.peek2(Token![mut]) || input.peek2(Ident))
-            || input.peek(Token![const]) && !input.peek2(token::Brace)
-            || input.peek(Token![unsafe]) && !input.peek2(token::Brace)
-            || input.peek(Token![async])
-                && (input.peek2(Token![unsafe])
-                    || input.peek2(Token![extern])
-                    || input.peek2(Token![fn]))
-            || input.peek(Token![fn])
-            || input.peek(Token![mod])
-            || input.peek(Token![type])
-            || input.peek(item::parsing::existential) && input.peek2(Token![type])
-            || input.peek(Token![struct])
-            || input.peek(Token![enum])
-            || input.peek(Token![union]) && input.peek2(Ident)
-            || input.peek(Token![auto]) && input.peek2(Token![trait])
-            || input.peek(Token![trait])
-            || input.peek(Token![default])
-                && (input.peek2(Token![unsafe]) || input.peek2(Token![impl]))
-            || input.peek(Token![impl])
-            || input.peek(Token![macro])
-        {
-            let mut item: Item = input.parse()?;
-            attrs.extend(item.replace_attrs(Vec::new()));
-            item.replace_attrs(attrs);
-            Ok(Stmt::Item(item))
-        } else {
-            stmt_expr(input, allow_nosemi, attrs)
-        }
-    }
-
-    fn stmt_mac(input: ParseStream, attrs: Vec<Attribute>, path: Path) -> Result<Stmt> {
-        let bang_token: Token![!] = input.parse()?;
-        let ident: Option<Ident> = input.parse()?;
-        let (delimiter, tokens) = mac::parse_delimiter(input)?;
-        let semi_token: Option<Token![;]> = input.parse()?;
-
-        Ok(Stmt::Item(Item::Macro(ItemMacro {
-            attrs,
-            ident,
-            mac: Macro {
-                path,
-                bang_token,
-                delimiter,
-                tokens,
-            },
-            semi_token,
-        })))
-    }
-
-    fn stmt_local(input: ParseStream, attrs: Vec<Attribute>) -> Result<Local> {
-        Ok(Local {
-            attrs,
-            let_token: input.parse()?,
-            pat: {
-                let mut pat: Pat = pat::parsing::multi_pat_with_leading_vert(input)?;
-                if input.peek(Token![:]) {
-                    let colon_token: Token![:] = input.parse()?;
-                    let ty: Type = input.parse()?;
-                    pat = Pat::Type(PatType {
-                        attrs: Vec::new(),
-                        pat: Box::new(pat),
-                        colon_token,
-                        ty: Box::new(ty),
-                    });
-                }
-                pat
-            },
-            init: {
-                if input.peek(Token![=]) {
-                    let eq_token: Token![=] = input.parse()?;
-                    let init: Expr = input.parse()?;
-                    Some((eq_token, Box::new(init)))
-                } else {
-                    None
-                }
-            },
-            semi_token: input.parse()?,
-        })
-    }
-
-    fn stmt_expr(
-        input: ParseStream,
-        allow_nosemi: bool,
-        mut attrs: Vec<Attribute>,
-    ) -> Result<Stmt> {
-        let mut e = expr::parsing::expr_early(input)?;
-
-        let mut attr_target = &mut e;
-        while let Expr::Binary(e) = attr_target {
-            attr_target = &mut e.left;
-        }
-        attrs.extend(attr_target.replace_attrs(Vec::new()));
-        attr_target.replace_attrs(attrs);
-
-        if input.peek(Token![;]) {
-            return Ok(Stmt::Semi(e, input.parse()?));
-        }
-
-        if allow_nosemi || !expr::requires_terminator(&e) {
-            Ok(Stmt::Expr(e))
-        } else {
-            Err(input.error("expected semicolon"))
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Block {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(&self.stmts);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Stmt {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                Stmt::Local(local) => local.to_tokens(tokens),
-                Stmt::Item(item) => item.to_tokens(tokens),
-                Stmt::Expr(expr) => expr.to_tokens(tokens),
-                Stmt::Semi(expr, semi) => {
-                    expr.to_tokens(tokens);
-                    semi.to_tokens(tokens);
-                }
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Local {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            expr::printing::outer_attrs_to_tokens(&self.attrs, tokens);
-            self.let_token.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-            if let Some((eq_token, init)) = &self.init {
-                eq_token.to_tokens(tokens);
-                init.to_tokens(tokens);
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/thread.rs b/vendor/syn/src/thread.rs
deleted file mode 100644
index 9e5d8ad8..00000000
--- a/vendor/syn/src/thread.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use std::fmt::{self, Debug};
-use std::thread::{self, ThreadId};
-
-/// ThreadBound is a Sync-maker and Send-maker that allows accessing a value
-/// of type T only from the original thread on which the ThreadBound was
-/// constructed.
-pub struct ThreadBound<T> {
-    value: T,
-    thread_id: ThreadId,
-}
-
-unsafe impl<T> Sync for ThreadBound<T> {}
-
-// Send bound requires Copy, as otherwise Drop could run in the wrong place.
-unsafe impl<T: Copy> Send for ThreadBound<T> {}
-
-impl<T> ThreadBound<T> {
-    pub fn new(value: T) -> Self {
-        ThreadBound {
-            value,
-            thread_id: thread::current().id(),
-        }
-    }
-
-    pub fn get(&self) -> Option<&T> {
-        if thread::current().id() == self.thread_id {
-            Some(&self.value)
-        } else {
-            None
-        }
-    }
-}
-
-impl<T: Debug> Debug for ThreadBound<T> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self.get() {
-            Some(value) => Debug::fmt(value, formatter),
-            None => formatter.write_str("unknown"),
-        }
-    }
-}
diff --git a/vendor/syn/src/token.rs b/vendor/syn/src/token.rs
deleted file mode 100644
index 2208b07d..00000000
--- a/vendor/syn/src/token.rs
+++ /dev/null
@@ -1,1013 +0,0 @@
-//! Tokens representing Rust punctuation, keywords, and delimiters.
-//!
-//! The type names in this module can be difficult to keep straight, so we
-//! prefer to use the [`Token!`] macro instead. This is a type-macro that
-//! expands to the token type of the given token.
-//!
-//! [`Token!`]: crate::Token
-//!
-//! # Example
-//!
-//! The [`ItemStatic`] syntax tree node is defined like this.
-//!
-//! [`ItemStatic`]: crate::ItemStatic
-//!
-//! ```
-//! # use syn::{Attribute, Expr, Ident, Token, Type, Visibility};
-//! #
-//! pub struct ItemStatic {
-//!     pub attrs: Vec<Attribute>,
-//!     pub vis: Visibility,
-//!     pub static_token: Token![static],
-//!     pub mutability: Option<Token![mut]>,
-//!     pub ident: Ident,
-//!     pub colon_token: Token![:],
-//!     pub ty: Box<Type>,
-//!     pub eq_token: Token![=],
-//!     pub expr: Box<Expr>,
-//!     pub semi_token: Token![;],
-//! }
-//! ```
-//!
-//! # Parsing
-//!
-//! Keywords and punctuation can be parsed through the [`ParseStream::parse`]
-//! method. Delimiter tokens are parsed using the [`parenthesized!`],
-//! [`bracketed!`] and [`braced!`] macros.
-//!
-//! [`ParseStream::parse`]: crate::parse::ParseBuffer::parse()
-//! [`parenthesized!`]: crate::parenthesized!
-//! [`bracketed!`]: crate::bracketed!
-//! [`braced!`]: crate::braced!
-//!
-//! ```
-//! use syn::{Attribute, Result};
-//! use syn::parse::{Parse, ParseStream};
-//! #
-//! # enum ItemStatic {}
-//!
-//! // Parse the ItemStatic struct shown above.
-//! impl Parse for ItemStatic {
-//!     fn parse(input: ParseStream) -> Result<Self> {
-//!         # use syn::ItemStatic;
-//!         # fn parse(input: ParseStream) -> Result<ItemStatic> {
-//!         Ok(ItemStatic {
-//!             attrs: input.call(Attribute::parse_outer)?,
-//!             vis: input.parse()?,
-//!             static_token: input.parse()?,
-//!             mutability: input.parse()?,
-//!             ident: input.parse()?,
-//!             colon_token: input.parse()?,
-//!             ty: input.parse()?,
-//!             eq_token: input.parse()?,
-//!             expr: input.parse()?,
-//!             semi_token: input.parse()?,
-//!         })
-//!         # }
-//!         # unimplemented!()
-//!     }
-//! }
-//! ```
-//!
-//! # Other operations
-//!
-//! Every keyword and punctuation token supports the following operations.
-//!
-//! - [Peeking] — `input.peek(Token![...])`
-//!
-//! - [Parsing] — `input.parse::<Token![...]>()?`
-//!
-//! - [Printing] — `quote!( ... #the_token ... )`
-//!
-//! - Construction from a [`Span`] — `let the_token = Token![...](sp)`
-//!
-//! - Field access to its span — `let sp = the_token.span`
-//!
-//! [Peeking]: crate::parse::ParseBuffer::peek()
-//! [Parsing]: crate::parse::ParseBuffer::parse()
-//! [Printing]: https://docs.rs/quote/1.0/quote/trait.ToTokens.html
-//! [`Span`]: https://docs.rs/proc-macro2/1.0/proc_macro2/struct.Span.html
-
-use self::private::WithSpan;
-#[cfg(feature = "parsing")]
-use crate::buffer::Cursor;
-#[cfg(feature = "parsing")]
-use crate::error::Result;
-#[cfg(feature = "parsing")]
-use crate::lifetime::Lifetime;
-#[cfg(feature = "parsing")]
-use crate::lit::{Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr};
-#[cfg(feature = "parsing")]
-use crate::lookahead;
-#[cfg(feature = "parsing")]
-use crate::parse::{Parse, ParseStream};
-use crate::span::IntoSpans;
-#[cfg(any(feature = "parsing", feature = "printing"))]
-use proc_macro2::Ident;
-use proc_macro2::Span;
-#[cfg(feature = "printing")]
-use proc_macro2::TokenStream;
-#[cfg(feature = "parsing")]
-use proc_macro2::{Delimiter, Literal, Punct, TokenTree};
-#[cfg(feature = "printing")]
-use quote::{ToTokens, TokenStreamExt};
-#[cfg(feature = "extra-traits")]
-use std::cmp;
-#[cfg(feature = "extra-traits")]
-use std::fmt::{self, Debug};
-#[cfg(feature = "extra-traits")]
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
-
-/// Marker trait for types that represent single tokens.
-///
-/// This trait is sealed and cannot be implemented for types outside of Syn.
-#[cfg(feature = "parsing")]
-pub trait Token: private::Sealed {
-    // Not public API.
-    #[doc(hidden)]
-    fn peek(cursor: Cursor) -> bool;
-
-    // Not public API.
-    #[doc(hidden)]
-    fn display() -> &'static str;
-}
-
-mod private {
-    use proc_macro2::Span;
-
-    #[cfg(feature = "parsing")]
-    pub trait Sealed {}
-
-    /// Support writing `token.span` rather than `token.spans[0]` on tokens that
-    /// hold a single span.
-    #[repr(C)]
-    pub struct WithSpan {
-        pub span: Span,
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl private::Sealed for Ident {}
-
-#[cfg(feature = "parsing")]
-fn peek_impl(cursor: Cursor, peek: fn(ParseStream) -> bool) -> bool {
-    use crate::parse::Unexpected;
-    use std::cell::Cell;
-    use std::rc::Rc;
-
-    let scope = Span::call_site();
-    let unexpected = Rc::new(Cell::new(Unexpected::None));
-    let buffer = crate::parse::new_parse_buffer(scope, cursor, unexpected);
-    peek(&buffer)
-}
-
-macro_rules! impl_token {
-    ($display:tt $name:ty) => {
-        #[cfg(feature = "parsing")]
-        impl Token for $name {
-            fn peek(cursor: Cursor) -> bool {
-                fn peek(input: ParseStream) -> bool {
-                    <$name as Parse>::parse(input).is_ok()
-                }
-                peek_impl(cursor, peek)
-            }
-
-            fn display() -> &'static str {
-                $display
-            }
-        }
-
-        #[cfg(feature = "parsing")]
-        impl private::Sealed for $name {}
-    };
-}
-
-impl_token!("lifetime" Lifetime);
-impl_token!("literal" Lit);
-impl_token!("string literal" LitStr);
-impl_token!("byte string literal" LitByteStr);
-impl_token!("byte literal" LitByte);
-impl_token!("character literal" LitChar);
-impl_token!("integer literal" LitInt);
-impl_token!("floating point literal" LitFloat);
-impl_token!("boolean literal" LitBool);
-impl_token!("group token" proc_macro2::Group);
-
-macro_rules! impl_low_level_token {
-    ($display:tt $ty:ident $get:ident) => {
-        #[cfg(feature = "parsing")]
-        impl Token for $ty {
-            fn peek(cursor: Cursor) -> bool {
-                cursor.$get().is_some()
-            }
-
-            fn display() -> &'static str {
-                $display
-            }
-        }
-
-        #[cfg(feature = "parsing")]
-        impl private::Sealed for $ty {}
-    };
-}
-
-impl_low_level_token!("punctuation token" Punct punct);
-impl_low_level_token!("literal" Literal literal);
-impl_low_level_token!("token" TokenTree token_tree);
-
-// Not public API.
-#[doc(hidden)]
-#[cfg(feature = "parsing")]
-pub trait CustomToken {
-    fn peek(cursor: Cursor) -> bool;
-    fn display() -> &'static str;
-}
-
-#[cfg(feature = "parsing")]
-impl<T: CustomToken> private::Sealed for T {}
-
-#[cfg(feature = "parsing")]
-impl<T: CustomToken> Token for T {
-    fn peek(cursor: Cursor) -> bool {
-        <Self as CustomToken>::peek(cursor)
-    }
-
-    fn display() -> &'static str {
-        <Self as CustomToken>::display()
-    }
-}
-
-macro_rules! define_keywords {
-    ($($token:tt pub struct $name:ident #[$doc:meta])*) => {
-        $(
-            #[$doc]
-            ///
-            /// Don't try to remember the name of this type &mdash; use the
-            /// [`Token!`] macro instead.
-            ///
-            /// [`Token!`]: crate::token
-            pub struct $name {
-                pub span: Span,
-            }
-
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name {
-                $name {
-                    span: span.into_spans()[0],
-                }
-            }
-
-            impl std::default::Default for $name {
-                fn default() -> Self {
-                    $name {
-                        span: Span::call_site(),
-                    }
-                }
-            }
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Copy for $name {}
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Clone for $name {
-                fn clone(&self) -> Self {
-                    *self
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Debug for $name {
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    f.write_str(stringify!($name))
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl cmp::Eq for $name {}
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl PartialEq for $name {
-                fn eq(&self, _other: &$name) -> bool {
-                    true
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Hash for $name {
-                fn hash<H: Hasher>(&self, _state: &mut H) {}
-            }
-
-            #[cfg(feature = "printing")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-            impl ToTokens for $name {
-                fn to_tokens(&self, tokens: &mut TokenStream) {
-                    printing::keyword($token, self.span, tokens);
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-            impl Parse for $name {
-                fn parse(input: ParseStream) -> Result<Self> {
-                    Ok($name {
-                        span: parsing::keyword(input, $token)?,
-                    })
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            impl Token for $name {
-                fn peek(cursor: Cursor) -> bool {
-                    parsing::peek_keyword(cursor, $token)
-                }
-
-                fn display() -> &'static str {
-                    concat!("`", $token, "`")
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            impl private::Sealed for $name {}
-        )*
-    };
-}
-
-macro_rules! impl_deref_if_len_is_1 {
-    ($name:ident/1) => {
-        impl Deref for $name {
-            type Target = WithSpan;
-
-            fn deref(&self) -> &Self::Target {
-                unsafe { &*(self as *const Self as *const WithSpan) }
-            }
-        }
-
-        impl DerefMut for $name {
-            fn deref_mut(&mut self) -> &mut Self::Target {
-                unsafe { &mut *(self as *mut Self as *mut WithSpan) }
-            }
-        }
-    };
-
-    ($name:ident/$len:tt) => {};
-}
-
-macro_rules! define_punctuation_structs {
-    ($($token:tt pub struct $name:ident/$len:tt #[$doc:meta])*) => {
-        $(
-            #[repr(C)]
-            #[$doc]
-            ///
-            /// Don't try to remember the name of this type &mdash; use the
-            /// [`Token!`] macro instead.
-            ///
-            /// [`Token!`]: crate::token
-            pub struct $name {
-                pub spans: [Span; $len],
-            }
-
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            pub fn $name<S: IntoSpans<[Span; $len]>>(spans: S) -> $name {
-                $name {
-                    spans: spans.into_spans(),
-                }
-            }
-
-            impl std::default::Default for $name {
-                fn default() -> Self {
-                    $name {
-                        spans: [Span::call_site(); $len],
-                    }
-                }
-            }
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Copy for $name {}
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Clone for $name {
-                fn clone(&self) -> Self {
-                    *self
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Debug for $name {
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    f.write_str(stringify!($name))
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl cmp::Eq for $name {}
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl PartialEq for $name {
-                fn eq(&self, _other: &$name) -> bool {
-                    true
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Hash for $name {
-                fn hash<H: Hasher>(&self, _state: &mut H) {}
-            }
-
-            impl_deref_if_len_is_1!($name/$len);
-        )*
-    };
-}
-
-macro_rules! define_punctuation {
-    ($($token:tt pub struct $name:ident/$len:tt #[$doc:meta])*) => {
-        $(
-            define_punctuation_structs! {
-                $token pub struct $name/$len #[$doc]
-            }
-
-            #[cfg(feature = "printing")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-            impl ToTokens for $name {
-                fn to_tokens(&self, tokens: &mut TokenStream) {
-                    printing::punct($token, &self.spans, tokens);
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-            impl Parse for $name {
-                fn parse(input: ParseStream) -> Result<Self> {
-                    Ok($name {
-                        spans: parsing::punct(input, $token)?,
-                    })
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            impl Token for $name {
-                fn peek(cursor: Cursor) -> bool {
-                    parsing::peek_punct(cursor, $token)
-                }
-
-                fn display() -> &'static str {
-                    concat!("`", $token, "`")
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            impl private::Sealed for $name {}
-        )*
-    };
-}
-
-macro_rules! define_delimiters {
-    ($($token:tt pub struct $name:ident #[$doc:meta])*) => {
-        $(
-            #[$doc]
-            pub struct $name {
-                pub span: Span,
-            }
-
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name {
-                $name {
-                    span: span.into_spans()[0],
-                }
-            }
-
-            impl std::default::Default for $name {
-                fn default() -> Self {
-                    $name {
-                        span: Span::call_site(),
-                    }
-                }
-            }
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Copy for $name {}
-
-            #[cfg(feature = "clone-impls")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-            impl Clone for $name {
-                fn clone(&self) -> Self {
-                    *self
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Debug for $name {
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    f.write_str(stringify!($name))
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl cmp::Eq for $name {}
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl PartialEq for $name {
-                fn eq(&self, _other: &$name) -> bool {
-                    true
-                }
-            }
-
-            #[cfg(feature = "extra-traits")]
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
-            impl Hash for $name {
-                fn hash<H: Hasher>(&self, _state: &mut H) {}
-            }
-
-            impl $name {
-                #[cfg(feature = "printing")]
-                pub fn surround<F>(&self, tokens: &mut TokenStream, f: F)
-                where
-                    F: FnOnce(&mut TokenStream),
-                {
-                    printing::delim($token, self.span, tokens, f);
-                }
-            }
-
-            #[cfg(feature = "parsing")]
-            impl private::Sealed for $name {}
-        )*
-    };
-}
-
-define_punctuation_structs! {
-    "_" pub struct Underscore/1 /// `_`
-}
-
-#[cfg(feature = "printing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-impl ToTokens for Underscore {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(Ident::new("_", self.span));
-    }
-}
-
-#[cfg(feature = "parsing")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-impl Parse for Underscore {
-    fn parse(input: ParseStream) -> Result<Self> {
-        input.step(|cursor| {
-            if let Some((ident, rest)) = cursor.ident() {
-                if ident == "_" {
-                    return Ok((Underscore(ident.span()), rest));
-                }
-            }
-            if let Some((punct, rest)) = cursor.punct() {
-                if punct.as_char() == '_' {
-                    return Ok((Underscore(punct.span()), rest));
-                }
-            }
-            Err(cursor.error("expected `_`"))
-        })
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl Token for Underscore {
-    fn peek(cursor: Cursor) -> bool {
-        if let Some((ident, _rest)) = cursor.ident() {
-            return ident == "_";
-        }
-        if let Some((punct, _rest)) = cursor.punct() {
-            return punct.as_char() == '_';
-        }
-        false
-    }
-
-    fn display() -> &'static str {
-        "`_`"
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl private::Sealed for Underscore {}
-
-#[cfg(feature = "parsing")]
-impl Token for Paren {
-    fn peek(cursor: Cursor) -> bool {
-        lookahead::is_delimiter(cursor, Delimiter::Parenthesis)
-    }
-
-    fn display() -> &'static str {
-        "parentheses"
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl Token for Brace {
-    fn peek(cursor: Cursor) -> bool {
-        lookahead::is_delimiter(cursor, Delimiter::Brace)
-    }
-
-    fn display() -> &'static str {
-        "curly braces"
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl Token for Bracket {
-    fn peek(cursor: Cursor) -> bool {
-        lookahead::is_delimiter(cursor, Delimiter::Bracket)
-    }
-
-    fn display() -> &'static str {
-        "square brackets"
-    }
-}
-
-#[cfg(feature = "parsing")]
-impl Token for Group {
-    fn peek(cursor: Cursor) -> bool {
-        lookahead::is_delimiter(cursor, Delimiter::None)
-    }
-
-    fn display() -> &'static str {
-        "invisible group"
-    }
-}
-
-define_keywords! {
-    "abstract"    pub struct Abstract     /// `abstract`
-    "as"          pub struct As           /// `as`
-    "async"       pub struct Async        /// `async`
-    "auto"        pub struct Auto         /// `auto`
-    "await"       pub struct Await        /// `await`
-    "become"      pub struct Become       /// `become`
-    "box"         pub struct Box          /// `box`
-    "break"       pub struct Break        /// `break`
-    "const"       pub struct Const        /// `const`
-    "continue"    pub struct Continue     /// `continue`
-    "crate"       pub struct Crate        /// `crate`
-    "default"     pub struct Default      /// `default`
-    "do"          pub struct Do           /// `do`
-    "dyn"         pub struct Dyn          /// `dyn`
-    "else"        pub struct Else         /// `else`
-    "enum"        pub struct Enum         /// `enum`
-    "extern"      pub struct Extern       /// `extern`
-    "final"       pub struct Final        /// `final`
-    "fn"          pub struct Fn           /// `fn`
-    "for"         pub struct For          /// `for`
-    "if"          pub struct If           /// `if`
-    "impl"        pub struct Impl         /// `impl`
-    "in"          pub struct In           /// `in`
-    "let"         pub struct Let          /// `let`
-    "loop"        pub struct Loop         /// `loop`
-    "macro"       pub struct Macro        /// `macro`
-    "match"       pub struct Match        /// `match`
-    "mod"         pub struct Mod          /// `mod`
-    "move"        pub struct Move         /// `move`
-    "mut"         pub struct Mut          /// `mut`
-    "override"    pub struct Override     /// `override`
-    "priv"        pub struct Priv         /// `priv`
-    "pub"         pub struct Pub          /// `pub`
-    "ref"         pub struct Ref          /// `ref`
-    "return"      pub struct Return       /// `return`
-    "Self"        pub struct SelfType     /// `Self`
-    "self"        pub struct SelfValue    /// `self`
-    "static"      pub struct Static       /// `static`
-    "struct"      pub struct Struct       /// `struct`
-    "super"       pub struct Super        /// `super`
-    "trait"       pub struct Trait        /// `trait`
-    "try"         pub struct Try          /// `try`
-    "type"        pub struct Type         /// `type`
-    "typeof"      pub struct Typeof       /// `typeof`
-    "union"       pub struct Union        /// `union`
-    "unsafe"      pub struct Unsafe       /// `unsafe`
-    "unsized"     pub struct Unsized      /// `unsized`
-    "use"         pub struct Use          /// `use`
-    "virtual"     pub struct Virtual      /// `virtual`
-    "where"       pub struct Where        /// `where`
-    "while"       pub struct While        /// `while`
-    "yield"       pub struct Yield        /// `yield`
-}
-
-define_punctuation! {
-    "+"           pub struct Add/1        /// `+`
-    "+="          pub struct AddEq/2      /// `+=`
-    "&"           pub struct And/1        /// `&`
-    "&&"          pub struct AndAnd/2     /// `&&`
-    "&="          pub struct AndEq/2      /// `&=`
-    "@"           pub struct At/1         /// `@`
-    "!"           pub struct Bang/1       /// `!`
-    "^"           pub struct Caret/1      /// `^`
-    "^="          pub struct CaretEq/2    /// `^=`
-    ":"           pub struct Colon/1      /// `:`
-    "::"          pub struct Colon2/2     /// `::`
-    ","           pub struct Comma/1      /// `,`
-    "/"           pub struct Div/1        /// `/`
-    "/="          pub struct DivEq/2      /// `/=`
-    "$"           pub struct Dollar/1     /// `$`
-    "."           pub struct Dot/1        /// `.`
-    ".."          pub struct Dot2/2       /// `..`
-    "..."         pub struct Dot3/3       /// `...`
-    "..="         pub struct DotDotEq/3   /// `..=`
-    "="           pub struct Eq/1         /// `=`
-    "=="          pub struct EqEq/2       /// `==`
-    ">="          pub struct Ge/2         /// `>=`
-    ">"           pub struct Gt/1         /// `>`
-    "<="          pub struct Le/2         /// `<=`
-    "<"           pub struct Lt/1         /// `<`
-    "*="          pub struct MulEq/2      /// `*=`
-    "!="          pub struct Ne/2         /// `!=`
-    "|"           pub struct Or/1         /// `|`
-    "|="          pub struct OrEq/2       /// `|=`
-    "||"          pub struct OrOr/2       /// `||`
-    "#"           pub struct Pound/1      /// `#`
-    "?"           pub struct Question/1   /// `?`
-    "->"          pub struct RArrow/2     /// `->`
-    "<-"          pub struct LArrow/2     /// `<-`
-    "%"           pub struct Rem/1        /// `%`
-    "%="          pub struct RemEq/2      /// `%=`
-    "=>"          pub struct FatArrow/2   /// `=>`
-    ";"           pub struct Semi/1       /// `;`
-    "<<"          pub struct Shl/2        /// `<<`
-    "<<="         pub struct ShlEq/3      /// `<<=`
-    ">>"          pub struct Shr/2        /// `>>`
-    ">>="         pub struct ShrEq/3      /// `>>=`
-    "*"           pub struct Star/1       /// `*`
-    "-"           pub struct Sub/1        /// `-`
-    "-="          pub struct SubEq/2      /// `-=`
-    "~"           pub struct Tilde/1      /// `~`
-}
-
-define_delimiters! {
-    "{"           pub struct Brace        /// `{...}`
-    "["           pub struct Bracket      /// `[...]`
-    "("           pub struct Paren        /// `(...)`
-    " "           pub struct Group        /// None-delimited group
-}
-
-macro_rules! export_token_macro {
-    ($($await_rule:tt)*) => {
-        /// A type-macro that expands to the name of the Rust type representation of a
-        /// given token.
-        ///
-        /// See the [token module] documentation for details and examples.
-        ///
-        /// [token module]: crate::token
-        // Unfortunate duplication due to a rustdoc bug.
-        // https://github.com/rust-lang/rust/issues/45939
-        #[macro_export]
-        macro_rules! Token {
-            [abstract]    => { $crate::token::Abstract };
-            [as]          => { $crate::token::As };
-            [async]       => { $crate::token::Async };
-            [auto]        => { $crate::token::Auto };
-            $($await_rule => { $crate::token::Await };)*
-            [become]      => { $crate::token::Become };
-            [box]         => { $crate::token::Box };
-            [break]       => { $crate::token::Break };
-            [const]       => { $crate::token::Const };
-            [continue]    => { $crate::token::Continue };
-            [crate]       => { $crate::token::Crate };
-            [default]     => { $crate::token::Default };
-            [do]          => { $crate::token::Do };
-            [dyn]         => { $crate::token::Dyn };
-            [else]        => { $crate::token::Else };
-            [enum]        => { $crate::token::Enum };
-            [extern]      => { $crate::token::Extern };
-            [final]       => { $crate::token::Final };
-            [fn]          => { $crate::token::Fn };
-            [for]         => { $crate::token::For };
-            [if]          => { $crate::token::If };
-            [impl]        => { $crate::token::Impl };
-            [in]          => { $crate::token::In };
-            [let]         => { $crate::token::Let };
-            [loop]        => { $crate::token::Loop };
-            [macro]       => { $crate::token::Macro };
-            [match]       => { $crate::token::Match };
-            [mod]         => { $crate::token::Mod };
-            [move]        => { $crate::token::Move };
-            [mut]         => { $crate::token::Mut };
-            [override]    => { $crate::token::Override };
-            [priv]        => { $crate::token::Priv };
-            [pub]         => { $crate::token::Pub };
-            [ref]         => { $crate::token::Ref };
-            [return]      => { $crate::token::Return };
-            [Self]        => { $crate::token::SelfType };
-            [self]        => { $crate::token::SelfValue };
-            [static]      => { $crate::token::Static };
-            [struct]      => { $crate::token::Struct };
-            [super]       => { $crate::token::Super };
-            [trait]       => { $crate::token::Trait };
-            [try]         => { $crate::token::Try };
-            [type]        => { $crate::token::Type };
-            [typeof]      => { $crate::token::Typeof };
-            [union]       => { $crate::token::Union };
-            [unsafe]      => { $crate::token::Unsafe };
-            [unsized]     => { $crate::token::Unsized };
-            [use]         => { $crate::token::Use };
-            [virtual]     => { $crate::token::Virtual };
-            [where]       => { $crate::token::Where };
-            [while]       => { $crate::token::While };
-            [yield]       => { $crate::token::Yield };
-            [+]           => { $crate::token::Add };
-            [+=]          => { $crate::token::AddEq };
-            [&]           => { $crate::token::And };
-            [&&]          => { $crate::token::AndAnd };
-            [&=]          => { $crate::token::AndEq };
-            [@]           => { $crate::token::At };
-            [!]           => { $crate::token::Bang };
-            [^]           => { $crate::token::Caret };
-            [^=]          => { $crate::token::CaretEq };
-            [:]           => { $crate::token::Colon };
-            [::]          => { $crate::token::Colon2 };
-            [,]           => { $crate::token::Comma };
-            [/]           => { $crate::token::Div };
-            [/=]          => { $crate::token::DivEq };
-            [$]           => { $crate::token::Dollar };
-            [.]           => { $crate::token::Dot };
-            [..]          => { $crate::token::Dot2 };
-            [...]         => { $crate::token::Dot3 };
-            [..=]         => { $crate::token::DotDotEq };
-            [=]           => { $crate::token::Eq };
-            [==]          => { $crate::token::EqEq };
-            [>=]          => { $crate::token::Ge };
-            [>]           => { $crate::token::Gt };
-            [<=]          => { $crate::token::Le };
-            [<]           => { $crate::token::Lt };
-            [*=]          => { $crate::token::MulEq };
-            [!=]          => { $crate::token::Ne };
-            [|]           => { $crate::token::Or };
-            [|=]          => { $crate::token::OrEq };
-            [||]          => { $crate::token::OrOr };
-            [#]           => { $crate::token::Pound };
-            [?]           => { $crate::token::Question };
-            [->]          => { $crate::token::RArrow };
-            [<-]          => { $crate::token::LArrow };
-            [%]           => { $crate::token::Rem };
-            [%=]          => { $crate::token::RemEq };
-            [=>]          => { $crate::token::FatArrow };
-            [;]           => { $crate::token::Semi };
-            [<<]          => { $crate::token::Shl };
-            [<<=]         => { $crate::token::ShlEq };
-            [>>]          => { $crate::token::Shr };
-            [>>=]         => { $crate::token::ShrEq };
-            [*]           => { $crate::token::Star };
-            [-]           => { $crate::token::Sub };
-            [-=]          => { $crate::token::SubEq };
-            [~]           => { $crate::token::Tilde };
-            [_]           => { $crate::token::Underscore };
-        }
-    };
-}
-
-// Old rustc does not permit `await` appearing anywhere in the source file.
-// https://github.com/rust-lang/rust/issues/57919
-// We put the Token![await] rule in a place that is not lexed by old rustc.
-#[cfg(not(syn_omit_await_from_token_macro))]
-include!("await.rs"); // export_token_macro! {[await]}
-#[cfg(syn_omit_await_from_token_macro)]
-export_token_macro! {}
-
-// Not public API.
-#[doc(hidden)]
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use crate::buffer::Cursor;
-    use crate::error::{Error, Result};
-    use crate::parse::ParseStream;
-    use crate::span::FromSpans;
-    use proc_macro2::{Spacing, Span};
-
-    pub fn keyword(input: ParseStream, token: &str) -> Result<Span> {
-        input.step(|cursor| {
-            if let Some((ident, rest)) = cursor.ident() {
-                if ident == token {
-                    return Ok((ident.span(), rest));
-                }
-            }
-            Err(cursor.error(format!("expected `{}`", token)))
-        })
-    }
-
-    pub fn peek_keyword(cursor: Cursor, token: &str) -> bool {
-        if let Some((ident, _rest)) = cursor.ident() {
-            ident == token
-        } else {
-            false
-        }
-    }
-
-    pub fn punct<S: FromSpans>(input: ParseStream, token: &str) -> Result<S> {
-        let mut spans = [input.span(); 3];
-        punct_helper(input, token, &mut spans)?;
-        Ok(S::from_spans(&spans))
-    }
-
-    fn punct_helper(input: ParseStream, token: &str, spans: &mut [Span; 3]) -> Result<()> {
-        input.step(|cursor| {
-            let mut cursor = *cursor;
-            assert!(token.len() <= spans.len());
-
-            for (i, ch) in token.chars().enumerate() {
-                match cursor.punct() {
-                    Some((punct, rest)) => {
-                        spans[i] = punct.span();
-                        if punct.as_char() != ch {
-                            break;
-                        } else if i == token.len() - 1 {
-                            return Ok(((), rest));
-                        } else if punct.spacing() != Spacing::Joint {
-                            break;
-                        }
-                        cursor = rest;
-                    }
-                    None => break,
-                }
-            }
-
-            Err(Error::new(spans[0], format!("expected `{}`", token)))
-        })
-    }
-
-    pub fn peek_punct(mut cursor: Cursor, token: &str) -> bool {
-        for (i, ch) in token.chars().enumerate() {
-            match cursor.punct() {
-                Some((punct, rest)) => {
-                    if punct.as_char() != ch {
-                        break;
-                    } else if i == token.len() - 1 {
-                        return true;
-                    } else if punct.spacing() != Spacing::Joint {
-                        break;
-                    }
-                    cursor = rest;
-                }
-                None => break,
-            }
-        }
-        false
-    }
-}
-
-// Not public API.
-#[doc(hidden)]
-#[cfg(feature = "printing")]
-pub mod printing {
-    use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream};
-    use quote::TokenStreamExt;
-
-    pub fn punct(s: &str, spans: &[Span], tokens: &mut TokenStream) {
-        assert_eq!(s.len(), spans.len());
-
-        let mut chars = s.chars();
-        let mut spans = spans.iter();
-        let ch = chars.next_back().unwrap();
-        let span = spans.next_back().unwrap();
-        for (ch, span) in chars.zip(spans) {
-            let mut op = Punct::new(ch, Spacing::Joint);
-            op.set_span(*span);
-            tokens.append(op);
-        }
-
-        let mut op = Punct::new(ch, Spacing::Alone);
-        op.set_span(*span);
-        tokens.append(op);
-    }
-
-    pub fn keyword(s: &str, span: Span, tokens: &mut TokenStream) {
-        tokens.append(Ident::new(s, span));
-    }
-
-    pub fn delim<F>(s: &str, span: Span, tokens: &mut TokenStream, f: F)
-    where
-        F: FnOnce(&mut TokenStream),
-    {
-        let delim = match s {
-            "(" => Delimiter::Parenthesis,
-            "[" => Delimiter::Bracket,
-            "{" => Delimiter::Brace,
-            " " => Delimiter::None,
-            _ => panic!("unknown delimiter: {}", s),
-        };
-        let mut inner = TokenStream::new();
-        f(&mut inner);
-        let mut g = Group::new(delim, inner);
-        g.set_span(span);
-        tokens.append(g);
-    }
-}
diff --git a/vendor/syn/src/tt.rs b/vendor/syn/src/tt.rs
deleted file mode 100644
index d87c0ed4..00000000
--- a/vendor/syn/src/tt.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use proc_macro2::{Delimiter, TokenStream, TokenTree};
-use std::hash::{Hash, Hasher};
-
-pub struct TokenTreeHelper<'a>(pub &'a TokenTree);
-
-impl<'a> PartialEq for TokenTreeHelper<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        use proc_macro2::Spacing;
-
-        match (self.0, other.0) {
-            (TokenTree::Group(g1), TokenTree::Group(g2)) => {
-                match (g1.delimiter(), g2.delimiter()) {
-                    (Delimiter::Parenthesis, Delimiter::Parenthesis)
-                    | (Delimiter::Brace, Delimiter::Brace)
-                    | (Delimiter::Bracket, Delimiter::Bracket)
-                    | (Delimiter::None, Delimiter::None) => {}
-                    _ => return false,
-                }
-
-                let s1 = g1.stream().into_iter();
-                let mut s2 = g2.stream().into_iter();
-
-                for item1 in s1 {
-                    let item2 = match s2.next() {
-                        Some(item) => item,
-                        None => return false,
-                    };
-                    if TokenTreeHelper(&item1) != TokenTreeHelper(&item2) {
-                        return false;
-                    }
-                }
-                s2.next().is_none()
-            }
-            (TokenTree::Punct(o1), TokenTree::Punct(o2)) => {
-                o1.as_char() == o2.as_char()
-                    && match (o1.spacing(), o2.spacing()) {
-                        (Spacing::Alone, Spacing::Alone) | (Spacing::Joint, Spacing::Joint) => true,
-                        _ => false,
-                    }
-            }
-            (TokenTree::Literal(l1), TokenTree::Literal(l2)) => l1.to_string() == l2.to_string(),
-            (TokenTree::Ident(s1), TokenTree::Ident(s2)) => s1 == s2,
-            _ => false,
-        }
-    }
-}
-
-impl<'a> Hash for TokenTreeHelper<'a> {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        use proc_macro2::Spacing;
-
-        match self.0 {
-            TokenTree::Group(g) => {
-                0u8.hash(h);
-                match g.delimiter() {
-                    Delimiter::Parenthesis => 0u8.hash(h),
-                    Delimiter::Brace => 1u8.hash(h),
-                    Delimiter::Bracket => 2u8.hash(h),
-                    Delimiter::None => 3u8.hash(h),
-                }
-
-                for item in g.stream() {
-                    TokenTreeHelper(&item).hash(h);
-                }
-                0xffu8.hash(h); // terminator w/ a variant we don't normally hash
-            }
-            TokenTree::Punct(op) => {
-                1u8.hash(h);
-                op.as_char().hash(h);
-                match op.spacing() {
-                    Spacing::Alone => 0u8.hash(h),
-                    Spacing::Joint => 1u8.hash(h),
-                }
-            }
-            TokenTree::Literal(lit) => (2u8, lit.to_string()).hash(h),
-            TokenTree::Ident(word) => (3u8, word).hash(h),
-        }
-    }
-}
-
-pub struct TokenStreamHelper<'a>(pub &'a TokenStream);
-
-impl<'a> PartialEq for TokenStreamHelper<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        let left = self.0.clone().into_iter().collect::<Vec<_>>();
-        let right = other.0.clone().into_iter().collect::<Vec<_>>();
-        if left.len() != right.len() {
-            return false;
-        }
-        for (a, b) in left.into_iter().zip(right) {
-            if TokenTreeHelper(&a) != TokenTreeHelper(&b) {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl<'a> Hash for TokenStreamHelper<'a> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let tts = self.0.clone().into_iter().collect::<Vec<_>>();
-        tts.len().hash(state);
-        for tt in tts {
-            TokenTreeHelper(&tt).hash(state);
-        }
-    }
-}
diff --git a/vendor/syn/src/ty.rs b/vendor/syn/src/ty.rs
deleted file mode 100644
index 3df340d5..00000000
--- a/vendor/syn/src/ty.rs
+++ /dev/null
@@ -1,1238 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-use proc_macro2::TokenStream;
-
-ast_enum_of_structs! {
-    /// The possible types that a Rust value could have.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: Expr#syntax-tree-enums
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum Type {
-        /// A fixed size array type: `[T; n]`.
-        Array(TypeArray),
-
-        /// A bare function type: `fn(usize) -> bool`.
-        BareFn(TypeBareFn),
-
-        /// A type contained within invisible delimiters.
-        Group(TypeGroup),
-
-        /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
-        /// a lifetime.
-        ImplTrait(TypeImplTrait),
-
-        /// Indication that a type should be inferred by the compiler: `_`.
-        Infer(TypeInfer),
-
-        /// A macro in the type position.
-        Macro(TypeMacro),
-
-        /// The never type: `!`.
-        Never(TypeNever),
-
-        /// A parenthesized type equivalent to the inner type.
-        Paren(TypeParen),
-
-        /// A path like `std::slice::Iter`, optionally qualified with a
-        /// self-type as in `<Vec<T> as SomeTrait>::Associated`.
-        Path(TypePath),
-
-        /// A raw pointer type: `*const T` or `*mut T`.
-        Ptr(TypePtr),
-
-        /// A reference type: `&'a T` or `&'a mut T`.
-        Reference(TypeReference),
-
-        /// A dynamically sized slice type: `[T]`.
-        Slice(TypeSlice),
-
-        /// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a
-        /// trait or a lifetime.
-        TraitObject(TypeTraitObject),
-
-        /// A tuple type: `(A, B, C, String)`.
-        Tuple(TypeTuple),
-
-        /// Tokens in type position not interpreted by Syn.
-        Verbatim(TokenStream),
-
-        // The following is the only supported idiom for exhaustive matching of
-        // this enum.
-        //
-        //     match expr {
-        //         Type::Array(e) => {...}
-        //         Type::BareFn(e) => {...}
-        //         ...
-        //         Type::Verbatim(e) => {...}
-        //
-        //         #[cfg(test)]
-        //         Type::__TestExhaustive(_) => unimplemented!(),
-        //         #[cfg(not(test))]
-        //         _ => { /* some sane fallback */ }
-        //     }
-        //
-        // This way we fail your tests but don't break your library when adding
-        // a variant. You will be notified by a test failure when a variant is
-        // added, so that you can add code to handle it, but your library will
-        // continue to compile and work for downstream users in the interim.
-        //
-        // Once `deny(reachable)` is available in rustc, Type will be
-        // reimplemented as a non_exhaustive enum.
-        // https://github.com/rust-lang/rust/issues/44109#issuecomment-521781237
-        #[doc(hidden)]
-        __TestExhaustive(crate::private),
-    }
-}
-
-ast_struct! {
-    /// A fixed size array type: `[T; n]`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeArray {
-        pub bracket_token: token::Bracket,
-        pub elem: Box<Type>,
-        pub semi_token: Token![;],
-        pub len: Expr,
-    }
-}
-
-ast_struct! {
-    /// A bare function type: `fn(usize) -> bool`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeBareFn {
-        pub lifetimes: Option<BoundLifetimes>,
-        pub unsafety: Option<Token![unsafe]>,
-        pub abi: Option<Abi>,
-        pub fn_token: Token![fn],
-        pub paren_token: token::Paren,
-        pub inputs: Punctuated<BareFnArg, Token![,]>,
-        pub variadic: Option<Variadic>,
-        pub output: ReturnType,
-    }
-}
-
-ast_struct! {
-    /// A type contained within invisible delimiters.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeGroup {
-        pub group_token: token::Group,
-        pub elem: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
-    /// a lifetime.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeImplTrait {
-        pub impl_token: Token![impl],
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// Indication that a type should be inferred by the compiler: `_`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeInfer {
-        pub underscore_token: Token![_],
-    }
-}
-
-ast_struct! {
-    /// A macro in the type position.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeMacro {
-        pub mac: Macro,
-    }
-}
-
-ast_struct! {
-    /// The never type: `!`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeNever {
-        pub bang_token: Token![!],
-    }
-}
-
-ast_struct! {
-    /// A parenthesized type equivalent to the inner type.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeParen {
-        pub paren_token: token::Paren,
-        pub elem: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A path like `std::slice::Iter`, optionally qualified with a
-    /// self-type as in `<Vec<T> as SomeTrait>::Associated`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypePath {
-        pub qself: Option<QSelf>,
-        pub path: Path,
-    }
-}
-
-ast_struct! {
-    /// A raw pointer type: `*const T` or `*mut T`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypePtr {
-        pub star_token: Token![*],
-        pub const_token: Option<Token![const]>,
-        pub mutability: Option<Token![mut]>,
-        pub elem: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A reference type: `&'a T` or `&'a mut T`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeReference {
-        pub and_token: Token![&],
-        pub lifetime: Option<Lifetime>,
-        pub mutability: Option<Token![mut]>,
-        pub elem: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A dynamically sized slice type: `[T]`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeSlice {
-        pub bracket_token: token::Bracket,
-        pub elem: Box<Type>,
-    }
-}
-
-ast_struct! {
-    /// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a
-    /// trait or a lifetime.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeTraitObject {
-        pub dyn_token: Option<Token![dyn]>,
-        pub bounds: Punctuated<TypeParamBound, Token![+]>,
-    }
-}
-
-ast_struct! {
-    /// A tuple type: `(A, B, C, String)`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or
-    /// `"full"` feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct TypeTuple {
-        pub paren_token: token::Paren,
-        pub elems: Punctuated<Type, Token![,]>,
-    }
-}
-
-ast_struct! {
-    /// The binary interface of a function: `extern "C"`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Abi {
-        pub extern_token: Token![extern],
-        pub name: Option<LitStr>,
-    }
-}
-
-ast_struct! {
-    /// An argument in a function type: the `usize` in `fn(usize) -> bool`.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct BareFnArg {
-        pub attrs: Vec<Attribute>,
-        pub name: Option<(Ident, Token![:])>,
-        pub ty: Type,
-    }
-}
-
-ast_struct! {
-    /// The variadic argument of a foreign function.
-    ///
-    /// ```rust
-    /// # struct c_char;
-    /// # struct c_int;
-    /// #
-    /// extern "C" {
-    ///     fn printf(format: *const c_char, ...) -> c_int;
-    ///     //                               ^^^
-    /// }
-    /// ```
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub struct Variadic {
-        pub attrs: Vec<Attribute>,
-        pub dots: Token![...],
-    }
-}
-
-ast_enum! {
-    /// Return type of a function signature.
-    ///
-    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
-    pub enum ReturnType {
-        /// Return type is not specified.
-        ///
-        /// Functions default to `()` and closures default to type inference.
-        Default,
-        /// A particular type is returned.
-        Type(Token![->], Box<Type>),
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use crate::ext::IdentExt;
-    use crate::parse::{Parse, ParseStream, Result};
-    use crate::path;
-    use proc_macro2::{Punct, Spacing, TokenTree};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Type {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_plus = true;
-            ambig_ty(input, allow_plus)
-        }
-    }
-
-    impl Type {
-        /// In some positions, types may not contain the `+` character, to
-        /// disambiguate them. For example in the expression `1 as T`, T may not
-        /// contain a `+` character.
-        ///
-        /// This parser does not allow a `+`, while the default parser does.
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn without_plus(input: ParseStream) -> Result<Self> {
-            let allow_plus = false;
-            ambig_ty(input, allow_plus)
-        }
-    }
-
-    fn ambig_ty(input: ParseStream, allow_plus: bool) -> Result<Type> {
-        let begin = input.fork();
-
-        if input.peek(token::Group) {
-            let mut group: TypeGroup = input.parse()?;
-            if input.peek(Token![::]) && input.peek3(Ident::peek_any) {
-                if let Type::Path(mut ty) = *group.elem {
-                    Path::parse_rest(input, &mut ty.path, false)?;
-                    return Ok(Type::Path(ty));
-                } else {
-                    return Ok(Type::Path(TypePath {
-                        qself: Some(QSelf {
-                            lt_token: Token![<](group.group_token.span),
-                            position: 0,
-                            as_token: None,
-                            gt_token: Token![>](group.group_token.span),
-                            ty: group.elem,
-                        }),
-                        path: Path::parse_helper(input, false)?,
-                    }));
-                }
-            } else if input.peek(Token![<]) || input.peek(Token![::]) && input.peek3(Token![<]) {
-                if let Type::Path(mut ty) = *group.elem {
-                    let arguments = &mut ty.path.segments.last_mut().unwrap().arguments;
-                    if let PathArguments::None = arguments {
-                        *arguments = PathArguments::AngleBracketed(input.parse()?);
-                        Path::parse_rest(input, &mut ty.path, false)?;
-                        return Ok(Type::Path(ty));
-                    } else {
-                        group.elem = Box::new(Type::Path(ty));
-                    }
-                }
-            }
-            return Ok(Type::Group(group));
-        }
-
-        let mut lifetimes = None::<BoundLifetimes>;
-        let mut lookahead = input.lookahead1();
-        if lookahead.peek(Token![for]) {
-            lifetimes = input.parse()?;
-            lookahead = input.lookahead1();
-            if !lookahead.peek(Ident)
-                && !lookahead.peek(Token![fn])
-                && !lookahead.peek(Token![unsafe])
-                && !lookahead.peek(Token![extern])
-                && !lookahead.peek(Token![super])
-                && !lookahead.peek(Token![self])
-                && !lookahead.peek(Token![Self])
-                && !lookahead.peek(Token![crate])
-                || input.peek(Token![dyn])
-            {
-                return Err(lookahead.error());
-            }
-        }
-
-        if lookahead.peek(token::Paren) {
-            let content;
-            let paren_token = parenthesized!(content in input);
-            if content.is_empty() {
-                return Ok(Type::Tuple(TypeTuple {
-                    paren_token,
-                    elems: Punctuated::new(),
-                }));
-            }
-            if content.peek(Lifetime) {
-                return Ok(Type::Paren(TypeParen {
-                    paren_token,
-                    elem: Box::new(Type::TraitObject(content.parse()?)),
-                }));
-            }
-            if content.peek(Token![?]) {
-                return Ok(Type::TraitObject(TypeTraitObject {
-                    dyn_token: None,
-                    bounds: {
-                        let mut bounds = Punctuated::new();
-                        bounds.push_value(TypeParamBound::Trait(TraitBound {
-                            paren_token: Some(paren_token),
-                            ..content.parse()?
-                        }));
-                        while let Some(plus) = input.parse()? {
-                            bounds.push_punct(plus);
-                            bounds.push_value(input.parse()?);
-                        }
-                        bounds
-                    },
-                }));
-            }
-            let mut first: Type = content.parse()?;
-            if content.peek(Token![,]) {
-                return Ok(Type::Tuple(TypeTuple {
-                    paren_token,
-                    elems: {
-                        let mut elems = Punctuated::new();
-                        elems.push_value(first);
-                        elems.push_punct(content.parse()?);
-                        while !content.is_empty() {
-                            elems.push_value(content.parse()?);
-                            if content.is_empty() {
-                                break;
-                            }
-                            elems.push_punct(content.parse()?);
-                        }
-                        elems
-                    },
-                }));
-            }
-            if allow_plus && input.peek(Token![+]) {
-                loop {
-                    let first = match first {
-                        Type::Path(TypePath { qself: None, path }) => {
-                            TypeParamBound::Trait(TraitBound {
-                                paren_token: Some(paren_token),
-                                modifier: TraitBoundModifier::None,
-                                lifetimes: None,
-                                path,
-                            })
-                        }
-                        Type::TraitObject(TypeTraitObject {
-                            dyn_token: None,
-                            bounds,
-                        }) => {
-                            if bounds.len() > 1 || bounds.trailing_punct() {
-                                first = Type::TraitObject(TypeTraitObject {
-                                    dyn_token: None,
-                                    bounds,
-                                });
-                                break;
-                            }
-                            match bounds.into_iter().next().unwrap() {
-                                TypeParamBound::Trait(trait_bound) => {
-                                    TypeParamBound::Trait(TraitBound {
-                                        paren_token: Some(paren_token),
-                                        ..trait_bound
-                                    })
-                                }
-                                other @ TypeParamBound::Lifetime(_) => other,
-                            }
-                        }
-                        _ => break,
-                    };
-                    return Ok(Type::TraitObject(TypeTraitObject {
-                        dyn_token: None,
-                        bounds: {
-                            let mut bounds = Punctuated::new();
-                            bounds.push_value(first);
-                            while let Some(plus) = input.parse()? {
-                                bounds.push_punct(plus);
-                                bounds.push_value(input.parse()?);
-                            }
-                            bounds
-                        },
-                    }));
-                }
-            }
-            Ok(Type::Paren(TypeParen {
-                paren_token,
-                elem: Box::new(first),
-            }))
-        } else if lookahead.peek(Token![fn])
-            || lookahead.peek(Token![unsafe])
-            || lookahead.peek(Token![extern])
-        {
-            let allow_mut_self = true;
-            if let Some(mut bare_fn) = parse_bare_fn(input, allow_mut_self)? {
-                bare_fn.lifetimes = lifetimes;
-                Ok(Type::BareFn(bare_fn))
-            } else {
-                Ok(Type::Verbatim(verbatim::between(begin, input)))
-            }
-        } else if lookahead.peek(Ident)
-            || input.peek(Token![super])
-            || input.peek(Token![self])
-            || input.peek(Token![Self])
-            || input.peek(Token![crate])
-            || lookahead.peek(Token![::])
-            || lookahead.peek(Token![<])
-        {
-            if input.peek(Token![dyn]) {
-                let trait_object: TypeTraitObject = input.parse()?;
-                return Ok(Type::TraitObject(trait_object));
-            }
-
-            let ty: TypePath = input.parse()?;
-            if ty.qself.is_some() {
-                return Ok(Type::Path(ty));
-            }
-
-            if input.peek(Token![!]) && !input.peek(Token![!=]) {
-                let mut contains_arguments = false;
-                for segment in &ty.path.segments {
-                    match segment.arguments {
-                        PathArguments::None => {}
-                        PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => {
-                            contains_arguments = true;
-                        }
-                    }
-                }
-
-                if !contains_arguments {
-                    let bang_token: Token![!] = input.parse()?;
-                    let (delimiter, tokens) = mac::parse_delimiter(input)?;
-                    return Ok(Type::Macro(TypeMacro {
-                        mac: Macro {
-                            path: ty.path,
-                            bang_token,
-                            delimiter,
-                            tokens,
-                        },
-                    }));
-                }
-            }
-
-            if lifetimes.is_some() || allow_plus && input.peek(Token![+]) {
-                let mut bounds = Punctuated::new();
-                bounds.push_value(TypeParamBound::Trait(TraitBound {
-                    paren_token: None,
-                    modifier: TraitBoundModifier::None,
-                    lifetimes,
-                    path: ty.path,
-                }));
-                if allow_plus {
-                    while input.peek(Token![+]) {
-                        bounds.push_punct(input.parse()?);
-                        if input.peek(Token![>]) {
-                            break;
-                        }
-                        bounds.push_value(input.parse()?);
-                    }
-                }
-                return Ok(Type::TraitObject(TypeTraitObject {
-                    dyn_token: None,
-                    bounds,
-                }));
-            }
-
-            Ok(Type::Path(ty))
-        } else if lookahead.peek(token::Bracket) {
-            let content;
-            let bracket_token = bracketed!(content in input);
-            let elem: Type = content.parse()?;
-            if content.peek(Token![;]) {
-                Ok(Type::Array(TypeArray {
-                    bracket_token,
-                    elem: Box::new(elem),
-                    semi_token: content.parse()?,
-                    len: content.parse()?,
-                }))
-            } else {
-                Ok(Type::Slice(TypeSlice {
-                    bracket_token,
-                    elem: Box::new(elem),
-                }))
-            }
-        } else if lookahead.peek(Token![*]) {
-            input.parse().map(Type::Ptr)
-        } else if lookahead.peek(Token![&]) {
-            input.parse().map(Type::Reference)
-        } else if lookahead.peek(Token![!]) && !input.peek(Token![=]) {
-            input.parse().map(Type::Never)
-        } else if lookahead.peek(Token![impl]) {
-            input.parse().map(Type::ImplTrait)
-        } else if lookahead.peek(Token![_]) {
-            input.parse().map(Type::Infer)
-        } else if lookahead.peek(Lifetime) {
-            input.parse().map(Type::TraitObject)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeSlice {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(TypeSlice {
-                bracket_token: bracketed!(content in input),
-                elem: content.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeArray {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(TypeArray {
-                bracket_token: bracketed!(content in input),
-                elem: content.parse()?,
-                semi_token: content.parse()?,
-                len: content.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypePtr {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let star_token: Token![*] = input.parse()?;
-
-            let lookahead = input.lookahead1();
-            let (const_token, mutability) = if lookahead.peek(Token![const]) {
-                (Some(input.parse()?), None)
-            } else if lookahead.peek(Token![mut]) {
-                (None, Some(input.parse()?))
-            } else {
-                return Err(lookahead.error());
-            };
-
-            Ok(TypePtr {
-                star_token,
-                const_token,
-                mutability,
-                elem: Box::new(input.call(Type::without_plus)?),
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeReference {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TypeReference {
-                and_token: input.parse()?,
-                lifetime: input.parse()?,
-                mutability: input.parse()?,
-                // & binds tighter than +, so we don't allow + here.
-                elem: Box::new(input.call(Type::without_plus)?),
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeBareFn {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_mut_self = false;
-            parse_bare_fn(input, allow_mut_self).map(Option::unwrap)
-        }
-    }
-
-    fn parse_bare_fn(input: ParseStream, allow_mut_self: bool) -> Result<Option<TypeBareFn>> {
-        let args;
-        let mut variadic = None;
-        let mut has_mut_self = false;
-
-        let bare_fn = TypeBareFn {
-            lifetimes: input.parse()?,
-            unsafety: input.parse()?,
-            abi: input.parse()?,
-            fn_token: input.parse()?,
-            paren_token: parenthesized!(args in input),
-            inputs: {
-                let mut inputs = Punctuated::new();
-
-                while !args.is_empty() {
-                    let attrs = args.call(Attribute::parse_outer)?;
-
-                    if inputs.empty_or_trailing() && args.peek(Token![...]) {
-                        variadic = Some(Variadic {
-                            attrs,
-                            dots: args.parse()?,
-                        });
-                        break;
-                    }
-
-                    if let Some(arg) = parse_bare_fn_arg(&args, allow_mut_self)? {
-                        inputs.push_value(BareFnArg { attrs, ..arg });
-                    } else {
-                        has_mut_self = true;
-                    }
-                    if args.is_empty() {
-                        break;
-                    }
-
-                    inputs.push_punct(args.parse()?);
-                }
-
-                inputs
-            },
-            variadic,
-            output: input.call(ReturnType::without_plus)?,
-        };
-
-        if has_mut_self {
-            Ok(None)
-        } else {
-            Ok(Some(bare_fn))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeNever {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TypeNever {
-                bang_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeInfer {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TypeInfer {
-                underscore_token: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeTuple {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            let paren_token = parenthesized!(content in input);
-
-            if content.is_empty() {
-                return Ok(TypeTuple {
-                    paren_token,
-                    elems: Punctuated::new(),
-                });
-            }
-
-            let first: Type = content.parse()?;
-            Ok(TypeTuple {
-                paren_token,
-                elems: {
-                    let mut elems = Punctuated::new();
-                    elems.push_value(first);
-                    elems.push_punct(content.parse()?);
-                    while !content.is_empty() {
-                        elems.push_value(content.parse()?);
-                        if content.is_empty() {
-                            break;
-                        }
-                        elems.push_punct(content.parse()?);
-                    }
-                    elems
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeMacro {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TypeMacro {
-                mac: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypePath {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let (qself, mut path) = path::parsing::qpath(input, false)?;
-
-            if path.segments.last().unwrap().arguments.is_empty() && input.peek(token::Paren) {
-                let args: ParenthesizedGenericArguments = input.parse()?;
-                let parenthesized = PathArguments::Parenthesized(args);
-                path.segments.last_mut().unwrap().arguments = parenthesized;
-            }
-
-            Ok(TypePath { qself, path })
-        }
-    }
-
-    impl ReturnType {
-        pub fn without_plus(input: ParseStream) -> Result<Self> {
-            let allow_plus = false;
-            Self::parse(input, allow_plus)
-        }
-
-        #[doc(hidden)]
-        pub fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
-            if input.peek(Token![->]) {
-                let arrow = input.parse()?;
-                let ty = ambig_ty(input, allow_plus)?;
-                Ok(ReturnType::Type(arrow, Box::new(ty)))
-            } else {
-                Ok(ReturnType::Default)
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for ReturnType {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Self::parse(input, true)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeTraitObject {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Self::parse(input, true)
-        }
-    }
-
-    fn at_least_one_type(bounds: &Punctuated<TypeParamBound, Token![+]>) -> bool {
-        for bound in bounds {
-            if let TypeParamBound::Trait(_) = *bound {
-                return true;
-            }
-        }
-        false
-    }
-
-    impl TypeTraitObject {
-        pub fn without_plus(input: ParseStream) -> Result<Self> {
-            let allow_plus = false;
-            Self::parse(input, allow_plus)
-        }
-
-        // Only allow multiple trait references if allow_plus is true.
-        #[doc(hidden)]
-        pub fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
-            Ok(TypeTraitObject {
-                dyn_token: input.parse()?,
-                bounds: {
-                    let mut bounds = Punctuated::new();
-                    if allow_plus {
-                        loop {
-                            bounds.push_value(input.parse()?);
-                            if !input.peek(Token![+]) {
-                                break;
-                            }
-                            bounds.push_punct(input.parse()?);
-                            if input.peek(Token![>]) {
-                                break;
-                            }
-                        }
-                    } else {
-                        bounds.push_value(input.parse()?);
-                    }
-                    // Just lifetimes like `'a + 'b` is not a TraitObject.
-                    if !at_least_one_type(&bounds) {
-                        return Err(input.error("expected at least one type"));
-                    }
-                    bounds
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeImplTrait {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(TypeImplTrait {
-                impl_token: input.parse()?,
-                // NOTE: rust-lang/rust#34511 includes discussion about whether
-                // or not + should be allowed in ImplTrait directly without ().
-                bounds: {
-                    let mut bounds = Punctuated::new();
-                    loop {
-                        bounds.push_value(input.parse()?);
-                        if !input.peek(Token![+]) {
-                            break;
-                        }
-                        bounds.push_punct(input.parse()?);
-                    }
-                    bounds
-                },
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeGroup {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let group = crate::group::parse_group(input)?;
-            Ok(TypeGroup {
-                group_token: group.token,
-                elem: group.content.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for TypeParen {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_plus = false;
-            Self::parse(input, allow_plus)
-        }
-    }
-
-    impl TypeParen {
-        fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
-            let content;
-            Ok(TypeParen {
-                paren_token: parenthesized!(content in input),
-                elem: Box::new(ambig_ty(&content, allow_plus)?),
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for BareFnArg {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_mut_self = false;
-            parse_bare_fn_arg(input, allow_mut_self).map(Option::unwrap)
-        }
-    }
-
-    fn parse_bare_fn_arg(
-        input: ParseStream,
-        mut allow_mut_self: bool,
-    ) -> Result<Option<BareFnArg>> {
-        let mut has_mut_self = false;
-        let arg = BareFnArg {
-            attrs: input.call(Attribute::parse_outer)?,
-            name: {
-                if (input.peek(Ident) || input.peek(Token![_]) || input.peek(Token![self]))
-                    && input.peek2(Token![:])
-                    && !input.peek2(Token![::])
-                {
-                    let name = input.call(Ident::parse_any)?;
-                    let colon: Token![:] = input.parse()?;
-                    Some((name, colon))
-                } else if allow_mut_self
-                    && input.peek(Token![mut])
-                    && input.peek2(Token![self])
-                    && input.peek3(Token![:])
-                    && !input.peek3(Token![::])
-                {
-                    has_mut_self = true;
-                    allow_mut_self = false;
-                    input.parse::<Token![mut]>()?;
-                    input.parse::<Token![self]>()?;
-                    input.parse::<Token![:]>()?;
-                    None
-                } else {
-                    None
-                }
-            },
-            ty: if !has_mut_self && input.peek(Token![...]) {
-                let dot3 = input.parse::<Token![...]>()?;
-                let args = vec![
-                    TokenTree::Punct(Punct::new('.', Spacing::Joint)),
-                    TokenTree::Punct(Punct::new('.', Spacing::Joint)),
-                    TokenTree::Punct(Punct::new('.', Spacing::Alone)),
-                ];
-                let tokens: TokenStream = args
-                    .into_iter()
-                    .zip(&dot3.spans)
-                    .map(|(mut arg, span)| {
-                        arg.set_span(*span);
-                        arg
-                    })
-                    .collect();
-                Type::Verbatim(tokens)
-            } else if allow_mut_self && input.peek(Token![mut]) && input.peek2(Token![self]) {
-                has_mut_self = true;
-                input.parse::<Token![mut]>()?;
-                Type::Path(TypePath {
-                    qself: None,
-                    path: input.parse::<Token![self]>()?.into(),
-                })
-            } else {
-                input.parse()?
-            },
-        };
-
-        if has_mut_self {
-            Ok(None)
-        } else {
-            Ok(Some(arg))
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Abi {
-        fn parse(input: ParseStream) -> Result<Self> {
-            Ok(Abi {
-                extern_token: input.parse()?,
-                name: input.parse()?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Option<Abi> {
-        fn parse(input: ParseStream) -> Result<Self> {
-            if input.peek(Token![extern]) {
-                input.parse().map(Some)
-            } else {
-                Ok(None)
-            }
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use crate::attr::FilterAttrs;
-    use crate::print::TokensOrDefault;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeSlice {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.bracket_token.surround(tokens, |tokens| {
-                self.elem.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeArray {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.bracket_token.surround(tokens, |tokens| {
-                self.elem.to_tokens(tokens);
-                self.semi_token.to_tokens(tokens);
-                self.len.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypePtr {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.star_token.to_tokens(tokens);
-            match &self.mutability {
-                Some(tok) => tok.to_tokens(tokens),
-                None => {
-                    TokensOrDefault(&self.const_token).to_tokens(tokens);
-                }
-            }
-            self.elem.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeReference {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.and_token.to_tokens(tokens);
-            self.lifetime.to_tokens(tokens);
-            self.mutability.to_tokens(tokens);
-            self.elem.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeBareFn {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.lifetimes.to_tokens(tokens);
-            self.unsafety.to_tokens(tokens);
-            self.abi.to_tokens(tokens);
-            self.fn_token.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.inputs.to_tokens(tokens);
-                if let Some(variadic) = &self.variadic {
-                    if !self.inputs.empty_or_trailing() {
-                        let span = variadic.dots.spans[0];
-                        Token![,](span).to_tokens(tokens);
-                    }
-                    variadic.to_tokens(tokens);
-                }
-            });
-            self.output.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeNever {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.bang_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeTuple {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.paren_token.surround(tokens, |tokens| {
-                self.elems.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypePath {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            private::print_path(tokens, &self.qself, &self.path);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeTraitObject {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.dyn_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeImplTrait {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.impl_token.to_tokens(tokens);
-            self.bounds.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeGroup {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.group_token.surround(tokens, |tokens| {
-                self.elem.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeParen {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.paren_token.surround(tokens, |tokens| {
-                self.elem.to_tokens(tokens);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeInfer {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.underscore_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for TypeMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.mac.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for ReturnType {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                ReturnType::Default => {}
-                ReturnType::Type(arrow, ty) => {
-                    arrow.to_tokens(tokens);
-                    ty.to_tokens(tokens);
-                }
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for BareFnArg {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            if let Some((name, colon)) = &self.name {
-                name.to_tokens(tokens);
-                colon.to_tokens(tokens);
-            }
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Variadic {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.attrs.outer());
-            self.dots.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Abi {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.extern_token.to_tokens(tokens);
-            self.name.to_tokens(tokens);
-        }
-    }
-}
diff --git a/vendor/syn/src/verbatim.rs b/vendor/syn/src/verbatim.rs
deleted file mode 100644
index 0686352f..00000000
--- a/vendor/syn/src/verbatim.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::parse::{ParseBuffer, ParseStream};
-use proc_macro2::TokenStream;
-use std::iter;
-
-pub fn between<'a>(begin: ParseBuffer<'a>, end: ParseStream<'a>) -> TokenStream {
-    let end = end.cursor();
-    let mut cursor = begin.cursor();
-    let mut tokens = TokenStream::new();
-    while cursor != end {
-        let (tt, next) = cursor.token_tree().unwrap();
-        tokens.extend(iter::once(tt));
-        cursor = next;
-    }
-    tokens
-}
diff --git a/vendor/syn/src/whitespace.rs b/vendor/syn/src/whitespace.rs
deleted file mode 100644
index 7be082e1..00000000
--- a/vendor/syn/src/whitespace.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-pub fn skip(mut s: &str) -> &str {
-    'skip: while !s.is_empty() {
-        let byte = s.as_bytes()[0];
-        if byte == b'/' {
-            if s.starts_with("//")
-                && (!s.starts_with("///") || s.starts_with("////"))
-                && !s.starts_with("//!")
-            {
-                if let Some(i) = s.find('\n') {
-                    s = &s[i + 1..];
-                    continue;
-                } else {
-                    return "";
-                }
-            } else if s.starts_with("/**/") {
-                s = &s[4..];
-                continue;
-            } else if s.starts_with("/*")
-                && (!s.starts_with("/**") || s.starts_with("/***"))
-                && !s.starts_with("/*!")
-            {
-                let mut depth = 0;
-                let bytes = s.as_bytes();
-                let mut i = 0;
-                let upper = bytes.len() - 1;
-                while i < upper {
-                    if bytes[i] == b'/' && bytes[i + 1] == b'*' {
-                        depth += 1;
-                        i += 1; // eat '*'
-                    } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
-                        depth -= 1;
-                        if depth == 0 {
-                            s = &s[i + 2..];
-                            continue 'skip;
-                        }
-                        i += 1; // eat '/'
-                    }
-                    i += 1;
-                }
-                return s;
-            }
-        }
-        match byte {
-            b' ' | 0x09..=0x0d => {
-                s = &s[1..];
-                continue;
-            }
-            b if b <= 0x7f => {}
-            _ => {
-                let ch = s.chars().next().unwrap();
-                if is_whitespace(ch) {
-                    s = &s[ch.len_utf8()..];
-                    continue;
-                }
-            }
-        }
-        return s;
-    }
-    s
-}
-
-fn is_whitespace(ch: char) -> bool {
-    // Rust treats left-to-right mark and right-to-left mark as whitespace
-    ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
-}
diff --git a/vendor/syn/tests/.gitignore b/vendor/syn/tests/.gitignore
deleted file mode 100644
index 291ed43a..00000000
--- a/vendor/syn/tests/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/*.pending-snap
diff --git a/vendor/syn/tests/common/eq.rs b/vendor/syn/tests/common/eq.rs
deleted file mode 100644
index 213e5462..00000000
--- a/vendor/syn/tests/common/eq.rs
+++ /dev/null
@@ -1,630 +0,0 @@
-extern crate rustc_ast;
-extern crate rustc_data_structures;
-extern crate rustc_span;
-
-use rustc_ast::ast::{
-    AngleBracketedArg, AngleBracketedArgs, AnonConst, Arm, AssocItemKind, AssocTyConstraint,
-    AssocTyConstraintKind, Async, AttrId, AttrItem, AttrKind, AttrStyle, Attribute, BareFnTy,
-    BinOpKind, BindingMode, Block, BlockCheckMode, BorrowKind, CaptureBy, Const, Crate, CrateSugar,
-    Defaultness, EnumDef, Expr, ExprField, ExprKind, Extern, FieldDef, FloatTy, FnDecl, FnHeader,
-    FnKind, FnRetTy, FnSig, ForeignItemKind, ForeignMod, GenericArg, GenericArgs, GenericBound,
-    GenericParam, GenericParamKind, Generics, ImplKind, ImplPolarity, Inline, InlineAsm,
-    InlineAsmOperand, InlineAsmOptions, InlineAsmRegOrRegClass, InlineAsmTemplatePiece, IntTy,
-    IsAuto, Item, ItemKind, Label, Lifetime, Lit, LitFloatType, LitIntType, LitKind,
-    LlvmAsmDialect, LlvmInlineAsm, LlvmInlineAsmOutput, Local, MacArgs, MacCall, MacCallStmt,
-    MacDelimiter, MacStmtStyle, MacroDef, ModKind, Movability, MutTy, Mutability, NodeId, Param,
-    ParenthesizedArgs, Pat, PatField, PatKind, Path, PathSegment, PolyTraitRef, QSelf, RangeEnd,
-    RangeLimits, RangeSyntax, Stmt, StmtKind, StrLit, StrStyle, StructExpr, StructRest,
-    TraitBoundModifier, TraitKind, TraitObjectSyntax, TraitRef, Ty, TyAliasKind, TyKind, UintTy,
-    UnOp, Unsafe, UnsafeSource, UseTree, UseTreeKind, Variant, VariantData, Visibility,
-    VisibilityKind, WhereBoundPredicate, WhereClause, WhereEqPredicate, WherePredicate,
-    WhereRegionPredicate,
-};
-use rustc_ast::ptr::P;
-use rustc_ast::token::{self, CommentKind, DelimToken, Nonterminal, Token, TokenKind};
-use rustc_ast::tokenstream::{
-    AttrAnnotatedTokenStream, AttrAnnotatedTokenTree, AttributesData, DelimSpan, LazyTokenStream,
-    Spacing, TokenStream, TokenTree,
-};
-use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::thin_vec::ThinVec;
-use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{sym, Ident};
-use rustc_span::{Span, Symbol, SyntaxContext, DUMMY_SP};
-
-pub trait SpanlessEq {
-    fn eq(&self, other: &Self) -> bool;
-}
-
-impl<T: SpanlessEq> SpanlessEq for Box<T> {
-    fn eq(&self, other: &Self) -> bool {
-        SpanlessEq::eq(&**self, &**other)
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for P<T> {
-    fn eq(&self, other: &Self) -> bool {
-        SpanlessEq::eq(&**self, &**other)
-    }
-}
-
-impl<T: ?Sized + SpanlessEq> SpanlessEq for Lrc<T> {
-    fn eq(&self, other: &Self) -> bool {
-        SpanlessEq::eq(&**self, &**other)
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for Option<T> {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (None, None) => true,
-            (Some(this), Some(other)) => SpanlessEq::eq(this, other),
-            _ => false,
-        }
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for [T] {
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| SpanlessEq::eq(a, b))
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for Vec<T> {
-    fn eq(&self, other: &Self) -> bool {
-        <[T] as SpanlessEq>::eq(self, other)
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for ThinVec<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len()
-            && self
-                .iter()
-                .zip(other.iter())
-                .all(|(a, b)| SpanlessEq::eq(a, b))
-    }
-}
-
-impl<T: SpanlessEq> SpanlessEq for Spanned<T> {
-    fn eq(&self, other: &Self) -> bool {
-        SpanlessEq::eq(&self.node, &other.node)
-    }
-}
-
-impl<A: SpanlessEq, B: SpanlessEq> SpanlessEq for (A, B) {
-    fn eq(&self, other: &Self) -> bool {
-        SpanlessEq::eq(&self.0, &other.0) && SpanlessEq::eq(&self.1, &other.1)
-    }
-}
-
-macro_rules! spanless_eq_true {
-    ($name:ty) => {
-        impl SpanlessEq for $name {
-            fn eq(&self, _other: &Self) -> bool {
-                true
-            }
-        }
-    };
-}
-
-spanless_eq_true!(Span);
-spanless_eq_true!(DelimSpan);
-spanless_eq_true!(AttrId);
-spanless_eq_true!(NodeId);
-spanless_eq_true!(SyntaxContext);
-spanless_eq_true!(Spacing);
-
-macro_rules! spanless_eq_partial_eq {
-    ($name:ty) => {
-        impl SpanlessEq for $name {
-            fn eq(&self, other: &Self) -> bool {
-                PartialEq::eq(self, other)
-            }
-        }
-    };
-}
-
-spanless_eq_partial_eq!(bool);
-spanless_eq_partial_eq!(u8);
-spanless_eq_partial_eq!(u16);
-spanless_eq_partial_eq!(u128);
-spanless_eq_partial_eq!(usize);
-spanless_eq_partial_eq!(char);
-spanless_eq_partial_eq!(String);
-spanless_eq_partial_eq!(Symbol);
-spanless_eq_partial_eq!(CommentKind);
-spanless_eq_partial_eq!(DelimToken);
-spanless_eq_partial_eq!(InlineAsmOptions);
-spanless_eq_partial_eq!(token::LitKind);
-
-macro_rules! spanless_eq_struct {
-    {
-        $($name:ident)::+ $(<$param:ident>)?
-        $([$field:tt $this:ident $other:ident])*
-        $(![$ignore:tt])*;
-    } => {
-        impl $(<$param: SpanlessEq>)* SpanlessEq for $($name)::+ $(<$param>)* {
-            fn eq(&self, other: &Self) -> bool {
-                let $($name)::+ { $($field: $this,)* $($ignore: _,)* } = self;
-                let $($name)::+ { $($field: $other,)* $($ignore: _,)* } = other;
-                true $(&& SpanlessEq::eq($this, $other))*
-            }
-        }
-    };
-
-    {
-        $($name:ident)::+ $(<$param:ident>)?
-        $([$field:tt $this:ident $other:ident])*
-        $(![$ignore:tt])*;
-        !$next:tt
-        $($rest:tt)*
-    } => {
-        spanless_eq_struct! {
-            $($name)::+ $(<$param>)*
-            $([$field $this $other])*
-            $(![$ignore])*
-            ![$next];
-            $($rest)*
-        }
-    };
-
-    {
-        $($name:ident)::+ $(<$param:ident>)?
-        $([$field:tt $this:ident $other:ident])*
-        $(![$ignore:tt])*;
-        $next:tt
-        $($rest:tt)*
-    } => {
-        spanless_eq_struct! {
-            $($name)::+ $(<$param>)*
-            $([$field $this $other])*
-            [$next this other]
-            $(![$ignore])*;
-            $($rest)*
-        }
-    };
-}
-
-macro_rules! spanless_eq_enum {
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $([$field:tt $this:ident $other:ident])* $(![$ignore:tt])*])*
-    } => {
-        impl SpanlessEq for $($name)::+ {
-            fn eq(&self, other: &Self) -> bool {
-                match self {
-                    $(
-                        $($variant)::+ { .. } => {}
-                    )*
-                }
-                #[allow(unreachable_patterns)]
-                match (self, other) {
-                    $(
-                        (
-                            $($variant)::+ { $($field: $this,)* $($ignore: _,)* },
-                            $($variant)::+ { $($field: $other,)* $($ignore: _,)* },
-                        ) => {
-                            true $(&& SpanlessEq::eq($this, $other))*
-                        }
-                    )*
-                    _ => false,
-                }
-            }
-        }
-    };
-
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $($fields:tt)*])*
-        $next:ident [$([$($named:tt)*])* $(![$ignore:tt])*] (!$i:tt $($field:tt)*)
-        $($rest:tt)*
-    } => {
-        spanless_eq_enum! {
-            $($name)::+;
-            $([$($variant)::+; $($fields)*])*
-            $next [$([$($named)*])* $(![$ignore])* ![$i]] ($($field)*)
-            $($rest)*
-        }
-    };
-
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $($fields:tt)*])*
-        $next:ident [$([$($named:tt)*])* $(![$ignore:tt])*] ($i:tt $($field:tt)*)
-        $($rest:tt)*
-    } => {
-        spanless_eq_enum! {
-            $($name)::+;
-            $([$($variant)::+; $($fields)*])*
-            $next [$([$($named)*])* [$i this other] $(![$ignore])*] ($($field)*)
-            $($rest)*
-        }
-    };
-
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $($fields:tt)*])*
-        $next:ident [$($named:tt)*] ()
-        $($rest:tt)*
-    } => {
-        spanless_eq_enum! {
-            $($name)::+;
-            $([$($variant)::+; $($fields)*])*
-            [$($name)::+::$next; $($named)*]
-            $($rest)*
-        }
-    };
-
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $($fields:tt)*])*
-        $next:ident ($($field:tt)*)
-        $($rest:tt)*
-    } => {
-        spanless_eq_enum! {
-            $($name)::+;
-            $([$($variant)::+; $($fields)*])*
-            $next [] ($($field)*)
-            $($rest)*
-        }
-    };
-
-    {
-        $($name:ident)::+;
-        $([$($variant:ident)::+; $($fields:tt)*])*
-        $next:ident
-        $($rest:tt)*
-    } => {
-        spanless_eq_enum! {
-            $($name)::+;
-            $([$($variant)::+; $($fields)*])*
-            [$($name)::+::$next;]
-            $($rest)*
-        }
-    };
-}
-
-spanless_eq_struct!(AngleBracketedArgs; span args);
-spanless_eq_struct!(AnonConst; id value);
-spanless_eq_struct!(Arm; attrs pat guard body span id is_placeholder);
-spanless_eq_struct!(AssocTyConstraint; id ident gen_args kind span);
-spanless_eq_struct!(AttrAnnotatedTokenStream; 0);
-spanless_eq_struct!(AttrItem; path args tokens);
-spanless_eq_struct!(Attribute; kind id style span);
-spanless_eq_struct!(AttributesData; attrs tokens);
-spanless_eq_struct!(BareFnTy; unsafety ext generic_params decl);
-spanless_eq_struct!(Block; stmts id rules span tokens);
-spanless_eq_struct!(Crate; attrs items span proc_macros);
-spanless_eq_struct!(EnumDef; variants);
-spanless_eq_struct!(Expr; id kind span attrs !tokens);
-spanless_eq_struct!(ExprField; attrs id span ident expr is_shorthand is_placeholder);
-spanless_eq_struct!(FieldDef; attrs id span vis ident ty is_placeholder);
-spanless_eq_struct!(FnDecl; inputs output);
-spanless_eq_struct!(FnHeader; constness asyncness unsafety ext);
-spanless_eq_struct!(FnKind; 0 1 2 3);
-spanless_eq_struct!(FnSig; header decl span);
-spanless_eq_struct!(ForeignMod; unsafety abi items);
-spanless_eq_struct!(GenericParam; id ident attrs bounds is_placeholder kind);
-spanless_eq_struct!(Generics; params where_clause span);
-spanless_eq_struct!(ImplKind; unsafety polarity defaultness constness generics of_trait self_ty items);
-spanless_eq_struct!(InlineAsm; template operands clobber_abi options line_spans);
-spanless_eq_struct!(Item<K>; attrs id span vis ident kind !tokens);
-spanless_eq_struct!(Label; ident);
-spanless_eq_struct!(Lifetime; id ident);
-spanless_eq_struct!(Lit; token kind span);
-spanless_eq_struct!(LlvmInlineAsm; asm asm_str_style outputs inputs clobbers volatile alignstack dialect);
-spanless_eq_struct!(LlvmInlineAsmOutput; constraint expr is_rw is_indirect);
-spanless_eq_struct!(Local; pat ty init id span attrs !tokens);
-spanless_eq_struct!(MacCall; path args prior_type_ascription);
-spanless_eq_struct!(MacCallStmt; mac style attrs tokens);
-spanless_eq_struct!(MacroDef; body macro_rules);
-spanless_eq_struct!(MutTy; ty mutbl);
-spanless_eq_struct!(ParenthesizedArgs; span inputs inputs_span output);
-spanless_eq_struct!(Pat; id kind span tokens);
-spanless_eq_struct!(PatField; ident pat is_shorthand attrs id span is_placeholder);
-spanless_eq_struct!(Path; span segments tokens);
-spanless_eq_struct!(PathSegment; ident id args);
-spanless_eq_struct!(PolyTraitRef; bound_generic_params trait_ref span);
-spanless_eq_struct!(QSelf; ty path_span position);
-spanless_eq_struct!(Stmt; id kind span);
-spanless_eq_struct!(StrLit; style symbol suffix span symbol_unescaped);
-spanless_eq_struct!(StructExpr; qself path fields rest);
-spanless_eq_struct!(Token; kind span);
-spanless_eq_struct!(TraitKind; 0 1 2 3 4);
-spanless_eq_struct!(TraitRef; path ref_id);
-spanless_eq_struct!(Ty; id kind span tokens);
-spanless_eq_struct!(TyAliasKind; 0 1 2 3);
-spanless_eq_struct!(UseTree; prefix kind span);
-spanless_eq_struct!(Variant; attrs id span !vis ident data disr_expr is_placeholder);
-spanless_eq_struct!(Visibility; kind span tokens);
-spanless_eq_struct!(WhereBoundPredicate; span bound_generic_params bounded_ty bounds);
-spanless_eq_struct!(WhereClause; has_where_token predicates span);
-spanless_eq_struct!(WhereEqPredicate; id span lhs_ty rhs_ty);
-spanless_eq_struct!(WhereRegionPredicate; span lifetime bounds);
-spanless_eq_struct!(token::Lit; kind symbol suffix);
-spanless_eq_enum!(AngleBracketedArg; Arg(0) Constraint(0));
-spanless_eq_enum!(AssocItemKind; Const(0 1 2) Fn(0) TyAlias(0) MacCall(0));
-spanless_eq_enum!(AssocTyConstraintKind; Equality(ty) Bound(bounds));
-spanless_eq_enum!(Async; Yes(span closure_id return_impl_trait_id) No);
-spanless_eq_enum!(AttrAnnotatedTokenTree; Token(0) Delimited(0 1 2) Attributes(0));
-spanless_eq_enum!(AttrStyle; Outer Inner);
-spanless_eq_enum!(BinOpKind; Add Sub Mul Div Rem And Or BitXor BitAnd BitOr Shl Shr Eq Lt Le Ne Ge Gt);
-spanless_eq_enum!(BindingMode; ByRef(0) ByValue(0));
-spanless_eq_enum!(BlockCheckMode; Default Unsafe(0));
-spanless_eq_enum!(BorrowKind; Ref Raw);
-spanless_eq_enum!(CaptureBy; Value Ref);
-spanless_eq_enum!(Const; Yes(0) No);
-spanless_eq_enum!(CrateSugar; PubCrate JustCrate);
-spanless_eq_enum!(Defaultness; Default(0) Final);
-spanless_eq_enum!(Extern; None Implicit Explicit(0));
-spanless_eq_enum!(FloatTy; F32 F64);
-spanless_eq_enum!(FnRetTy; Default(0) Ty(0));
-spanless_eq_enum!(ForeignItemKind; Static(0 1 2) Fn(0) TyAlias(0) MacCall(0));
-spanless_eq_enum!(GenericArg; Lifetime(0) Type(0) Const(0));
-spanless_eq_enum!(GenericArgs; AngleBracketed(0) Parenthesized(0));
-spanless_eq_enum!(GenericBound; Trait(0 1) Outlives(0));
-spanless_eq_enum!(GenericParamKind; Lifetime Type(default) Const(ty kw_span default));
-spanless_eq_enum!(ImplPolarity; Positive Negative(0));
-spanless_eq_enum!(Inline; Yes No);
-spanless_eq_enum!(InlineAsmRegOrRegClass; Reg(0) RegClass(0));
-spanless_eq_enum!(InlineAsmTemplatePiece; String(0) Placeholder(operand_idx modifier span));
-spanless_eq_enum!(IntTy; Isize I8 I16 I32 I64 I128);
-spanless_eq_enum!(IsAuto; Yes No);
-spanless_eq_enum!(LitFloatType; Suffixed(0) Unsuffixed);
-spanless_eq_enum!(LitIntType; Signed(0) Unsigned(0) Unsuffixed);
-spanless_eq_enum!(LlvmAsmDialect; Att Intel);
-spanless_eq_enum!(MacArgs; Empty Delimited(0 1 2) Eq(0 1));
-spanless_eq_enum!(MacDelimiter; Parenthesis Bracket Brace);
-spanless_eq_enum!(MacStmtStyle; Semicolon Braces NoBraces);
-spanless_eq_enum!(ModKind; Loaded(0 1 2) Unloaded);
-spanless_eq_enum!(Movability; Static Movable);
-spanless_eq_enum!(Mutability; Mut Not);
-spanless_eq_enum!(RangeEnd; Included(0) Excluded);
-spanless_eq_enum!(RangeLimits; HalfOpen Closed);
-spanless_eq_enum!(StmtKind; Local(0) Item(0) Expr(0) Semi(0) Empty MacCall(0));
-spanless_eq_enum!(StrStyle; Cooked Raw(0));
-spanless_eq_enum!(StructRest; Base(0) Rest(0) None);
-spanless_eq_enum!(TokenTree; Token(0) Delimited(0 1 2));
-spanless_eq_enum!(TraitBoundModifier; None Maybe MaybeConst MaybeConstMaybe);
-spanless_eq_enum!(TraitObjectSyntax; Dyn None);
-spanless_eq_enum!(UintTy; Usize U8 U16 U32 U64 U128);
-spanless_eq_enum!(UnOp; Deref Not Neg);
-spanless_eq_enum!(Unsafe; Yes(0) No);
-spanless_eq_enum!(UnsafeSource; CompilerGenerated UserProvided);
-spanless_eq_enum!(UseTreeKind; Simple(0 1 2) Nested(0) Glob);
-spanless_eq_enum!(VariantData; Struct(0 1) Tuple(0 1) Unit(0));
-spanless_eq_enum!(VisibilityKind; Public Crate(0) Restricted(path id) Inherited);
-spanless_eq_enum!(WherePredicate; BoundPredicate(0) RegionPredicate(0) EqPredicate(0));
-spanless_eq_enum!(ExprKind; Box(0) Array(0) ConstBlock(0) Call(0 1)
-    MethodCall(0 1 2) Tup(0) Binary(0 1 2) Unary(0 1) Lit(0) Cast(0 1) Type(0 1)
-    Let(0 1 2) If(0 1 2) While(0 1 2) ForLoop(0 1 2 3) Loop(0 1) Match(0 1)
-    Closure(0 1 2 3 4 5) Block(0 1) Async(0 1 2) Await(0) TryBlock(0)
-    Assign(0 1 2) AssignOp(0 1 2) Field(0 1) Index(0 1) Underscore Range(0 1 2)
-    Path(0 1) AddrOf(0 1 2) Break(0 1) Continue(0) Ret(0) InlineAsm(0)
-    LlvmInlineAsm(0) MacCall(0) Struct(0) Repeat(0 1) Paren(0) Try(0) Yield(0)
-    Err);
-spanless_eq_enum!(InlineAsmOperand; In(reg expr) Out(reg late expr)
-    InOut(reg late expr) SplitInOut(reg late in_expr out_expr) Const(anon_const)
-    Sym(expr));
-spanless_eq_enum!(ItemKind; ExternCrate(0) Use(0) Static(0 1 2) Const(0 1 2)
-    Fn(0) Mod(0 1) ForeignMod(0) GlobalAsm(0) TyAlias(0) Enum(0 1) Struct(0 1)
-    Union(0 1) Trait(0) TraitAlias(0 1) Impl(0) MacCall(0) MacroDef(0));
-spanless_eq_enum!(LitKind; Str(0 1) ByteStr(0) Byte(0) Char(0) Int(0 1)
-    Float(0 1) Bool(0) Err(0));
-spanless_eq_enum!(PatKind; Wild Ident(0 1 2) Struct(0 1 2 3) TupleStruct(0 1 2)
-    Or(0) Path(0 1) Tuple(0) Box(0) Ref(0 1) Lit(0) Range(0 1 2) Slice(0) Rest
-    Paren(0) MacCall(0));
-spanless_eq_enum!(TyKind; Slice(0) Array(0 1) Ptr(0) Rptr(0 1) BareFn(0) Never
-    Tup(0) AnonymousStruct(0 1) AnonymousUnion(0 1) Path(0 1) TraitObject(0 1)
-    ImplTrait(0 1) Paren(0) Typeof(0) Infer ImplicitSelf MacCall(0) Err
-    CVarArgs);
-
-impl SpanlessEq for Ident {
-    fn eq(&self, other: &Self) -> bool {
-        self.as_str() == other.as_str()
-    }
-}
-
-impl SpanlessEq for RangeSyntax {
-    fn eq(&self, _other: &Self) -> bool {
-        match self {
-            RangeSyntax::DotDotDot | RangeSyntax::DotDotEq => true,
-        }
-    }
-}
-
-impl SpanlessEq for Param {
-    fn eq(&self, other: &Self) -> bool {
-        let Param {
-            attrs,
-            ty,
-            pat,
-            id,
-            span: _,
-            is_placeholder,
-        } = self;
-        let Param {
-            attrs: attrs2,
-            ty: ty2,
-            pat: pat2,
-            id: id2,
-            span: _,
-            is_placeholder: is_placeholder2,
-        } = other;
-        SpanlessEq::eq(id, id2)
-            && SpanlessEq::eq(is_placeholder, is_placeholder2)
-            && (matches!(ty.kind, TyKind::Err)
-                || matches!(ty2.kind, TyKind::Err)
-                || SpanlessEq::eq(attrs, attrs2)
-                    && SpanlessEq::eq(ty, ty2)
-                    && SpanlessEq::eq(pat, pat2))
-    }
-}
-
-impl SpanlessEq for TokenKind {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (TokenKind::Literal(this), TokenKind::Literal(other)) => SpanlessEq::eq(this, other),
-            (TokenKind::DotDotEq, _) | (TokenKind::DotDotDot, _) => match other {
-                TokenKind::DotDotEq | TokenKind::DotDotDot => true,
-                _ => false,
-            },
-            (TokenKind::Interpolated(this), TokenKind::Interpolated(other)) => {
-                match (this.as_ref(), other.as_ref()) {
-                    (Nonterminal::NtExpr(this), Nonterminal::NtExpr(other)) => {
-                        SpanlessEq::eq(this, other)
-                    }
-                    _ => this == other,
-                }
-            }
-            _ => self == other,
-        }
-    }
-}
-
-impl SpanlessEq for TokenStream {
-    fn eq(&self, other: &Self) -> bool {
-        let mut this_trees = self.trees();
-        let mut other_trees = other.trees();
-        loop {
-            let this = match this_trees.next() {
-                None => return other_trees.next().is_none(),
-                Some(tree) => tree,
-            };
-            let other = match other_trees.next() {
-                None => return false,
-                Some(tree) => tree,
-            };
-            if SpanlessEq::eq(&this, &other) {
-                continue;
-            }
-            if let (TokenTree::Token(this), TokenTree::Token(other)) = (this, other) {
-                if match (&this.kind, &other.kind) {
-                    (TokenKind::Literal(this), TokenKind::Literal(other)) => {
-                        SpanlessEq::eq(this, other)
-                    }
-                    (TokenKind::DocComment(_kind, style, symbol), TokenKind::Pound) => {
-                        doc_comment(*style, *symbol, &mut other_trees)
-                    }
-                    (TokenKind::Pound, TokenKind::DocComment(_kind, style, symbol)) => {
-                        doc_comment(*style, *symbol, &mut this_trees)
-                    }
-                    _ => false,
-                } {
-                    continue;
-                }
-            }
-            return false;
-        }
-    }
-}
-
-fn doc_comment<'a>(
-    style: AttrStyle,
-    unescaped: Symbol,
-    trees: &mut impl Iterator<Item = TokenTree>,
-) -> bool {
-    if match style {
-        AttrStyle::Outer => false,
-        AttrStyle::Inner => true,
-    } {
-        match trees.next() {
-            Some(TokenTree::Token(Token {
-                kind: TokenKind::Not,
-                span: _,
-            })) => {}
-            _ => return false,
-        }
-    }
-    let stream = match trees.next() {
-        Some(TokenTree::Delimited(_span, DelimToken::Bracket, stream)) => stream,
-        _ => return false,
-    };
-    let mut trees = stream.trees();
-    match trees.next() {
-        Some(TokenTree::Token(Token {
-            kind: TokenKind::Ident(symbol, false),
-            span: _,
-        })) if symbol == sym::doc => {}
-        _ => return false,
-    }
-    match trees.next() {
-        Some(TokenTree::Token(Token {
-            kind: TokenKind::Eq,
-            span: _,
-        })) => {}
-        _ => return false,
-    }
-    match trees.next() {
-        Some(TokenTree::Token(token)) => {
-            is_escaped_literal(&token, unescaped) && trees.next().is_none()
-        }
-        _ => false,
-    }
-}
-
-fn is_escaped_literal(token: &Token, unescaped: Symbol) -> bool {
-    match match token {
-        Token {
-            kind: TokenKind::Literal(lit),
-            span: _,
-        } => Lit::from_lit_token(*lit, DUMMY_SP),
-        Token {
-            kind: TokenKind::Interpolated(nonterminal),
-            span: _,
-        } => match nonterminal.as_ref() {
-            Nonterminal::NtExpr(expr) => match &expr.kind {
-                ExprKind::Lit(lit) => Ok(lit.clone()),
-                _ => return false,
-            },
-            _ => return false,
-        },
-        _ => return false,
-    } {
-        Ok(Lit {
-            token:
-                token::Lit {
-                    kind: token::LitKind::Str,
-                    symbol: _,
-                    suffix: None,
-                },
-            kind: LitKind::Str(symbol, StrStyle::Cooked),
-            span: _,
-        }) => symbol.as_str().replace('\r', "") == unescaped.as_str().replace('\r', ""),
-        _ => false,
-    }
-}
-
-impl SpanlessEq for LazyTokenStream {
-    fn eq(&self, other: &Self) -> bool {
-        let this = self.create_token_stream();
-        let other = other.create_token_stream();
-        SpanlessEq::eq(&this, &other)
-    }
-}
-
-impl SpanlessEq for AttrKind {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (AttrKind::Normal(item, tokens), AttrKind::Normal(item2, tokens2)) => {
-                SpanlessEq::eq(item, item2) && SpanlessEq::eq(tokens, tokens2)
-            }
-            (AttrKind::DocComment(kind, symbol), AttrKind::DocComment(kind2, symbol2)) => {
-                SpanlessEq::eq(kind, kind2) && SpanlessEq::eq(symbol, symbol2)
-            }
-            (AttrKind::DocComment(kind, unescaped), AttrKind::Normal(item2, _tokens)) => {
-                match kind {
-                    CommentKind::Line | CommentKind::Block => {}
-                }
-                let path = Path::from_ident(Ident::with_dummy_span(sym::doc));
-                SpanlessEq::eq(&path, &item2.path)
-                    && match &item2.args {
-                        MacArgs::Empty | MacArgs::Delimited(..) => false,
-                        MacArgs::Eq(_span, token) => is_escaped_literal(token, *unescaped),
-                    }
-            }
-            (AttrKind::Normal(..), AttrKind::DocComment(..)) => SpanlessEq::eq(other, self),
-        }
-    }
-}
diff --git a/vendor/syn/tests/common/mod.rs b/vendor/syn/tests/common/mod.rs
deleted file mode 100644
index a1cc80a1..00000000
--- a/vendor/syn/tests/common/mod.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![allow(dead_code)]
-
-use rayon::ThreadPoolBuilder;
-use std::env;
-
-pub mod eq;
-pub mod parse;
-
-/// Read the `ABORT_AFTER_FAILURE` environment variable, and parse it.
-pub fn abort_after() -> usize {
-    match env::var("ABORT_AFTER_FAILURE") {
-        Ok(s) => s.parse().expect("failed to parse ABORT_AFTER_FAILURE"),
-        Err(_) => usize::max_value(),
-    }
-}
-
-/// Configure Rayon threadpool.
-pub fn rayon_init() {
-    let stack_size = match env::var("RUST_MIN_STACK") {
-        Ok(s) => s.parse().expect("failed to parse RUST_MIN_STACK"),
-        Err(_) => 20 * 1024 * 1024,
-    };
-    ThreadPoolBuilder::new()
-        .stack_size(stack_size)
-        .build_global()
-        .unwrap();
-}
diff --git a/vendor/syn/tests/common/parse.rs b/vendor/syn/tests/common/parse.rs
deleted file mode 100644
index 636d0a37..00000000
--- a/vendor/syn/tests/common/parse.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-extern crate rustc_ast;
-extern crate rustc_expand;
-extern crate rustc_parse as parse;
-extern crate rustc_session;
-extern crate rustc_span;
-
-use rustc_ast::ast;
-use rustc_ast::ptr::P;
-use rustc_session::parse::ParseSess;
-use rustc_span::source_map::FilePathMapping;
-use rustc_span::FileName;
-use std::panic;
-
-pub fn librustc_expr(input: &str) -> Option<P<ast::Expr>> {
-    match panic::catch_unwind(|| {
-        let sess = ParseSess::new(FilePathMapping::empty());
-        let e = parse::new_parser_from_source_str(
-            &sess,
-            FileName::Custom("test_precedence".to_string()),
-            input.to_string(),
-        )
-        .parse_expr();
-        match e {
-            Ok(expr) => Some(expr),
-            Err(mut diagnostic) => {
-                diagnostic.emit();
-                None
-            }
-        }
-    }) {
-        Ok(Some(e)) => Some(e),
-        Ok(None) => None,
-        Err(_) => {
-            errorf!("librustc panicked\n");
-            None
-        }
-    }
-}
-
-pub fn syn_expr(input: &str) -> Option<syn::Expr> {
-    match syn::parse_str(input) {
-        Ok(e) => Some(e),
-        Err(msg) => {
-            errorf!("syn failed to parse\n{:?}\n", msg);
-            None
-        }
-    }
-}
diff --git a/vendor/syn/tests/debug/gen.rs b/vendor/syn/tests/debug/gen.rs
deleted file mode 100644
index 1eae327b..00000000
--- a/vendor/syn/tests/debug/gen.rs
+++ /dev/null
@@ -1,5645 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-use super::{Lite, RefCast};
-use std::fmt::{self, Debug, Display};
-impl Debug for Lite<syn::Abi> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Abi");
-        if let Some(val) = &_val.name {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::LitStr);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("name", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::AngleBracketedGenericArguments> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
-        if let Some(val) = &_val.colon2_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon2);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon2_token", Print::ref_cast(val));
-        }
-        if !_val.args.is_empty() {
-            formatter.field("args", Lite(&_val.args));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Arm> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Arm");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        if let Some(val) = &_val.guard {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::If, Box<syn::Expr>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("guard", Print::ref_cast(val));
-        }
-        formatter.field("body", Lite(&_val.body));
-        if let Some(val) = &_val.comma {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Comma);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("comma", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::AttrStyle> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::AttrStyle::Outer => formatter.write_str("Outer"),
-            syn::AttrStyle::Inner(_val) => {
-                formatter.write_str("Inner")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Attribute> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Attribute");
-        formatter.field("style", Lite(&_val.style));
-        formatter.field("path", Lite(&_val.path));
-        formatter.field("tokens", Lite(&_val.tokens));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::BareFnArg> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("BareFnArg");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.name {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((proc_macro2::Ident, syn::token::Colon));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.0), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("name", Print::ref_cast(val));
-        }
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::BinOp> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::BinOp::Add(_val) => {
-                formatter.write_str("Add")?;
-                Ok(())
-            }
-            syn::BinOp::Sub(_val) => {
-                formatter.write_str("Sub")?;
-                Ok(())
-            }
-            syn::BinOp::Mul(_val) => {
-                formatter.write_str("Mul")?;
-                Ok(())
-            }
-            syn::BinOp::Div(_val) => {
-                formatter.write_str("Div")?;
-                Ok(())
-            }
-            syn::BinOp::Rem(_val) => {
-                formatter.write_str("Rem")?;
-                Ok(())
-            }
-            syn::BinOp::And(_val) => {
-                formatter.write_str("And")?;
-                Ok(())
-            }
-            syn::BinOp::Or(_val) => {
-                formatter.write_str("Or")?;
-                Ok(())
-            }
-            syn::BinOp::BitXor(_val) => {
-                formatter.write_str("BitXor")?;
-                Ok(())
-            }
-            syn::BinOp::BitAnd(_val) => {
-                formatter.write_str("BitAnd")?;
-                Ok(())
-            }
-            syn::BinOp::BitOr(_val) => {
-                formatter.write_str("BitOr")?;
-                Ok(())
-            }
-            syn::BinOp::Shl(_val) => {
-                formatter.write_str("Shl")?;
-                Ok(())
-            }
-            syn::BinOp::Shr(_val) => {
-                formatter.write_str("Shr")?;
-                Ok(())
-            }
-            syn::BinOp::Eq(_val) => {
-                formatter.write_str("Eq")?;
-                Ok(())
-            }
-            syn::BinOp::Lt(_val) => {
-                formatter.write_str("Lt")?;
-                Ok(())
-            }
-            syn::BinOp::Le(_val) => {
-                formatter.write_str("Le")?;
-                Ok(())
-            }
-            syn::BinOp::Ne(_val) => {
-                formatter.write_str("Ne")?;
-                Ok(())
-            }
-            syn::BinOp::Ge(_val) => {
-                formatter.write_str("Ge")?;
-                Ok(())
-            }
-            syn::BinOp::Gt(_val) => {
-                formatter.write_str("Gt")?;
-                Ok(())
-            }
-            syn::BinOp::AddEq(_val) => {
-                formatter.write_str("AddEq")?;
-                Ok(())
-            }
-            syn::BinOp::SubEq(_val) => {
-                formatter.write_str("SubEq")?;
-                Ok(())
-            }
-            syn::BinOp::MulEq(_val) => {
-                formatter.write_str("MulEq")?;
-                Ok(())
-            }
-            syn::BinOp::DivEq(_val) => {
-                formatter.write_str("DivEq")?;
-                Ok(())
-            }
-            syn::BinOp::RemEq(_val) => {
-                formatter.write_str("RemEq")?;
-                Ok(())
-            }
-            syn::BinOp::BitXorEq(_val) => {
-                formatter.write_str("BitXorEq")?;
-                Ok(())
-            }
-            syn::BinOp::BitAndEq(_val) => {
-                formatter.write_str("BitAndEq")?;
-                Ok(())
-            }
-            syn::BinOp::BitOrEq(_val) => {
-                formatter.write_str("BitOrEq")?;
-                Ok(())
-            }
-            syn::BinOp::ShlEq(_val) => {
-                formatter.write_str("ShlEq")?;
-                Ok(())
-            }
-            syn::BinOp::ShrEq(_val) => {
-                formatter.write_str("ShrEq")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Binding> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Binding");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Block> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Block");
-        if !_val.stmts.is_empty() {
-            formatter.field("stmts", Lite(&_val.stmts));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::BoundLifetimes> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("BoundLifetimes");
-        if !_val.lifetimes.is_empty() {
-            formatter.field("lifetimes", Lite(&_val.lifetimes));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ConstParam> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ConstParam");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        if let Some(val) = &_val.eq_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Eq);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("eq_token", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.default {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Expr);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("default", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Constraint> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Constraint");
-        formatter.field("ident", Lite(&_val.ident));
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Data> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Data::Struct(_val) => {
-                let mut formatter = formatter.debug_struct("Data::Struct");
-                formatter.field("fields", Lite(&_val.fields));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Data::Enum(_val) => {
-                let mut formatter = formatter.debug_struct("Data::Enum");
-                if !_val.variants.is_empty() {
-                    formatter.field("variants", Lite(&_val.variants));
-                }
-                formatter.finish()
-            }
-            syn::Data::Union(_val) => {
-                let mut formatter = formatter.debug_struct("Data::Union");
-                formatter.field("fields", Lite(&_val.fields));
-                formatter.finish()
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::DataEnum> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("DataEnum");
-        if !_val.variants.is_empty() {
-            formatter.field("variants", Lite(&_val.variants));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::DataStruct> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("DataStruct");
-        formatter.field("fields", Lite(&_val.fields));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::DataUnion> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("DataUnion");
-        formatter.field("fields", Lite(&_val.fields));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::DeriveInput> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("DeriveInput");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        formatter.field("data", Lite(&_val.data));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Expr> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Expr::Array(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Array");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if !_val.elems.is_empty() {
-                    formatter.field("elems", Lite(&_val.elems));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Assign(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Assign");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("left", Lite(&_val.left));
-                formatter.field("right", Lite(&_val.right));
-                formatter.finish()
-            }
-            syn::Expr::AssignOp(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::AssignOp");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("left", Lite(&_val.left));
-                formatter.field("op", Lite(&_val.op));
-                formatter.field("right", Lite(&_val.right));
-                formatter.finish()
-            }
-            syn::Expr::Async(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Async");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.capture {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Move);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("capture", Print::ref_cast(val));
-                }
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::Expr::Await(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Await");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("base", Lite(&_val.base));
-                formatter.finish()
-            }
-            syn::Expr::Binary(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Binary");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("left", Lite(&_val.left));
-                formatter.field("op", Lite(&_val.op));
-                formatter.field("right", Lite(&_val.right));
-                formatter.finish()
-            }
-            syn::Expr::Block(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Block");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Label);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::Expr::Box(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Box");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::Break(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Break");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Lifetime);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.expr {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("expr", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Call(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Call");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("func", Lite(&_val.func));
-                if !_val.args.is_empty() {
-                    formatter.field("args", Lite(&_val.args));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Cast(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Cast");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::Expr::Closure(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Closure");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.asyncness {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Async);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("asyncness", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.movability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Static);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("movability", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.capture {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Move);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("capture", Print::ref_cast(val));
-                }
-                if !_val.inputs.is_empty() {
-                    formatter.field("inputs", Lite(&_val.inputs));
-                }
-                formatter.field("output", Lite(&_val.output));
-                formatter.field("body", Lite(&_val.body));
-                formatter.finish()
-            }
-            syn::Expr::Continue(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Continue");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Lifetime);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Field(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Field");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("base", Lite(&_val.base));
-                formatter.field("member", Lite(&_val.member));
-                formatter.finish()
-            }
-            syn::Expr::ForLoop(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::ForLoop");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Label);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.field("body", Lite(&_val.body));
-                formatter.finish()
-            }
-            syn::Expr::Group(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Group");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::If(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::If");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("cond", Lite(&_val.cond));
-                formatter.field("then_branch", Lite(&_val.then_branch));
-                if let Some(val) = &_val.else_branch {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::Else, Box<syn::Expr>));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("else_branch", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Index(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Index");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.field("index", Lite(&_val.index));
-                formatter.finish()
-            }
-            syn::Expr::Let(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Let");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::Lit(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Lit");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("lit", Lite(&_val.lit));
-                formatter.finish()
-            }
-            syn::Expr::Loop(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Loop");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Label);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                formatter.field("body", Lite(&_val.body));
-                formatter.finish()
-            }
-            syn::Expr::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                formatter.finish()
-            }
-            syn::Expr::Match(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Match");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                if !_val.arms.is_empty() {
-                    formatter.field("arms", Lite(&_val.arms));
-                }
-                formatter.finish()
-            }
-            syn::Expr::MethodCall(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::MethodCall");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("receiver", Lite(&_val.receiver));
-                formatter.field("method", Lite(&_val.method));
-                if let Some(val) = &_val.turbofish {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::MethodTurbofish);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("turbofish", Print::ref_cast(val));
-                }
-                if !_val.args.is_empty() {
-                    formatter.field("args", Lite(&_val.args));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Paren(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Paren");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::Path(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Path");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.qself {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::QSelf);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("qself", Print::ref_cast(val));
-                }
-                formatter.field("path", Lite(&_val.path));
-                formatter.finish()
-            }
-            syn::Expr::Range(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Range");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.from {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("from", Print::ref_cast(val));
-                }
-                formatter.field("limits", Lite(&_val.limits));
-                if let Some(val) = &_val.to {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("to", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Reference(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Reference");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::Repeat(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Repeat");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.field("len", Lite(&_val.len));
-                formatter.finish()
-            }
-            syn::Expr::Return(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Return");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.expr {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("expr", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Struct(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Struct");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("path", Lite(&_val.path));
-                if !_val.fields.is_empty() {
-                    formatter.field("fields", Lite(&_val.fields));
-                }
-                if let Some(val) = &_val.dot2_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Dot2);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("dot2_token", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.rest {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("rest", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Try(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Try");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::TryBlock(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::TryBlock");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::Expr::Tuple(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Tuple");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if !_val.elems.is_empty() {
-                    formatter.field("elems", Lite(&_val.elems));
-                }
-                formatter.finish()
-            }
-            syn::Expr::Type(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::Expr::Unary(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Unary");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("op", Lite(&_val.op));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Expr::Unsafe(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Unsafe");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::Expr::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            syn::Expr::While(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::While");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.label {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Label);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("label", Print::ref_cast(val));
-                }
-                formatter.field("cond", Lite(&_val.cond));
-                formatter.field("body", Lite(&_val.body));
-                formatter.finish()
-            }
-            syn::Expr::Yield(_val) => {
-                let mut formatter = formatter.debug_struct("Expr::Yield");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.expr {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(Box<syn::Expr>);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("expr", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::ExprArray> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprArray");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if !_val.elems.is_empty() {
-            formatter.field("elems", Lite(&_val.elems));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprAssign> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprAssign");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("left", Lite(&_val.left));
-        formatter.field("right", Lite(&_val.right));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprAssignOp> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprAssignOp");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("left", Lite(&_val.left));
-        formatter.field("op", Lite(&_val.op));
-        formatter.field("right", Lite(&_val.right));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprAsync> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprAsync");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.capture {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Move);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("capture", Print::ref_cast(val));
-        }
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprAwait> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprAwait");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("base", Lite(&_val.base));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprBinary> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprBinary");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("left", Lite(&_val.left));
-        formatter.field("op", Lite(&_val.op));
-        formatter.field("right", Lite(&_val.right));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprBlock> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprBlock");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Label);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprBox> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprBox");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprBreak> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprBreak");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Lifetime);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.expr {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("expr", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprCall> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprCall");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("func", Lite(&_val.func));
-        if !_val.args.is_empty() {
-            formatter.field("args", Lite(&_val.args));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprCast> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprCast");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprClosure> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprClosure");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.asyncness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Async);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("asyncness", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.movability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Static);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("movability", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.capture {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Move);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("capture", Print::ref_cast(val));
-        }
-        if !_val.inputs.is_empty() {
-            formatter.field("inputs", Lite(&_val.inputs));
-        }
-        formatter.field("output", Lite(&_val.output));
-        formatter.field("body", Lite(&_val.body));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprContinue> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprContinue");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Lifetime);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprField> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprField");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("base", Lite(&_val.base));
-        formatter.field("member", Lite(&_val.member));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprForLoop> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprForLoop");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Label);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.field("body", Lite(&_val.body));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprGroup> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprGroup");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprIf> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprIf");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("cond", Lite(&_val.cond));
-        formatter.field("then_branch", Lite(&_val.then_branch));
-        if let Some(val) = &_val.else_branch {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Else, Box<syn::Expr>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("else_branch", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprIndex> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprIndex");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.field("index", Lite(&_val.index));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprLet> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprLet");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprLit> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprLit");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("lit", Lite(&_val.lit));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprLoop> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprLoop");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Label);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        formatter.field("body", Lite(&_val.body));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprMatch> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprMatch");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        if !_val.arms.is_empty() {
-            formatter.field("arms", Lite(&_val.arms));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprMethodCall> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprMethodCall");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("receiver", Lite(&_val.receiver));
-        formatter.field("method", Lite(&_val.method));
-        if let Some(val) = &_val.turbofish {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::MethodTurbofish);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("turbofish", Print::ref_cast(val));
-        }
-        if !_val.args.is_empty() {
-            formatter.field("args", Lite(&_val.args));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprParen> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprParen");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprPath> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprPath");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.qself {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::QSelf);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("qself", Print::ref_cast(val));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprRange> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprRange");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.from {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("from", Print::ref_cast(val));
-        }
-        formatter.field("limits", Lite(&_val.limits));
-        if let Some(val) = &_val.to {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("to", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprReference> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprReference");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprRepeat> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprRepeat");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.field("len", Lite(&_val.len));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprReturn> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprReturn");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.expr {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("expr", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprStruct> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprStruct");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("path", Lite(&_val.path));
-        if !_val.fields.is_empty() {
-            formatter.field("fields", Lite(&_val.fields));
-        }
-        if let Some(val) = &_val.dot2_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Dot2);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("dot2_token", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.rest {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("rest", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprTry> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprTry");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprTryBlock> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprTryBlock");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprTuple> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprTuple");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if !_val.elems.is_empty() {
-            formatter.field("elems", Lite(&_val.elems));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprUnary> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprUnary");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("op", Lite(&_val.op));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprUnsafe> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprUnsafe");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprWhile> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprWhile");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.label {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Label);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("label", Print::ref_cast(val));
-        }
-        formatter.field("cond", Lite(&_val.cond));
-        formatter.field("body", Lite(&_val.body));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ExprYield> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ExprYield");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.expr {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(Box<syn::Expr>);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("expr", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Field> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Field");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.ident {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(proc_macro2::Ident);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("ident", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::FieldPat> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("FieldPat");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("member", Lite(&_val.member));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::FieldValue> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("FieldValue");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("member", Lite(&_val.member));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Fields> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Fields::Named(_val) => {
-                let mut formatter = formatter.debug_struct("Fields::Named");
-                if !_val.named.is_empty() {
-                    formatter.field("named", Lite(&_val.named));
-                }
-                formatter.finish()
-            }
-            syn::Fields::Unnamed(_val) => {
-                let mut formatter = formatter.debug_struct("Fields::Unnamed");
-                if !_val.unnamed.is_empty() {
-                    formatter.field("unnamed", Lite(&_val.unnamed));
-                }
-                formatter.finish()
-            }
-            syn::Fields::Unit => formatter.write_str("Unit"),
-        }
-    }
-}
-impl Debug for Lite<syn::FieldsNamed> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("FieldsNamed");
-        if !_val.named.is_empty() {
-            formatter.field("named", Lite(&_val.named));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::FieldsUnnamed> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("FieldsUnnamed");
-        if !_val.unnamed.is_empty() {
-            formatter.field("unnamed", Lite(&_val.unnamed));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::File> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("File");
-        if let Some(val) = &_val.shebang {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(String);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("shebang", Print::ref_cast(val));
-        }
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if !_val.items.is_empty() {
-            formatter.field("items", Lite(&_val.items));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::FnArg> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::FnArg::Receiver(_val) => {
-                formatter.write_str("Receiver")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::FnArg::Typed(_val) => {
-                formatter.write_str("Typed")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::ForeignItem> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::ForeignItem::Fn(_val) => {
-                let mut formatter = formatter.debug_struct("ForeignItem::Fn");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("sig", Lite(&_val.sig));
-                formatter.finish()
-            }
-            syn::ForeignItem::Static(_val) => {
-                let mut formatter = formatter.debug_struct("ForeignItem::Static");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::ForeignItem::Type(_val) => {
-                let mut formatter = formatter.debug_struct("ForeignItem::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.finish()
-            }
-            syn::ForeignItem::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("ForeignItem::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::ForeignItem::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::ForeignItemFn> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ForeignItemFn");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("sig", Lite(&_val.sig));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ForeignItemMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ForeignItemMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ForeignItemStatic> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ForeignItemStatic");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ForeignItemType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ForeignItemType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::GenericArgument> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::GenericArgument::Lifetime(_val) => {
-                formatter.write_str("Lifetime")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericArgument::Type(_val) => {
-                formatter.write_str("Type")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericArgument::Binding(_val) => {
-                formatter.write_str("Binding")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericArgument::Constraint(_val) => {
-                formatter.write_str("Constraint")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericArgument::Const(_val) => {
-                formatter.write_str("Const")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::GenericMethodArgument> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::GenericMethodArgument::Type(_val) => {
-                formatter.write_str("Type")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericMethodArgument::Const(_val) => {
-                formatter.write_str("Const")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::GenericParam> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::GenericParam::Type(_val) => {
-                formatter.write_str("Type")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericParam::Lifetime(_val) => {
-                formatter.write_str("Lifetime")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::GenericParam::Const(_val) => {
-                formatter.write_str("Const")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Generics> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Generics");
-        if let Some(val) = &_val.lt_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Lt);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("lt_token", Print::ref_cast(val));
-        }
-        if !_val.params.is_empty() {
-            formatter.field("params", Lite(&_val.params));
-        }
-        if let Some(val) = &_val.gt_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Gt);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("gt_token", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.where_clause {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::WhereClause);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("where_clause", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ImplItem> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::ImplItem::Const(_val) => {
-                let mut formatter = formatter.debug_struct("ImplItem::Const");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.defaultness {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Default);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("defaultness", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::ImplItem::Method(_val) => {
-                let mut formatter = formatter.debug_struct("ImplItem::Method");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.defaultness {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Default);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("defaultness", Print::ref_cast(val));
-                }
-                formatter.field("sig", Lite(&_val.sig));
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::ImplItem::Type(_val) => {
-                let mut formatter = formatter.debug_struct("ImplItem::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.defaultness {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Default);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("defaultness", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::ImplItem::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("ImplItem::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::ImplItem::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::ImplItemConst> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ImplItemConst");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.defaultness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Default);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("defaultness", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ImplItemMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ImplItemMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ImplItemMethod> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ImplItemMethod");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.defaultness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Default);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("defaultness", Print::ref_cast(val));
-        }
-        formatter.field("sig", Lite(&_val.sig));
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ImplItemType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ImplItemType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.defaultness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Default);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("defaultness", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Index> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Index");
-        formatter.field("index", Lite(&_val.index));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Item> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Item::Const(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Const");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Item::Enum(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Enum");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                if !_val.variants.is_empty() {
-                    formatter.field("variants", Lite(&_val.variants));
-                }
-                formatter.finish()
-            }
-            syn::Item::ExternCrate(_val) => {
-                let mut formatter = formatter.debug_struct("Item::ExternCrate");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                if let Some(val) = &_val.rename {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::As, proc_macro2::Ident));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("rename", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Item::Fn(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Fn");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("sig", Lite(&_val.sig));
-                formatter.field("block", Lite(&_val.block));
-                formatter.finish()
-            }
-            syn::Item::ForeignMod(_val) => {
-                let mut formatter = formatter.debug_struct("Item::ForeignMod");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("abi", Lite(&_val.abi));
-                if !_val.items.is_empty() {
-                    formatter.field("items", Lite(&_val.items));
-                }
-                formatter.finish()
-            }
-            syn::Item::Impl(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Impl");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.defaultness {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Default);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("defaultness", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.unsafety {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Unsafe);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("unsafety", Print::ref_cast(val));
-                }
-                formatter.field("generics", Lite(&_val.generics));
-                if let Some(val) = &_val.trait_ {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((Option<syn::token::Bang>, syn::Path, syn::token::For));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(
-                                &(
-                                    {
-                                        #[derive(RefCast)]
-                                        #[repr(transparent)]
-                                        struct Print(Option<syn::token::Bang>);
-                                        impl Debug for Print {
-                                            fn fmt(
-                                                &self,
-                                                formatter: &mut fmt::Formatter,
-                                            ) -> fmt::Result
-                                            {
-                                                match &self.0 {
-                                                    Some(_val) => {
-                                                        formatter.write_str("Some")?;
-                                                        Ok(())
-                                                    }
-                                                    None => formatter.write_str("None"),
-                                                }
-                                            }
-                                        }
-                                        Print::ref_cast(&_val.0)
-                                    },
-                                    Lite(&_val.1),
-                                ),
-                                formatter,
-                            )?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("trait_", Print::ref_cast(val));
-                }
-                formatter.field("self_ty", Lite(&_val.self_ty));
-                if !_val.items.is_empty() {
-                    formatter.field("items", Lite(&_val.items));
-                }
-                formatter.finish()
-            }
-            syn::Item::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.ident {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(proc_macro2::Ident);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("ident", Print::ref_cast(val));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Item::Macro2(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Macro2");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("rules", Lite(&_val.rules));
-                formatter.finish()
-            }
-            syn::Item::Mod(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Mod");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                if let Some(val) = &_val.content {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::Brace, Vec<syn::Item>));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("content", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.semi {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Item::Static(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Static");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Item::Struct(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Struct");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                formatter.field("fields", Lite(&_val.fields));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Item::Trait(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Trait");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.unsafety {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Unsafe);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("unsafety", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.auto_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Auto);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("auto_token", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                if let Some(val) = &_val.colon_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Colon);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("colon_token", Print::ref_cast(val));
-                }
-                if !_val.supertraits.is_empty() {
-                    formatter.field("supertraits", Lite(&_val.supertraits));
-                }
-                if !_val.items.is_empty() {
-                    formatter.field("items", Lite(&_val.items));
-                }
-                formatter.finish()
-            }
-            syn::Item::TraitAlias(_val) => {
-                let mut formatter = formatter.debug_struct("Item::TraitAlias");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                if !_val.bounds.is_empty() {
-                    formatter.field("bounds", Lite(&_val.bounds));
-                }
-                formatter.finish()
-            }
-            syn::Item::Type(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::Item::Union(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Union");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                formatter.field("fields", Lite(&_val.fields));
-                formatter.finish()
-            }
-            syn::Item::Use(_val) => {
-                let mut formatter = formatter.debug_struct("Item::Use");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("vis", Lite(&_val.vis));
-                if let Some(val) = &_val.leading_colon {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Colon2);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("leading_colon", Print::ref_cast(val));
-                }
-                formatter.field("tree", Lite(&_val.tree));
-                formatter.finish()
-            }
-            syn::Item::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::ItemConst> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemConst");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemEnum> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemEnum");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        if !_val.variants.is_empty() {
-            formatter.field("variants", Lite(&_val.variants));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemExternCrate> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemExternCrate");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        if let Some(val) = &_val.rename {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::As, proc_macro2::Ident));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("rename", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemFn> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemFn");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("sig", Lite(&_val.sig));
-        formatter.field("block", Lite(&_val.block));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemForeignMod> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemForeignMod");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("abi", Lite(&_val.abi));
-        if !_val.items.is_empty() {
-            formatter.field("items", Lite(&_val.items));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemImpl> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemImpl");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.defaultness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Default);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("defaultness", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.unsafety {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Unsafe);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("unsafety", Print::ref_cast(val));
-        }
-        formatter.field("generics", Lite(&_val.generics));
-        if let Some(val) = &_val.trait_ {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((Option<syn::token::Bang>, syn::Path, syn::token::For));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(
-                        &(
-                            {
-                                #[derive(RefCast)]
-                                #[repr(transparent)]
-                                struct Print(Option<syn::token::Bang>);
-                                impl Debug for Print {
-                                    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                                        match &self.0 {
-                                            Some(_val) => {
-                                                formatter.write_str("Some")?;
-                                                Ok(())
-                                            }
-                                            None => formatter.write_str("None"),
-                                        }
-                                    }
-                                }
-                                Print::ref_cast(&_val.0)
-                            },
-                            Lite(&_val.1),
-                        ),
-                        formatter,
-                    )?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("trait_", Print::ref_cast(val));
-        }
-        formatter.field("self_ty", Lite(&_val.self_ty));
-        if !_val.items.is_empty() {
-            formatter.field("items", Lite(&_val.items));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.ident {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(proc_macro2::Ident);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("ident", Print::ref_cast(val));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemMacro2> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemMacro2");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("rules", Lite(&_val.rules));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemMod> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemMod");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        if let Some(val) = &_val.content {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Brace, Vec<syn::Item>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("content", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.semi {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemStatic> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemStatic");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemStruct> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemStruct");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        formatter.field("fields", Lite(&_val.fields));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemTrait> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemTrait");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.unsafety {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Unsafe);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("unsafety", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.auto_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Auto);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("auto_token", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        if !_val.supertraits.is_empty() {
-            formatter.field("supertraits", Lite(&_val.supertraits));
-        }
-        if !_val.items.is_empty() {
-            formatter.field("items", Lite(&_val.items));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemTraitAlias> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemTraitAlias");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemUnion> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemUnion");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        formatter.field("fields", Lite(&_val.fields));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ItemUse> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ItemUse");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("vis", Lite(&_val.vis));
-        if let Some(val) = &_val.leading_colon {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon2);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("leading_colon", Print::ref_cast(val));
-        }
-        formatter.field("tree", Lite(&_val.tree));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Label> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Label");
-        formatter.field("name", Lite(&_val.name));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Lifetime> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Lifetime");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::LifetimeDef> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("LifetimeDef");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("lifetime", Lite(&_val.lifetime));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Lit> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Lit::Str(_val) => {
-                write!(formatter, "{:?}", _val.value())
-            }
-            syn::Lit::ByteStr(_val) => {
-                write!(formatter, "{:?}", _val.value())
-            }
-            syn::Lit::Byte(_val) => {
-                write!(formatter, "{:?}", _val.value())
-            }
-            syn::Lit::Char(_val) => {
-                write!(formatter, "{:?}", _val.value())
-            }
-            syn::Lit::Int(_val) => {
-                write!(formatter, "{}", _val)
-            }
-            syn::Lit::Float(_val) => {
-                write!(formatter, "{}", _val)
-            }
-            syn::Lit::Bool(_val) => {
-                let mut formatter = formatter.debug_struct("Lit::Bool");
-                formatter.field("value", Lite(&_val.value));
-                formatter.finish()
-            }
-            syn::Lit::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::LitBool> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("LitBool");
-        formatter.field("value", Lite(&_val.value));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::LitByte> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{:?}", _val.value())
-    }
-}
-impl Debug for Lite<syn::LitByteStr> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{:?}", _val.value())
-    }
-}
-impl Debug for Lite<syn::LitChar> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{:?}", _val.value())
-    }
-}
-impl Debug for Lite<syn::LitFloat> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{}", _val)
-    }
-}
-impl Debug for Lite<syn::LitInt> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{}", _val)
-    }
-}
-impl Debug for Lite<syn::LitStr> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        write!(formatter, "{:?}", _val.value())
-    }
-}
-impl Debug for Lite<syn::Local> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Local");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        if let Some(val) = &_val.init {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Eq, Box<syn::Expr>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("init", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Macro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Macro");
-        formatter.field("path", Lite(&_val.path));
-        formatter.field("delimiter", Lite(&_val.delimiter));
-        formatter.field("tokens", Lite(&_val.tokens));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::MacroDelimiter> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::MacroDelimiter::Paren(_val) => {
-                formatter.write_str("Paren")?;
-                Ok(())
-            }
-            syn::MacroDelimiter::Brace(_val) => {
-                formatter.write_str("Brace")?;
-                Ok(())
-            }
-            syn::MacroDelimiter::Bracket(_val) => {
-                formatter.write_str("Bracket")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Member> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Member::Named(_val) => {
-                formatter.write_str("Named")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::Member::Unnamed(_val) => {
-                formatter.write_str("Unnamed")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Meta> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Meta::Path(_val) => {
-                formatter.write_str("Path")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::Meta::List(_val) => {
-                let mut formatter = formatter.debug_struct("Meta::List");
-                formatter.field("path", Lite(&_val.path));
-                if !_val.nested.is_empty() {
-                    formatter.field("nested", Lite(&_val.nested));
-                }
-                formatter.finish()
-            }
-            syn::Meta::NameValue(_val) => {
-                let mut formatter = formatter.debug_struct("Meta::NameValue");
-                formatter.field("path", Lite(&_val.path));
-                formatter.field("lit", Lite(&_val.lit));
-                formatter.finish()
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::MetaList> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("MetaList");
-        formatter.field("path", Lite(&_val.path));
-        if !_val.nested.is_empty() {
-            formatter.field("nested", Lite(&_val.nested));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::MetaNameValue> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("MetaNameValue");
-        formatter.field("path", Lite(&_val.path));
-        formatter.field("lit", Lite(&_val.lit));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::MethodTurbofish> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("MethodTurbofish");
-        if !_val.args.is_empty() {
-            formatter.field("args", Lite(&_val.args));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::NestedMeta> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::NestedMeta::Meta(_val) => {
-                formatter.write_str("Meta")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::NestedMeta::Lit(_val) => {
-                formatter.write_str("Lit")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::ParenthesizedGenericArguments> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
-        if !_val.inputs.is_empty() {
-            formatter.field("inputs", Lite(&_val.inputs));
-        }
-        formatter.field("output", Lite(&_val.output));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Pat> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Pat::Box(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Box");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.finish()
-            }
-            syn::Pat::Ident(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Ident");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.by_ref {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Ref);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("by_ref", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                if let Some(val) = &_val.subpat {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::At, Box<syn::Pat>));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("subpat", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Pat::Lit(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Lit");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("expr", Lite(&_val.expr));
-                formatter.finish()
-            }
-            syn::Pat::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                formatter.finish()
-            }
-            syn::Pat::Or(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Or");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.leading_vert {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Or);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("leading_vert", Print::ref_cast(val));
-                }
-                if !_val.cases.is_empty() {
-                    formatter.field("cases", Lite(&_val.cases));
-                }
-                formatter.finish()
-            }
-            syn::Pat::Path(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Path");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.qself {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::QSelf);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("qself", Print::ref_cast(val));
-                }
-                formatter.field("path", Lite(&_val.path));
-                formatter.finish()
-            }
-            syn::Pat::Range(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Range");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("lo", Lite(&_val.lo));
-                formatter.field("limits", Lite(&_val.limits));
-                formatter.field("hi", Lite(&_val.hi));
-                formatter.finish()
-            }
-            syn::Pat::Reference(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Reference");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.finish()
-            }
-            syn::Pat::Rest(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Rest");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.finish()
-            }
-            syn::Pat::Slice(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Slice");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if !_val.elems.is_empty() {
-                    formatter.field("elems", Lite(&_val.elems));
-                }
-                formatter.finish()
-            }
-            syn::Pat::Struct(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Struct");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("path", Lite(&_val.path));
-                if !_val.fields.is_empty() {
-                    formatter.field("fields", Lite(&_val.fields));
-                }
-                if let Some(val) = &_val.dot2_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Dot2);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("dot2_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::Pat::Tuple(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Tuple");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                if !_val.elems.is_empty() {
-                    formatter.field("elems", Lite(&_val.elems));
-                }
-                formatter.finish()
-            }
-            syn::Pat::TupleStruct(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::TupleStruct");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("path", Lite(&_val.path));
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.finish()
-            }
-            syn::Pat::Type(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("pat", Lite(&_val.pat));
-                formatter.field("ty", Lite(&_val.ty));
-                formatter.finish()
-            }
-            syn::Pat::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            syn::Pat::Wild(_val) => {
-                let mut formatter = formatter.debug_struct("Pat::Wild");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.finish()
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::PatBox> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatBox");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatIdent> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatIdent");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.by_ref {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Ref);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("by_ref", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        if let Some(val) = &_val.subpat {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::At, Box<syn::Pat>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("subpat", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatLit> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatLit");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("expr", Lite(&_val.expr));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatOr> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatOr");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.leading_vert {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Or);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("leading_vert", Print::ref_cast(val));
-        }
-        if !_val.cases.is_empty() {
-            formatter.field("cases", Lite(&_val.cases));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatPath> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatPath");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.qself {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::QSelf);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("qself", Print::ref_cast(val));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatRange> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatRange");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("lo", Lite(&_val.lo));
-        formatter.field("limits", Lite(&_val.limits));
-        formatter.field("hi", Lite(&_val.hi));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatReference> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatReference");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatRest> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatRest");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatSlice> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatSlice");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if !_val.elems.is_empty() {
-            formatter.field("elems", Lite(&_val.elems));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatStruct> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatStruct");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("path", Lite(&_val.path));
-        if !_val.fields.is_empty() {
-            formatter.field("fields", Lite(&_val.fields));
-        }
-        if let Some(val) = &_val.dot2_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Dot2);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("dot2_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatTuple> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatTuple");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if !_val.elems.is_empty() {
-            formatter.field("elems", Lite(&_val.elems));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatTupleStruct> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatTupleStruct");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("pat", Lite(&_val.pat));
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PatWild> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PatWild");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Path> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Path");
-        if let Some(val) = &_val.leading_colon {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon2);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("leading_colon", Print::ref_cast(val));
-        }
-        if !_val.segments.is_empty() {
-            formatter.field("segments", Lite(&_val.segments));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PathArguments> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::PathArguments::None => formatter.write_str("None"),
-            syn::PathArguments::AngleBracketed(_val) => {
-                let mut formatter = formatter.debug_struct("PathArguments::AngleBracketed");
-                if let Some(val) = &_val.colon2_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Colon2);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("colon2_token", Print::ref_cast(val));
-                }
-                if !_val.args.is_empty() {
-                    formatter.field("args", Lite(&_val.args));
-                }
-                formatter.finish()
-            }
-            syn::PathArguments::Parenthesized(_val) => {
-                let mut formatter = formatter.debug_struct("PathArguments::Parenthesized");
-                if !_val.inputs.is_empty() {
-                    formatter.field("inputs", Lite(&_val.inputs));
-                }
-                formatter.field("output", Lite(&_val.output));
-                formatter.finish()
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::PathSegment> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PathSegment");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("arguments", Lite(&_val.arguments));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PredicateEq> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PredicateEq");
-        formatter.field("lhs_ty", Lite(&_val.lhs_ty));
-        formatter.field("rhs_ty", Lite(&_val.rhs_ty));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PredicateLifetime> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PredicateLifetime");
-        formatter.field("lifetime", Lite(&_val.lifetime));
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::PredicateType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("PredicateType");
-        if let Some(val) = &_val.lifetimes {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::BoundLifetimes);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("lifetimes", Print::ref_cast(val));
-        }
-        formatter.field("bounded_ty", Lite(&_val.bounded_ty));
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::QSelf> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("QSelf");
-        formatter.field("ty", Lite(&_val.ty));
-        formatter.field("position", Lite(&_val.position));
-        if let Some(val) = &_val.as_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::As);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("as_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::RangeLimits> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::RangeLimits::HalfOpen(_val) => {
-                formatter.write_str("HalfOpen")?;
-                Ok(())
-            }
-            syn::RangeLimits::Closed(_val) => {
-                formatter.write_str("Closed")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Receiver> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Receiver");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        if let Some(val) = &_val.reference {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::And, Option<syn::Lifetime>));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(
-                        {
-                            #[derive(RefCast)]
-                            #[repr(transparent)]
-                            struct Print(Option<syn::Lifetime>);
-                            impl Debug for Print {
-                                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                                    match &self.0 {
-                                        Some(_val) => {
-                                            formatter.write_str("Some")?;
-                                            formatter.write_str("(")?;
-                                            Debug::fmt(Lite(_val), formatter)?;
-                                            formatter.write_str(")")?;
-                                            Ok(())
-                                        }
-                                        None => formatter.write_str("None"),
-                                    }
-                                }
-                            }
-                            Print::ref_cast(&_val.1)
-                        },
-                        formatter,
-                    )?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("reference", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::ReturnType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::ReturnType::Default => formatter.write_str("Default"),
-            syn::ReturnType::Type(_v0, _v1) => {
-                let mut formatter = formatter.debug_tuple("Type");
-                formatter.field(Lite(_v1));
-                formatter.finish()
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Signature> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Signature");
-        if let Some(val) = &_val.constness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Const);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("constness", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.asyncness {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Async);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("asyncness", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.unsafety {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Unsafe);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("unsafety", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.abi {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Abi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("abi", Print::ref_cast(val));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        if !_val.inputs.is_empty() {
-            formatter.field("inputs", Lite(&_val.inputs));
-        }
-        if let Some(val) = &_val.variadic {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Variadic);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("variadic", Print::ref_cast(val));
-        }
-        formatter.field("output", Lite(&_val.output));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Stmt> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Stmt::Local(_val) => {
-                formatter.write_str("Local")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::Stmt::Item(_val) => {
-                formatter.write_str("Item")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::Stmt::Expr(_val) => {
-                formatter.write_str("Expr")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::Stmt::Semi(_v0, _v1) => {
-                let mut formatter = formatter.debug_tuple("Semi");
-                formatter.field(Lite(_v0));
-                formatter.finish()
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::TraitBound> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TraitBound");
-        if let Some(val) = &_val.paren_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Paren);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("paren_token", Print::ref_cast(val));
-        }
-        formatter.field("modifier", Lite(&_val.modifier));
-        if let Some(val) = &_val.lifetimes {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::BoundLifetimes);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("lifetimes", Print::ref_cast(val));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TraitBoundModifier> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::TraitBoundModifier::None => formatter.write_str("None"),
-            syn::TraitBoundModifier::Maybe(_val) => {
-                formatter.write_str("Maybe")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::TraitItem> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::TraitItem::Const(_val) => {
-                let mut formatter = formatter.debug_struct("TraitItem::Const");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("ty", Lite(&_val.ty));
-                if let Some(val) = &_val.default {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::Eq, syn::Expr));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("default", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::TraitItem::Method(_val) => {
-                let mut formatter = formatter.debug_struct("TraitItem::Method");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("sig", Lite(&_val.sig));
-                if let Some(val) = &_val.default {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Block);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("default", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::TraitItem::Type(_val) => {
-                let mut formatter = formatter.debug_struct("TraitItem::Type");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("ident", Lite(&_val.ident));
-                formatter.field("generics", Lite(&_val.generics));
-                if let Some(val) = &_val.colon_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Colon);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("colon_token", Print::ref_cast(val));
-                }
-                if !_val.bounds.is_empty() {
-                    formatter.field("bounds", Lite(&_val.bounds));
-                }
-                if let Some(val) = &_val.default {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print((syn::token::Eq, syn::Type));
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(&_val.1), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("default", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::TraitItem::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("TraitItem::Macro");
-                if !_val.attrs.is_empty() {
-                    formatter.field("attrs", Lite(&_val.attrs));
-                }
-                formatter.field("mac", Lite(&_val.mac));
-                if let Some(val) = &_val.semi_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Semi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("semi_token", Print::ref_cast(val));
-                }
-                formatter.finish()
-            }
-            syn::TraitItem::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::TraitItemConst> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TraitItemConst");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("ty", Lite(&_val.ty));
-        if let Some(val) = &_val.default {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Eq, syn::Expr));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("default", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TraitItemMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TraitItemMacro");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("mac", Lite(&_val.mac));
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TraitItemMethod> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TraitItemMethod");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("sig", Lite(&_val.sig));
-        if let Some(val) = &_val.default {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Block);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("default", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.semi_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Semi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("semi_token", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TraitItemType> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TraitItemType");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("generics", Lite(&_val.generics));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        if let Some(val) = &_val.default {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Eq, syn::Type));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("default", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Type> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Type::Array(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Array");
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.field("len", Lite(&_val.len));
-                formatter.finish()
-            }
-            syn::Type::BareFn(_val) => {
-                let mut formatter = formatter.debug_struct("Type::BareFn");
-                if let Some(val) = &_val.lifetimes {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::BoundLifetimes);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("lifetimes", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.unsafety {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Unsafe);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("unsafety", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.abi {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Abi);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("abi", Print::ref_cast(val));
-                }
-                if !_val.inputs.is_empty() {
-                    formatter.field("inputs", Lite(&_val.inputs));
-                }
-                if let Some(val) = &_val.variadic {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Variadic);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("variadic", Print::ref_cast(val));
-                }
-                formatter.field("output", Lite(&_val.output));
-                formatter.finish()
-            }
-            syn::Type::Group(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Group");
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.finish()
-            }
-            syn::Type::ImplTrait(_val) => {
-                let mut formatter = formatter.debug_struct("Type::ImplTrait");
-                if !_val.bounds.is_empty() {
-                    formatter.field("bounds", Lite(&_val.bounds));
-                }
-                formatter.finish()
-            }
-            syn::Type::Infer(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Infer");
-                formatter.finish()
-            }
-            syn::Type::Macro(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Macro");
-                formatter.field("mac", Lite(&_val.mac));
-                formatter.finish()
-            }
-            syn::Type::Never(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Never");
-                formatter.finish()
-            }
-            syn::Type::Paren(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Paren");
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.finish()
-            }
-            syn::Type::Path(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Path");
-                if let Some(val) = &_val.qself {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::QSelf);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("qself", Print::ref_cast(val));
-                }
-                formatter.field("path", Lite(&_val.path));
-                formatter.finish()
-            }
-            syn::Type::Ptr(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Ptr");
-                if let Some(val) = &_val.const_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Const);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("const_token", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.finish()
-            }
-            syn::Type::Reference(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Reference");
-                if let Some(val) = &_val.lifetime {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::Lifetime);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            let _val = &self.0;
-                            formatter.write_str("(")?;
-                            Debug::fmt(Lite(_val), formatter)?;
-                            formatter.write_str(")")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("lifetime", Print::ref_cast(val));
-                }
-                if let Some(val) = &_val.mutability {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Mut);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("mutability", Print::ref_cast(val));
-                }
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.finish()
-            }
-            syn::Type::Slice(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Slice");
-                formatter.field("elem", Lite(&_val.elem));
-                formatter.finish()
-            }
-            syn::Type::TraitObject(_val) => {
-                let mut formatter = formatter.debug_struct("Type::TraitObject");
-                if let Some(val) = &_val.dyn_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::Dyn);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("dyn_token", Print::ref_cast(val));
-                }
-                if !_val.bounds.is_empty() {
-                    formatter.field("bounds", Lite(&_val.bounds));
-                }
-                formatter.finish()
-            }
-            syn::Type::Tuple(_val) => {
-                let mut formatter = formatter.debug_struct("Type::Tuple");
-                if !_val.elems.is_empty() {
-                    formatter.field("elems", Lite(&_val.elems));
-                }
-                formatter.finish()
-            }
-            syn::Type::Verbatim(_val) => {
-                formatter.write_str("Verbatim")?;
-                formatter.write_str("(`")?;
-                Display::fmt(_val, formatter)?;
-                formatter.write_str("`)")?;
-                Ok(())
-            }
-            _ => unreachable!(),
-        }
-    }
-}
-impl Debug for Lite<syn::TypeArray> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeArray");
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.field("len", Lite(&_val.len));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeBareFn> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeBareFn");
-        if let Some(val) = &_val.lifetimes {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::BoundLifetimes);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("lifetimes", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.unsafety {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Unsafe);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("unsafety", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.abi {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Abi);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("abi", Print::ref_cast(val));
-        }
-        if !_val.inputs.is_empty() {
-            formatter.field("inputs", Lite(&_val.inputs));
-        }
-        if let Some(val) = &_val.variadic {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Variadic);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("variadic", Print::ref_cast(val));
-        }
-        formatter.field("output", Lite(&_val.output));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeGroup> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeGroup");
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeImplTrait> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeImplTrait");
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeInfer> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeInfer");
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeMacro> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeMacro");
-        formatter.field("mac", Lite(&_val.mac));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeNever> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeNever");
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeParam> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeParam");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        if let Some(val) = &_val.colon_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Colon);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("colon_token", Print::ref_cast(val));
-        }
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        if let Some(val) = &_val.eq_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Eq);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("eq_token", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.default {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Type);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("default", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeParamBound> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::TypeParamBound::Trait(_val) => {
-                formatter.write_str("Trait")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::TypeParamBound::Lifetime(_val) => {
-                formatter.write_str("Lifetime")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::TypeParen> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeParen");
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypePath> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypePath");
-        if let Some(val) = &_val.qself {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::QSelf);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("qself", Print::ref_cast(val));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypePtr> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypePtr");
-        if let Some(val) = &_val.const_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Const);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("const_token", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeReference> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeReference");
-        if let Some(val) = &_val.lifetime {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::Lifetime);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(_val), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("lifetime", Print::ref_cast(val));
-        }
-        if let Some(val) = &_val.mutability {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Mut);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("mutability", Print::ref_cast(val));
-        }
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeSlice> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeSlice");
-        formatter.field("elem", Lite(&_val.elem));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeTraitObject> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeTraitObject");
-        if let Some(val) = &_val.dyn_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::Dyn);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("dyn_token", Print::ref_cast(val));
-        }
-        if !_val.bounds.is_empty() {
-            formatter.field("bounds", Lite(&_val.bounds));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::TypeTuple> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("TypeTuple");
-        if !_val.elems.is_empty() {
-            formatter.field("elems", Lite(&_val.elems));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UnOp> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::UnOp::Deref(_val) => {
-                formatter.write_str("Deref")?;
-                Ok(())
-            }
-            syn::UnOp::Not(_val) => {
-                formatter.write_str("Not")?;
-                Ok(())
-            }
-            syn::UnOp::Neg(_val) => {
-                formatter.write_str("Neg")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::UseGlob> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("UseGlob");
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UseGroup> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("UseGroup");
-        if !_val.items.is_empty() {
-            formatter.field("items", Lite(&_val.items));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UseName> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("UseName");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UsePath> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("UsePath");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("tree", Lite(&_val.tree));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UseRename> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("UseRename");
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("rename", Lite(&_val.rename));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::UseTree> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::UseTree::Path(_val) => {
-                formatter.write_str("Path")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::UseTree::Name(_val) => {
-                formatter.write_str("Name")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::UseTree::Rename(_val) => {
-                formatter.write_str("Rename")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::UseTree::Glob(_val) => {
-                formatter.write_str("Glob")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::UseTree::Group(_val) => {
-                formatter.write_str("Group")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
-impl Debug for Lite<syn::Variadic> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Variadic");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Variant> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("Variant");
-        if !_val.attrs.is_empty() {
-            formatter.field("attrs", Lite(&_val.attrs));
-        }
-        formatter.field("ident", Lite(&_val.ident));
-        formatter.field("fields", Lite(&_val.fields));
-        if let Some(val) = &_val.discriminant {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print((syn::token::Eq, syn::Expr));
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    let _val = &self.0;
-                    formatter.write_str("(")?;
-                    Debug::fmt(Lite(&_val.1), formatter)?;
-                    formatter.write_str(")")?;
-                    Ok(())
-                }
-            }
-            formatter.field("discriminant", Print::ref_cast(val));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::VisCrate> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("VisCrate");
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::VisPublic> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("VisPublic");
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::VisRestricted> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("VisRestricted");
-        if let Some(val) = &_val.in_token {
-            #[derive(RefCast)]
-            #[repr(transparent)]
-            struct Print(syn::token::In);
-            impl Debug for Print {
-                fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("Some")?;
-                    Ok(())
-                }
-            }
-            formatter.field("in_token", Print::ref_cast(val));
-        }
-        formatter.field("path", Lite(&_val.path));
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::Visibility> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::Visibility::Public(_val) => {
-                let mut formatter = formatter.debug_struct("Visibility::Public");
-                formatter.finish()
-            }
-            syn::Visibility::Crate(_val) => {
-                let mut formatter = formatter.debug_struct("Visibility::Crate");
-                formatter.finish()
-            }
-            syn::Visibility::Restricted(_val) => {
-                let mut formatter = formatter.debug_struct("Visibility::Restricted");
-                if let Some(val) = &_val.in_token {
-                    #[derive(RefCast)]
-                    #[repr(transparent)]
-                    struct Print(syn::token::In);
-                    impl Debug for Print {
-                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str("Some")?;
-                            Ok(())
-                        }
-                    }
-                    formatter.field("in_token", Print::ref_cast(val));
-                }
-                formatter.field("path", Lite(&_val.path));
-                formatter.finish()
-            }
-            syn::Visibility::Inherited => formatter.write_str("Inherited"),
-        }
-    }
-}
-impl Debug for Lite<syn::WhereClause> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        let mut formatter = formatter.debug_struct("WhereClause");
-        if !_val.predicates.is_empty() {
-            formatter.field("predicates", Lite(&_val.predicates));
-        }
-        formatter.finish()
-    }
-}
-impl Debug for Lite<syn::WherePredicate> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let _val = &self.value;
-        match _val {
-            syn::WherePredicate::Type(_val) => {
-                formatter.write_str("Type")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::WherePredicate::Lifetime(_val) => {
-                formatter.write_str("Lifetime")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-            syn::WherePredicate::Eq(_val) => {
-                formatter.write_str("Eq")?;
-                formatter.write_str("(")?;
-                Debug::fmt(Lite(_val), formatter)?;
-                formatter.write_str(")")?;
-                Ok(())
-            }
-        }
-    }
-}
diff --git a/vendor/syn/tests/debug/mod.rs b/vendor/syn/tests/debug/mod.rs
deleted file mode 100644
index cefebace..00000000
--- a/vendor/syn/tests/debug/mod.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-mod gen;
-
-use proc_macro2::{Ident, Literal, TokenStream};
-use ref_cast::RefCast;
-use std::fmt::{self, Debug};
-use std::ops::Deref;
-use syn::punctuated::Punctuated;
-
-#[derive(RefCast)]
-#[repr(transparent)]
-pub struct Lite<T: ?Sized> {
-    value: T,
-}
-
-#[allow(non_snake_case)]
-pub fn Lite<T: ?Sized>(value: &T) -> &Lite<T> {
-    Lite::ref_cast(value)
-}
-
-impl<T: ?Sized> Deref for Lite<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl Debug for Lite<bool> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{}", self.value)
-    }
-}
-
-impl Debug for Lite<u32> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{}", self.value)
-    }
-}
-
-impl Debug for Lite<usize> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{}", self.value)
-    }
-}
-
-impl Debug for Lite<String> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{:?}", self.value)
-    }
-}
-
-impl Debug for Lite<Ident> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{:?}", self.value.to_string())
-    }
-}
-
-impl Debug for Lite<Literal> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "{}", self.value)
-    }
-}
-
-impl Debug for Lite<TokenStream> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let string = self.value.to_string();
-        if string.len() <= 80 {
-            write!(formatter, "TokenStream(`{}`)", self.value)
-        } else {
-            formatter
-                .debug_tuple("TokenStream")
-                .field(&format_args!("`{}`", string))
-                .finish()
-        }
-    }
-}
-
-impl<'a, T> Debug for Lite<&'a T>
-where
-    Lite<T>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(Lite(&*self.value), formatter)
-    }
-}
-
-impl<T> Debug for Lite<Box<T>>
-where
-    Lite<T>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(Lite(&*self.value), formatter)
-    }
-}
-
-impl<T> Debug for Lite<Vec<T>>
-where
-    Lite<T>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_list()
-            .entries(self.value.iter().map(Lite))
-            .finish()
-    }
-}
-
-impl<T, P> Debug for Lite<Punctuated<T, P>>
-where
-    Lite<T>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_list()
-            .entries(self.value.iter().map(Lite))
-            .finish()
-    }
-}
diff --git a/vendor/syn/tests/macros/mod.rs b/vendor/syn/tests/macros/mod.rs
deleted file mode 100644
index db90818e..00000000
--- a/vendor/syn/tests/macros/mod.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#[path = "../debug/mod.rs"]
-pub mod debug;
-
-use syn::parse::{Parse, Result};
-
-#[macro_export]
-macro_rules! errorf {
-    ($($tt:tt)*) => {{
-        use ::std::io::Write;
-        let stderr = ::std::io::stderr();
-        write!(stderr.lock(), $($tt)*).unwrap();
-    }};
-}
-
-#[macro_export]
-macro_rules! punctuated {
-    ($($e:expr,)+) => {{
-        let mut seq = ::syn::punctuated::Punctuated::new();
-        $(
-            seq.push($e);
-        )+
-        seq
-    }};
-
-    ($($e:expr),+) => {
-        punctuated!($($e,)+)
-    };
-}
-
-#[macro_export]
-macro_rules! snapshot {
-    ($($args:tt)*) => {
-        snapshot_impl!(() $($args)*)
-    };
-}
-
-#[macro_export]
-macro_rules! snapshot_impl {
-    (($expr:ident) as $t:ty, @$snapshot:literal) => {
-        let $expr = crate::macros::Tokens::parse::<$t>($expr).unwrap();
-        let debug = crate::macros::debug::Lite(&$expr);
-        insta::assert_debug_snapshot!(debug, @$snapshot);
-    };
-    (($($expr:tt)*) as $t:ty, @$snapshot:literal) => {{
-        let syntax_tree = crate::macros::Tokens::parse::<$t>($($expr)*).unwrap();
-        let debug = crate::macros::debug::Lite(&syntax_tree);
-        insta::assert_debug_snapshot!(debug, @$snapshot);
-        syntax_tree
-    }};
-    (($($expr:tt)*) , @$snapshot:literal) => {{
-        let syntax_tree = $($expr)*;
-        let debug = crate::macros::debug::Lite(&syntax_tree);
-        insta::assert_debug_snapshot!(debug, @$snapshot);
-        syntax_tree
-    }};
-    (($($expr:tt)*) $next:tt $($rest:tt)*) => {
-        snapshot_impl!(($($expr)* $next) $($rest)*)
-    };
-}
-
-pub trait Tokens {
-    fn parse<T: Parse>(self) -> Result<T>;
-}
-
-impl<'a> Tokens for &'a str {
-    fn parse<T: Parse>(self) -> Result<T> {
-        syn::parse_str(self)
-    }
-}
-
-impl Tokens for proc_macro2::TokenStream {
-    fn parse<T: Parse>(self) -> Result<T> {
-        syn::parse2(self)
-    }
-}
diff --git a/vendor/syn/tests/repo/mod.rs b/vendor/syn/tests/repo/mod.rs
deleted file mode 100644
index 58c239ac..00000000
--- a/vendor/syn/tests/repo/mod.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-mod progress;
-
-use self::progress::Progress;
-use anyhow::Result;
-use flate2::read::GzDecoder;
-use std::fs;
-use std::path::Path;
-use tar::Archive;
-use walkdir::DirEntry;
-
-const REVISION: &str = "716394d6581b60c75cfdd88b8e5b876f2db88b62";
-
-#[rustfmt::skip]
-static EXCLUDE: &[&str] = &[
-    // Rustc loses some attributes
-    // https://github.com/rust-lang/rust/issues/84879
-    "src/test/ui/proc-macro/issue-81555.rs",
-
-    // Compile-fail expr parameter in const generic position: f::<1 + 2>()
-    "src/test/ui/const-generics/closing-args-token.rs",
-    "src/test/ui/const-generics/const-expression-parameter.rs",
-
-    // Deprecated anonymous parameter syntax in traits
-    "src/test/ui/issues/issue-13105.rs",
-    "src/test/ui/issues/issue-13775.rs",
-    "src/test/ui/issues/issue-34074.rs",
-    "src/test/ui/proc-macro/trait-fn-args-2015.rs",
-
-    // Excessive nesting
-    "src/test/ui/issues/issue-74564-if-expr-stack-overflow.rs",
-
-    // Not actually test cases
-    "src/test/rustdoc-ui/test-compile-fail2.rs",
-    "src/test/rustdoc-ui/test-compile-fail3.rs",
-    "src/test/ui/include-single-expr-helper.rs",
-    "src/test/ui/include-single-expr-helper-1.rs",
-    "src/test/ui/json-bom-plus-crlf-multifile-aux.rs",
-    "src/test/ui/lint/expansion-time-include.rs",
-    "src/test/ui/macros/auxiliary/macro-comma-support.rs",
-    "src/test/ui/macros/auxiliary/macro-include-items-expr.rs",
-    "src/test/ui/parser/auxiliary/issue-21146-inc.rs",
-];
-
-pub fn base_dir_filter(entry: &DirEntry) -> bool {
-    let path = entry.path();
-    if path.is_dir() {
-        return true; // otherwise walkdir does not visit the files
-    }
-    if path.extension().map(|e| e != "rs").unwrap_or(true) {
-        return false;
-    }
-
-    let mut path_string = path.to_string_lossy();
-    if cfg!(windows) {
-        path_string = path_string.replace('\\', "/").into();
-    }
-    let path = if let Some(path) = path_string.strip_prefix("tests/rust/") {
-        path
-    } else {
-        panic!("unexpected path in Rust dist: {}", path_string);
-    };
-
-    if path.starts_with("src/test/compile-fail") || path.starts_with("src/test/rustfix") {
-        return false;
-    }
-
-    if path.starts_with("src/test/ui") {
-        let stderr_path = entry.path().with_extension("stderr");
-        if stderr_path.exists() {
-            // Expected to fail in some way
-            return false;
-        }
-    }
-
-    !EXCLUDE.contains(&path)
-}
-
-#[allow(dead_code)]
-pub fn edition(path: &Path) -> &'static str {
-    if path.ends_with("dyn-2015-no-warnings-without-lints.rs") {
-        "2015"
-    } else {
-        "2018"
-    }
-}
-
-pub fn clone_rust() {
-    let needs_clone = match fs::read_to_string("tests/rust/COMMIT") {
-        Err(_) => true,
-        Ok(contents) => contents.trim() != REVISION,
-    };
-    if needs_clone {
-        download_and_unpack().unwrap();
-    }
-    let mut missing = String::new();
-    let test_src = Path::new("tests/rust");
-    for exclude in EXCLUDE {
-        if !test_src.join(exclude).exists() {
-            missing += "\ntests/rust/";
-            missing += exclude;
-        }
-    }
-    if !missing.is_empty() {
-        panic!("excluded test file does not exist:{}\n", missing);
-    }
-}
-
-fn download_and_unpack() -> Result<()> {
-    let url = format!(
-        "https://github.com/rust-lang/rust/archive/{}.tar.gz",
-        REVISION
-    );
-    let response = reqwest::blocking::get(&url)?.error_for_status()?;
-    let progress = Progress::new(response);
-    let decoder = GzDecoder::new(progress);
-    let mut archive = Archive::new(decoder);
-    let prefix = format!("rust-{}", REVISION);
-
-    let tests_rust = Path::new("tests/rust");
-    if tests_rust.exists() {
-        fs::remove_dir_all(tests_rust)?;
-    }
-
-    for entry in archive.entries()? {
-        let mut entry = entry?;
-        let path = entry.path()?;
-        if path == Path::new("pax_global_header") {
-            continue;
-        }
-        let relative = path.strip_prefix(&prefix)?;
-        let out = tests_rust.join(relative);
-        entry.unpack(&out)?;
-    }
-
-    fs::write("tests/rust/COMMIT", REVISION)?;
-    Ok(())
-}
diff --git a/vendor/syn/tests/repo/progress.rs b/vendor/syn/tests/repo/progress.rs
deleted file mode 100644
index 28c8a44b..00000000
--- a/vendor/syn/tests/repo/progress.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use std::io::{Read, Result};
-use std::time::{Duration, Instant};
-
-pub struct Progress<R> {
-    bytes: usize,
-    tick: Instant,
-    stream: R,
-}
-
-impl<R> Progress<R> {
-    pub fn new(stream: R) -> Self {
-        Progress {
-            bytes: 0,
-            tick: Instant::now() + Duration::from_millis(2000),
-            stream,
-        }
-    }
-}
-
-impl<R: Read> Read for Progress<R> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        let num = self.stream.read(buf)?;
-        self.bytes += num;
-        let now = Instant::now();
-        if now > self.tick {
-            self.tick = now + Duration::from_millis(500);
-            errorf!("downloading... {} bytes\n", self.bytes);
-        }
-        Ok(num)
-    }
-}
-
-impl<R> Drop for Progress<R> {
-    fn drop(&mut self) {
-        errorf!("done ({} bytes)\n", self.bytes);
-    }
-}
diff --git a/vendor/syn/tests/test_asyncness.rs b/vendor/syn/tests/test_asyncness.rs
deleted file mode 100644
index 0efef597..00000000
--- a/vendor/syn/tests/test_asyncness.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[macro_use]
-mod macros;
-
-use syn::{Expr, Item};
-
-#[test]
-fn test_async_fn() {
-    let input = "async fn process() {}";
-
-    snapshot!(input as Item, @r###"
-    Item::Fn {
-        vis: Inherited,
-        sig: Signature {
-            asyncness: Some,
-            ident: "process",
-            generics: Generics,
-            output: Default,
-        },
-        block: Block,
-    }
-    "###);
-}
-
-#[test]
-fn test_async_closure() {
-    let input = "async || {}";
-
-    snapshot!(input as Expr, @r###"
-    Expr::Closure {
-        asyncness: Some,
-        output: Default,
-        body: Expr::Block {
-            block: Block,
-        },
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_attribute.rs b/vendor/syn/tests/test_attribute.rs
deleted file mode 100644
index c26bd090..00000000
--- a/vendor/syn/tests/test_attribute.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-#[macro_use]
-mod macros;
-
-use syn::parse::Parser;
-use syn::{Attribute, Meta};
-
-#[test]
-fn test_meta_item_word() {
-    let meta = test("#[foo]");
-
-    snapshot!(meta, @r###"
-    Path(Path {
-        segments: [
-            PathSegment {
-                ident: "foo",
-                arguments: None,
-            },
-        ],
-    })
-    "###);
-}
-
-#[test]
-fn test_meta_item_name_value() {
-    let meta = test("#[foo = 5]");
-
-    snapshot!(meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_bool_value() {
-    let meta = test("#[foo = true]");
-
-    snapshot!(meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: Lit::Bool {
-            value: true,
-        },
-    }
-    "###);
-
-    let meta = test("#[foo = false]");
-
-    snapshot!(meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: Lit::Bool {
-            value: false,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_list_lit() {
-    let meta = test("#[foo(5)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Lit(5),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_list_word() {
-    let meta = test("#[foo(bar)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "bar",
-                        arguments: None,
-                    },
-                ],
-            })),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_list_name_value() {
-    let meta = test("#[foo(bar = 5)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "bar",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 5,
-            }),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_list_bool_value() {
-    let meta = test("#[foo(bar = true)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "bar",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: Lit::Bool {
-                    value: true,
-                },
-            }),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_meta_item_multiple() {
-    let meta = test("#[foo(word, name = 5, list(name2 = 6), word2)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word",
-                        arguments: None,
-                    },
-                ],
-            })),
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "name",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 5,
-            }),
-            Meta(Meta::List {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "list",
-                            arguments: None,
-                        },
-                    ],
-                },
-                nested: [
-                    Meta(Meta::NameValue {
-                        path: Path {
-                            segments: [
-                                PathSegment {
-                                    ident: "name2",
-                                    arguments: None,
-                                },
-                            ],
-                        },
-                        lit: 6,
-                    }),
-                ],
-            }),
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word2",
-                        arguments: None,
-                    },
-                ],
-            })),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_bool_lit() {
-    let meta = test("#[foo(true)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Lit(Lit::Bool {
-                value: true,
-            }),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_negative_lit() {
-    let meta = test("#[form(min = -1, max = 200)]");
-
-    snapshot!(meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "form",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "min",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: -1,
-            }),
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "max",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 200,
-            }),
-        ],
-    }
-    "###);
-}
-
-fn test(input: &str) -> Meta {
-    let attrs = Attribute::parse_outer.parse_str(input).unwrap();
-
-    assert_eq!(attrs.len(), 1);
-    let attr = attrs.into_iter().next().unwrap();
-
-    attr.parse_meta().unwrap()
-}
diff --git a/vendor/syn/tests/test_derive_input.rs b/vendor/syn/tests/test_derive_input.rs
deleted file mode 100644
index bf1ebdb6..00000000
--- a/vendor/syn/tests/test_derive_input.rs
+++ /dev/null
@@ -1,892 +0,0 @@
-#[macro_use]
-mod macros;
-
-use quote::quote;
-use syn::{Data, DeriveInput};
-
-#[test]
-fn test_unit() {
-    let input = quote! {
-        struct Unit;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "Unit",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_struct() {
-    let input = quote! {
-        #[derive(Debug, Clone)]
-        pub struct Item {
-            pub ident: Ident,
-            pub attrs: Vec<Attribute>
-        }
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "derive",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(`(Debug , Clone)`),
-            },
-        ],
-        vis: Visibility::Public,
-        ident: "Item",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Named {
-                named: [
-                    Field {
-                        vis: Visibility::Public,
-                        ident: Some("ident"),
-                        colon_token: Some,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "Ident",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                    Field {
-                        vis: Visibility::Public,
-                        ident: Some("attrs"),
-                        colon_token: Some,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "Vec",
-                                        arguments: PathArguments::AngleBracketed {
-                                            args: [
-                                                Type(Type::Path {
-                                                    path: Path {
-                                                        segments: [
-                                                            PathSegment {
-                                                                ident: "Attribute",
-                                                                arguments: None,
-                                                            },
-                                                        ],
-                                                    },
-                                                }),
-                                            ],
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-
-    snapshot!(input.attrs[0].parse_meta().unwrap(), @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "derive",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "Debug",
-                        arguments: None,
-                    },
-                ],
-            })),
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "Clone",
-                        arguments: None,
-                    },
-                ],
-            })),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_union() {
-    let input = quote! {
-        union MaybeUninit<T> {
-            uninit: (),
-            value: T
-        }
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "MaybeUninit",
-        generics: Generics {
-            lt_token: Some,
-            params: [
-                Type(TypeParam {
-                    ident: "T",
-                }),
-            ],
-            gt_token: Some,
-        },
-        data: Data::Union {
-            fields: FieldsNamed {
-                named: [
-                    Field {
-                        vis: Inherited,
-                        ident: Some("uninit"),
-                        colon_token: Some,
-                        ty: Type::Tuple,
-                    },
-                    Field {
-                        vis: Inherited,
-                        ident: Some("value"),
-                        colon_token: Some,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "T",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-}
-
-#[test]
-#[cfg(feature = "full")]
-fn test_enum() {
-    let input = quote! {
-        /// See the std::result module documentation for details.
-        #[must_use]
-        pub enum Result<T, E> {
-            Ok(T),
-            Err(E),
-            Surprise = 0isize,
-
-            // Smuggling data into a proc_macro_derive,
-            // in the style of https://github.com/dtolnay/proc-macro-hack
-            ProcMacroHack = (0, "data").0
-        }
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "doc",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(`= r" See the std::result module documentation for details."`),
-            },
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "must_use",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(``),
-            },
-        ],
-        vis: Visibility::Public,
-        ident: "Result",
-        generics: Generics {
-            lt_token: Some,
-            params: [
-                Type(TypeParam {
-                    ident: "T",
-                }),
-                Type(TypeParam {
-                    ident: "E",
-                }),
-            ],
-            gt_token: Some,
-        },
-        data: Data::Enum {
-            variants: [
-                Variant {
-                    ident: "Ok",
-                    fields: Fields::Unnamed {
-                        unnamed: [
-                            Field {
-                                vis: Inherited,
-                                ty: Type::Path {
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "T",
-                                                arguments: None,
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-                Variant {
-                    ident: "Err",
-                    fields: Fields::Unnamed {
-                        unnamed: [
-                            Field {
-                                vis: Inherited,
-                                ty: Type::Path {
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "E",
-                                                arguments: None,
-                                            },
-                                        ],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-                Variant {
-                    ident: "Surprise",
-                    fields: Unit,
-                    discriminant: Some(Expr::Lit {
-                        lit: 0isize,
-                    }),
-                },
-                Variant {
-                    ident: "ProcMacroHack",
-                    fields: Unit,
-                    discriminant: Some(Expr::Field {
-                        base: Expr::Tuple {
-                            elems: [
-                                Expr::Lit {
-                                    lit: 0,
-                                },
-                                Expr::Lit {
-                                    lit: "data",
-                                },
-                            ],
-                        },
-                        member: Unnamed(Index {
-                            index: 0,
-                        }),
-                    }),
-                },
-            ],
-        },
-    }
-    "###);
-
-    let meta_items: Vec<_> = input
-        .attrs
-        .into_iter()
-        .map(|attr| attr.parse_meta().unwrap())
-        .collect();
-
-    snapshot!(meta_items, @r###"
-    [
-        Meta::NameValue {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "doc",
-                        arguments: None,
-                    },
-                ],
-            },
-            lit: " See the std::result module documentation for details.",
-        },
-        Path(Path {
-            segments: [
-                PathSegment {
-                    ident: "must_use",
-                    arguments: None,
-                },
-            ],
-        }),
-    ]
-    "###);
-}
-
-#[test]
-fn test_attr_with_path() {
-    let input = quote! {
-        #[::attr_args::identity
-            fn main() { assert_eq!(foo(), "Hello, world!"); }]
-        struct Dummy;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    leading_colon: Some,
-                    segments: [
-                        PathSegment {
-                            ident: "attr_args",
-                            arguments: None,
-                        },
-                        PathSegment {
-                            ident: "identity",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(`fn main () { assert_eq ! (foo () , "Hello, world!") ; }`),
-            },
-        ],
-        vis: Inherited,
-        ident: "Dummy",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    assert!(input.attrs[0].parse_meta().is_err());
-}
-
-#[test]
-fn test_attr_with_non_mod_style_path() {
-    let input = quote! {
-        #[inert <T>]
-        struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "inert",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(`< T >`),
-            },
-        ],
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    assert!(input.attrs[0].parse_meta().is_err());
-}
-
-#[test]
-fn test_attr_with_mod_style_path_with_self() {
-    let input = quote! {
-        #[foo::self]
-        struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "foo",
-                            arguments: None,
-                        },
-                        PathSegment {
-                            ident: "self",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(``),
-            },
-        ],
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    snapshot!(input.attrs[0].parse_meta().unwrap(), @r###"
-    Path(Path {
-        segments: [
-            PathSegment {
-                ident: "foo",
-                arguments: None,
-            },
-            PathSegment {
-                ident: "self",
-                arguments: None,
-            },
-        ],
-    })
-    "###);
-}
-
-#[test]
-fn test_pub_restricted() {
-    // Taken from tests/rust/src/test/ui/resolve/auxiliary/privacy-struct-ctor.rs
-    let input = quote! {
-        pub(in m) struct Z(pub(in m::n) u8);
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Visibility::Restricted {
-            in_token: Some,
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "m",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-        ident: "Z",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Unnamed {
-                unnamed: [
-                    Field {
-                        vis: Visibility::Restricted {
-                            in_token: Some,
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "m",
-                                        arguments: None,
-                                    },
-                                    PathSegment {
-                                        ident: "n",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "u8",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_vis_crate() {
-    let input = quote! {
-        crate struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Visibility::Crate,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_pub_restricted_crate() {
-    let input = quote! {
-        pub(crate) struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Visibility::Restricted {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "crate",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_pub_restricted_super() {
-    let input = quote! {
-        pub(super) struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Visibility::Restricted {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "super",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_pub_restricted_in_super() {
-    let input = quote! {
-        pub(in super) struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Visibility::Restricted {
-            in_token: Some,
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "super",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_fields_on_unit_struct() {
-    let input = quote! {
-        struct S;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    let data = match input.data {
-        Data::Struct(data) => data,
-        _ => panic!("expected a struct"),
-    };
-
-    assert_eq!(0, data.fields.iter().count());
-}
-
-#[test]
-fn test_fields_on_named_struct() {
-    let input = quote! {
-        struct S {
-            foo: i32,
-            pub bar: String,
-        }
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Named {
-                named: [
-                    Field {
-                        vis: Inherited,
-                        ident: Some("foo"),
-                        colon_token: Some,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "i32",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                    Field {
-                        vis: Visibility::Public,
-                        ident: Some("bar"),
-                        colon_token: Some,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "String",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-
-    let data = match input.data {
-        Data::Struct(data) => data,
-        _ => panic!("expected a struct"),
-    };
-
-    snapshot!(data.fields.into_iter().collect::<Vec<_>>(), @r###"
-    [
-        Field {
-            vis: Inherited,
-            ident: Some("foo"),
-            colon_token: Some,
-            ty: Type::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "i32",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-        Field {
-            vis: Visibility::Public,
-            ident: Some("bar"),
-            colon_token: Some,
-            ty: Type::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "String",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-    ]
-    "###);
-}
-
-#[test]
-fn test_fields_on_tuple_struct() {
-    let input = quote! {
-        struct S(i32, pub String);
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Unnamed {
-                unnamed: [
-                    Field {
-                        vis: Inherited,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "i32",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                    Field {
-                        vis: Visibility::Public,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "String",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    let data = match input.data {
-        Data::Struct(data) => data,
-        _ => panic!("expected a struct"),
-    };
-
-    snapshot!(data.fields.iter().collect::<Vec<_>>(), @r###"
-    [
-        Field {
-            vis: Inherited,
-            ty: Type::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "i32",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-        Field {
-            vis: Visibility::Public,
-            ty: Type::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "String",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-    ]
-    "###);
-}
-
-#[test]
-fn test_ambiguous_crate() {
-    let input = quote! {
-        // The field type is `(crate::X)` not `crate (::X)`.
-        struct S(crate::X);
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Unnamed {
-                unnamed: [
-                    Field {
-                        vis: Inherited,
-                        ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "crate",
-                                        arguments: None,
-                                    },
-                                    PathSegment {
-                                        ident: "X",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                ],
-            },
-            semi_token: Some,
-        },
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_expr.rs b/vendor/syn/tests/test_expr.rs
deleted file mode 100644
index 8c1cc73a..00000000
--- a/vendor/syn/tests/test_expr.rs
+++ /dev/null
@@ -1,320 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
-use quote::quote;
-use std::iter::FromIterator;
-use syn::{Expr, ExprRange};
-
-#[test]
-fn test_expr_parse() {
-    let tokens = quote!(..100u32);
-    snapshot!(tokens as Expr, @r###"
-    Expr::Range {
-        limits: HalfOpen,
-        to: Some(Expr::Lit {
-            lit: 100u32,
-        }),
-    }
-    "###);
-
-    let tokens = quote!(..100u32);
-    snapshot!(tokens as ExprRange, @r###"
-    ExprRange {
-        limits: HalfOpen,
-        to: Some(Expr::Lit {
-            lit: 100u32,
-        }),
-    }
-    "###);
-}
-
-#[test]
-fn test_await() {
-    // Must not parse as Expr::Field.
-    let tokens = quote!(fut.await);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Await {
-        base: Expr::Path {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "fut",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-}
-
-#[rustfmt::skip]
-#[test]
-fn test_tuple_multi_index() {
-    for &input in &[
-        "tuple.0.0",
-        "tuple .0.0",
-        "tuple. 0.0",
-        "tuple.0 .0",
-        "tuple.0. 0",
-        "tuple . 0 . 0",
-    ] {
-        snapshot!(input as Expr, @r###"
-        Expr::Field {
-            base: Expr::Field {
-                base: Expr::Path {
-                    path: Path {
-                        segments: [
-                            PathSegment {
-                                ident: "tuple",
-                                arguments: None,
-                            },
-                        ],
-                    },
-                },
-                member: Unnamed(Index {
-                    index: 0,
-                }),
-            },
-            member: Unnamed(Index {
-                index: 0,
-            }),
-        }
-        "###);
-    }
-
-    for tokens in vec![
-        quote!(tuple.0.0),
-        quote!(tuple .0.0),
-        quote!(tuple. 0.0),
-        quote!(tuple.0 .0),
-        quote!(tuple.0. 0),
-        quote!(tuple . 0 . 0),
-    ] {
-        snapshot!(tokens as Expr, @r###"
-        Expr::Field {
-            base: Expr::Field {
-                base: Expr::Path {
-                    path: Path {
-                        segments: [
-                            PathSegment {
-                                ident: "tuple",
-                                arguments: None,
-                            },
-                        ],
-                    },
-                },
-                member: Unnamed(Index {
-                    index: 0,
-                }),
-            },
-            member: Unnamed(Index {
-                index: 0,
-            }),
-        }
-        "###);
-    }
-}
-
-#[test]
-fn test_macro_variable_func() {
-    // mimics the token stream corresponding to `$fn()`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { f })),
-        TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Call {
-        func: Expr::Group {
-            expr: Expr::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "f",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-    }
-    "###);
-
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Punct(Punct::new('#', Spacing::Alone)),
-        TokenTree::Group(Group::new(Delimiter::Bracket, quote! { outside })),
-        TokenTree::Group(Group::new(Delimiter::None, quote! { #[inside] f })),
-        TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Call {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "outside",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(``),
-            },
-        ],
-        func: Expr::Group {
-            expr: Expr::Path {
-                attrs: [
-                    Attribute {
-                        style: Outer,
-                        path: Path {
-                            segments: [
-                                PathSegment {
-                                    ident: "inside",
-                                    arguments: None,
-                                },
-                            ],
-                        },
-                        tokens: TokenStream(``),
-                    },
-                ],
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "f",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_macro_variable_macro() {
-    // mimics the token stream corresponding to `$macro!()`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { m })),
-        TokenTree::Punct(Punct::new('!', Spacing::Alone)),
-        TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Macro {
-        mac: Macro {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "m",
-                        arguments: None,
-                    },
-                ],
-            },
-            delimiter: Paren,
-            tokens: TokenStream(``),
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_macro_variable_struct() {
-    // mimics the token stream corresponding to `$struct {}`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { S })),
-        TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Struct {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "S",
-                    arguments: None,
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_macro_variable_match_arm() {
-    // mimics the token stream corresponding to `match v { _ => $expr }`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Ident(Ident::new("match", Span::call_site())),
-        TokenTree::Ident(Ident::new("v", Span::call_site())),
-        TokenTree::Group(Group::new(
-            Delimiter::Brace,
-            TokenStream::from_iter(vec![
-                TokenTree::Punct(Punct::new('_', Spacing::Alone)),
-                TokenTree::Punct(Punct::new('=', Spacing::Joint)),
-                TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-                TokenTree::Group(Group::new(Delimiter::None, quote! { #[a] () })),
-            ]),
-        )),
-    ]);
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Match {
-        expr: Expr::Path {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "v",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-        arms: [
-            Arm {
-                pat: Pat::Wild,
-                body: Expr::Group {
-                    expr: Expr::Tuple {
-                        attrs: [
-                            Attribute {
-                                style: Outer,
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "a",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                                tokens: TokenStream(``),
-                            },
-                        ],
-                    },
-                },
-            },
-        ],
-    }
-    "###);
-}
-
-// https://github.com/dtolnay/syn/issues/1019
-#[test]
-fn test_closure_vs_rangefull() {
-    #[rustfmt::skip] // rustfmt bug: https://github.com/rust-lang/rustfmt/issues/4808
-    let tokens = quote!(|| .. .method());
-    snapshot!(tokens as Expr, @r###"
-    Expr::MethodCall {
-        receiver: Expr::Closure {
-            output: Default,
-            body: Expr::Range {
-                limits: HalfOpen,
-            },
-        },
-        method: "method",
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_generics.rs b/vendor/syn/tests/test_generics.rs
deleted file mode 100644
index b29434a1..00000000
--- a/vendor/syn/tests/test_generics.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-#[macro_use]
-mod macros;
-
-use quote::quote;
-use syn::{DeriveInput, ItemFn, TypeParamBound, WhereClause, WherePredicate};
-
-#[test]
-fn test_split_for_impl() {
-    let input = quote! {
-        struct S<'a, 'b: 'a, #[may_dangle] T: 'a = ()> where T: Debug;
-    };
-
-    snapshot!(input as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics {
-            lt_token: Some,
-            params: [
-                Lifetime(LifetimeDef {
-                    lifetime: Lifetime {
-                        ident: "a",
-                    },
-                }),
-                Lifetime(LifetimeDef {
-                    lifetime: Lifetime {
-                        ident: "b",
-                    },
-                    colon_token: Some,
-                    bounds: [
-                        Lifetime {
-                            ident: "a",
-                        },
-                    ],
-                }),
-                Type(TypeParam {
-                    attrs: [
-                        Attribute {
-                            style: Outer,
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "may_dangle",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                            tokens: TokenStream(``),
-                        },
-                    ],
-                    ident: "T",
-                    colon_token: Some,
-                    bounds: [
-                        Lifetime(Lifetime {
-                            ident: "a",
-                        }),
-                    ],
-                    eq_token: Some,
-                    default: Some(Type::Tuple),
-                }),
-            ],
-            gt_token: Some,
-            where_clause: Some(WhereClause {
-                predicates: [
-                    Type(PredicateType {
-                        bounded_ty: Type::Path {
-                            path: Path {
-                                segments: [
-                                    PathSegment {
-                                        ident: "T",
-                                        arguments: None,
-                                    },
-                                ],
-                            },
-                        },
-                        bounds: [
-                            Trait(TraitBound {
-                                modifier: None,
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "Debug",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    }),
-                ],
-            }),
-        },
-        data: Data::Struct {
-            fields: Unit,
-            semi_token: Some,
-        },
-    }
-    "###);
-
-    let generics = input.generics;
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-
-    let generated = quote! {
-        impl #impl_generics MyTrait for Test #ty_generics #where_clause {}
-    };
-    let expected = quote! {
-        impl<'a, 'b: 'a, #[may_dangle] T: 'a> MyTrait
-        for Test<'a, 'b, T>
-        where
-            T: Debug
-        {}
-    };
-    assert_eq!(generated.to_string(), expected.to_string());
-
-    let turbofish = ty_generics.as_turbofish();
-    let generated = quote! {
-        Test #turbofish
-    };
-    let expected = quote! {
-        Test::<'a, 'b, T>
-    };
-    assert_eq!(generated.to_string(), expected.to_string());
-}
-
-#[test]
-fn test_ty_param_bound() {
-    let tokens = quote!('a);
-    snapshot!(tokens as TypeParamBound, @r###"
-    Lifetime(Lifetime {
-        ident: "a",
-    })
-    "###);
-
-    let tokens = quote!('_);
-    snapshot!(tokens as TypeParamBound, @r###"
-    Lifetime(Lifetime {
-        ident: "_",
-    })
-    "###);
-
-    let tokens = quote!(Debug);
-    snapshot!(tokens as TypeParamBound, @r###"
-    Trait(TraitBound {
-        modifier: None,
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Debug",
-                    arguments: None,
-                },
-            ],
-        },
-    })
-    "###);
-
-    let tokens = quote!(?Sized);
-    snapshot!(tokens as TypeParamBound, @r###"
-    Trait(TraitBound {
-        modifier: Maybe,
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Sized",
-                    arguments: None,
-                },
-            ],
-        },
-    })
-    "###);
-}
-
-#[test]
-fn test_fn_precedence_in_where_clause() {
-    // This should parse as two separate bounds, `FnOnce() -> i32` and `Send` - not
-    // `FnOnce() -> (i32 + Send)`.
-    let input = quote! {
-        fn f<G>()
-        where
-            G: FnOnce() -> i32 + Send,
-        {
-        }
-    };
-
-    snapshot!(input as ItemFn, @r###"
-    ItemFn {
-        vis: Inherited,
-        sig: Signature {
-            ident: "f",
-            generics: Generics {
-                lt_token: Some,
-                params: [
-                    Type(TypeParam {
-                        ident: "G",
-                    }),
-                ],
-                gt_token: Some,
-                where_clause: Some(WhereClause {
-                    predicates: [
-                        Type(PredicateType {
-                            bounded_ty: Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "G",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                            },
-                            bounds: [
-                                Trait(TraitBound {
-                                    modifier: None,
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "FnOnce",
-                                                arguments: PathArguments::Parenthesized {
-                                                    output: Type(
-                                                        Type::Path {
-                                                            path: Path {
-                                                                segments: [
-                                                                    PathSegment {
-                                                                        ident: "i32",
-                                                                        arguments: None,
-                                                                    },
-                                                                ],
-                                                            },
-                                                        },
-                                                    ),
-                                                },
-                                            },
-                                        ],
-                                    },
-                                }),
-                                Trait(TraitBound {
-                                    modifier: None,
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "Send",
-                                                arguments: None,
-                                            },
-                                        ],
-                                    },
-                                }),
-                            ],
-                        }),
-                    ],
-                }),
-            },
-            output: Default,
-        },
-        block: Block,
-    }
-    "###);
-
-    let where_clause = input.sig.generics.where_clause.as_ref().unwrap();
-    assert_eq!(where_clause.predicates.len(), 1);
-
-    let predicate = match &where_clause.predicates[0] {
-        WherePredicate::Type(pred) => pred,
-        _ => panic!("wrong predicate kind"),
-    };
-
-    assert_eq!(predicate.bounds.len(), 2, "{:#?}", predicate.bounds);
-
-    let first_bound = &predicate.bounds[0];
-    assert_eq!(quote!(#first_bound).to_string(), "FnOnce () -> i32");
-
-    let second_bound = &predicate.bounds[1];
-    assert_eq!(quote!(#second_bound).to_string(), "Send");
-}
-
-#[test]
-fn test_where_clause_at_end_of_input() {
-    let input = quote! {
-        where
-    };
-
-    snapshot!(input as WhereClause, @"WhereClause");
-
-    assert_eq!(input.predicates.len(), 0);
-}
diff --git a/vendor/syn/tests/test_grouping.rs b/vendor/syn/tests/test_grouping.rs
deleted file mode 100644
index 9eb7eee9..00000000
--- a/vendor/syn/tests/test_grouping.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Literal, Punct, Spacing, TokenStream, TokenTree};
-use std::iter::FromIterator;
-use syn::Expr;
-
-#[test]
-fn test_grouping() {
-    let tokens: TokenStream = TokenStream::from_iter(vec![
-        TokenTree::Literal(Literal::i32_suffixed(1)),
-        TokenTree::Punct(Punct::new('+', Spacing::Alone)),
-        TokenTree::Group(Group::new(
-            Delimiter::None,
-            TokenStream::from_iter(vec![
-                TokenTree::Literal(Literal::i32_suffixed(2)),
-                TokenTree::Punct(Punct::new('+', Spacing::Alone)),
-                TokenTree::Literal(Literal::i32_suffixed(3)),
-            ]),
-        )),
-        TokenTree::Punct(Punct::new('*', Spacing::Alone)),
-        TokenTree::Literal(Literal::i32_suffixed(4)),
-    ]);
-
-    assert_eq!(tokens.to_string(), "1i32 + 2i32 + 3i32 * 4i32");
-
-    snapshot!(tokens as Expr, @r###"
-    Expr::Binary {
-        left: Expr::Lit {
-            lit: 1i32,
-        },
-        op: Add,
-        right: Expr::Binary {
-            left: Expr::Group {
-                expr: Expr::Binary {
-                    left: Expr::Lit {
-                        lit: 2i32,
-                    },
-                    op: Add,
-                    right: Expr::Lit {
-                        lit: 3i32,
-                    },
-                },
-            },
-            op: Mul,
-            right: Expr::Lit {
-                lit: 4i32,
-            },
-        },
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_ident.rs b/vendor/syn/tests/test_ident.rs
deleted file mode 100644
index ee01bfcc..00000000
--- a/vendor/syn/tests/test_ident.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use proc_macro2::{Ident, Span, TokenStream};
-use std::str::FromStr;
-use syn::Result;
-
-fn parse(s: &str) -> Result<Ident> {
-    syn::parse2(TokenStream::from_str(s).unwrap())
-}
-
-fn new(s: &str) -> Ident {
-    Ident::new(s, Span::call_site())
-}
-
-#[test]
-fn ident_parse() {
-    parse("String").unwrap();
-}
-
-#[test]
-fn ident_parse_keyword() {
-    parse("abstract").unwrap_err();
-}
-
-#[test]
-fn ident_parse_empty() {
-    parse("").unwrap_err();
-}
-
-#[test]
-fn ident_parse_lifetime() {
-    parse("'static").unwrap_err();
-}
-
-#[test]
-fn ident_parse_underscore() {
-    parse("_").unwrap_err();
-}
-
-#[test]
-fn ident_parse_number() {
-    parse("255").unwrap_err();
-}
-
-#[test]
-fn ident_parse_invalid() {
-    parse("a#").unwrap_err();
-}
-
-#[test]
-fn ident_new() {
-    new("String");
-}
-
-#[test]
-fn ident_new_keyword() {
-    new("abstract");
-}
-
-#[test]
-#[should_panic(expected = "use Option<Ident>")]
-fn ident_new_empty() {
-    new("");
-}
-
-#[test]
-#[should_panic(expected = "not a valid Ident")]
-fn ident_new_lifetime() {
-    new("'static");
-}
-
-#[test]
-fn ident_new_underscore() {
-    new("_");
-}
-
-#[test]
-#[should_panic(expected = "use Literal instead")]
-fn ident_new_number() {
-    new("255");
-}
-
-#[test]
-#[should_panic(expected = "\"a#\" is not a valid Ident")]
-fn ident_new_invalid() {
-    new("a#");
-}
diff --git a/vendor/syn/tests/test_item.rs b/vendor/syn/tests/test_item.rs
deleted file mode 100644
index a991e62d..00000000
--- a/vendor/syn/tests/test_item.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
-use quote::quote;
-use std::iter::FromIterator;
-use syn::{Item, ItemTrait};
-
-#[test]
-fn test_macro_variable_attr() {
-    // mimics the token stream corresponding to `$attr fn f() {}`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { #[test] })),
-        TokenTree::Ident(Ident::new("fn", Span::call_site())),
-        TokenTree::Ident(Ident::new("f", Span::call_site())),
-        TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-        TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Item, @r###"
-    Item::Fn {
-        attrs: [
-            Attribute {
-                style: Outer,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "test",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(``),
-            },
-        ],
-        vis: Inherited,
-        sig: Signature {
-            ident: "f",
-            generics: Generics,
-            output: Default,
-        },
-        block: Block,
-    }
-    "###);
-}
-
-#[test]
-fn test_negative_impl() {
-    // Rustc parses all of the following.
-
-    #[cfg(any())]
-    impl ! {}
-    let tokens = quote! {
-        impl ! {}
-    };
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics,
-        self_ty: Type::Never,
-    }
-    "###);
-
-    #[cfg(any())]
-    #[rustfmt::skip]
-    impl !Trait {}
-    let tokens = quote! {
-        impl !Trait {}
-    };
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics,
-        self_ty: Verbatim(`! Trait`),
-    }
-    "###);
-
-    #[cfg(any())]
-    impl !Trait for T {}
-    let tokens = quote! {
-        impl !Trait for T {}
-    };
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics,
-        trait_: Some((
-            Some,
-            Path {
-                segments: [
-                    PathSegment {
-                        ident: "Trait",
-                        arguments: None,
-                    },
-                ],
-            },
-        )),
-        self_ty: Type::Path {
-            path: Path {
-                segments: [
-                    PathSegment {
-                        ident: "T",
-                        arguments: None,
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-
-    #[cfg(any())]
-    #[rustfmt::skip]
-    impl !! {}
-    let tokens = quote! {
-        impl !! {}
-    };
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics,
-        self_ty: Verbatim(`! !`),
-    }
-    "###);
-}
-
-#[test]
-fn test_macro_variable_impl() {
-    // mimics the token stream corresponding to `impl $trait for $ty {}`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Ident(Ident::new("impl", Span::call_site())),
-        TokenTree::Group(Group::new(Delimiter::None, quote!(Trait))),
-        TokenTree::Ident(Ident::new("for", Span::call_site())),
-        TokenTree::Group(Group::new(Delimiter::None, quote!(Type))),
-        TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::new())),
-    ]);
-
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics,
-        trait_: Some((
-            None,
-            Path {
-                segments: [
-                    PathSegment {
-                        ident: "Trait",
-                        arguments: None,
-                    },
-                ],
-            },
-        )),
-        self_ty: Type::Group {
-            elem: Type::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Type",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_supertraits() {
-    // Rustc parses all of the following.
-
-    #[rustfmt::skip]
-    let tokens = quote!(trait Trait where {});
-    snapshot!(tokens as ItemTrait, @r###"
-    ItemTrait {
-        vis: Inherited,
-        ident: "Trait",
-        generics: Generics {
-            where_clause: Some(WhereClause),
-        },
-    }
-    "###);
-
-    #[rustfmt::skip]
-    let tokens = quote!(trait Trait: where {});
-    snapshot!(tokens as ItemTrait, @r###"
-    ItemTrait {
-        vis: Inherited,
-        ident: "Trait",
-        generics: Generics {
-            where_clause: Some(WhereClause),
-        },
-        colon_token: Some,
-    }
-    "###);
-
-    #[rustfmt::skip]
-    let tokens = quote!(trait Trait: Sized where {});
-    snapshot!(tokens as ItemTrait, @r###"
-    ItemTrait {
-        vis: Inherited,
-        ident: "Trait",
-        generics: Generics {
-            where_clause: Some(WhereClause),
-        },
-        colon_token: Some,
-        supertraits: [
-            Trait(TraitBound {
-                modifier: None,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Sized",
-                            arguments: None,
-                        },
-                    ],
-                },
-            }),
-        ],
-    }
-    "###);
-
-    #[rustfmt::skip]
-    let tokens = quote!(trait Trait: Sized + where {});
-    snapshot!(tokens as ItemTrait, @r###"
-    ItemTrait {
-        vis: Inherited,
-        ident: "Trait",
-        generics: Generics {
-            where_clause: Some(WhereClause),
-        },
-        colon_token: Some,
-        supertraits: [
-            Trait(TraitBound {
-                modifier: None,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Sized",
-                            arguments: None,
-                        },
-                    ],
-                },
-            }),
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_type_empty_bounds() {
-    #[rustfmt::skip]
-    let tokens = quote! {
-        trait Foo {
-            type Bar: ;
-        }
-    };
-
-    snapshot!(tokens as ItemTrait, @r###"
-    ItemTrait {
-        vis: Inherited,
-        ident: "Foo",
-        generics: Generics,
-        items: [
-            TraitItem::Type {
-                ident: "Bar",
-                generics: Generics,
-                colon_token: Some,
-            },
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_impl_visibility() {
-    let tokens = quote! {
-        pub default unsafe impl union {}
-    };
-
-    snapshot!(tokens as Item, @"Verbatim(`pub default unsafe impl union { }`)");
-}
-
-#[test]
-fn test_impl_type_parameter_defaults() {
-    #[cfg(any())]
-    impl<T = ()> () {}
-    let tokens = quote! {
-        impl<T = ()> () {}
-    };
-    snapshot!(tokens as Item, @r###"
-    Item::Impl {
-        generics: Generics {
-            lt_token: Some,
-            params: [
-                Type(TypeParam {
-                    ident: "T",
-                    eq_token: Some,
-                    default: Some(Type::Tuple),
-                }),
-            ],
-            gt_token: Some,
-        },
-        self_ty: Type::Tuple,
-    }"###);
-}
diff --git a/vendor/syn/tests/test_iterators.rs b/vendor/syn/tests/test_iterators.rs
deleted file mode 100644
index 2c8359c1..00000000
--- a/vendor/syn/tests/test_iterators.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use syn::punctuated::{Pair, Punctuated};
-use syn::Token;
-
-#[macro_use]
-mod macros;
-
-macro_rules! check_exact_size_iterator {
-    ($iter:expr) => {{
-        let iter = $iter;
-        let size_hint = iter.size_hint();
-        let len = iter.len();
-        let count = iter.count();
-        assert_eq!(len, count);
-        assert_eq!(size_hint, (count, Some(count)));
-    }};
-}
-
-#[test]
-fn pairs() {
-    let mut p: Punctuated<_, Token![,]> = punctuated!(2, 3, 4);
-
-    check_exact_size_iterator!(p.pairs());
-    check_exact_size_iterator!(p.pairs_mut());
-    check_exact_size_iterator!(p.into_pairs());
-
-    let mut p: Punctuated<_, Token![,]> = punctuated!(2, 3, 4);
-
-    assert_eq!(p.pairs().next_back().map(Pair::into_value), Some(&4));
-    assert_eq!(
-        p.pairs_mut().next_back().map(Pair::into_value),
-        Some(&mut 4)
-    );
-    assert_eq!(p.into_pairs().next_back().map(Pair::into_value), Some(4));
-}
-
-#[test]
-fn iter() {
-    let mut p: Punctuated<_, Token![,]> = punctuated!(2, 3, 4);
-
-    check_exact_size_iterator!(p.iter());
-    check_exact_size_iterator!(p.iter_mut());
-    check_exact_size_iterator!(p.into_iter());
-
-    let mut p: Punctuated<_, Token![,]> = punctuated!(2, 3, 4);
-
-    assert_eq!(p.iter().next_back(), Some(&4));
-    assert_eq!(p.iter_mut().next_back(), Some(&mut 4));
-    assert_eq!(p.into_iter().next_back(), Some(4));
-}
diff --git a/vendor/syn/tests/test_lit.rs b/vendor/syn/tests/test_lit.rs
deleted file mode 100644
index 099daf10..00000000
--- a/vendor/syn/tests/test_lit.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Literal, Span, TokenStream, TokenTree};
-use quote::ToTokens;
-use std::iter::FromIterator;
-use std::str::FromStr;
-use syn::{Lit, LitFloat, LitInt, LitStr};
-
-fn lit(s: &str) -> Lit {
-    match TokenStream::from_str(s)
-        .unwrap()
-        .into_iter()
-        .next()
-        .unwrap()
-    {
-        TokenTree::Literal(lit) => Lit::new(lit),
-        _ => panic!(),
-    }
-}
-
-#[test]
-fn strings() {
-    fn test_string(s: &str, value: &str) {
-        match lit(s) {
-            Lit::Str(lit) => {
-                assert_eq!(lit.value(), value);
-                let again = lit.into_token_stream().to_string();
-                if again != s {
-                    test_string(&again, value);
-                }
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_string("\"a\"", "a");
-    test_string("\"\\n\"", "\n");
-    test_string("\"\\r\"", "\r");
-    test_string("\"\\t\"", "\t");
-    test_string("\"🐕\"", "🐕"); // NOTE: This is an emoji
-    test_string("\"\\\"\"", "\"");
-    test_string("\"'\"", "'");
-    test_string("\"\"", "");
-    test_string("\"\\u{1F415}\"", "\u{1F415}");
-    test_string("\"\\u{1_2__3_}\"", "\u{123}");
-    test_string(
-        "\"contains\nnewlines\\\nescaped newlines\"",
-        "contains\nnewlinesescaped newlines",
-    );
-    test_string("r\"raw\nstring\\\nhere\"", "raw\nstring\\\nhere");
-    test_string("\"...\"q", "...");
-    test_string("r\"...\"q", "...");
-    test_string("r##\"...\"##q", "...");
-}
-
-#[test]
-fn byte_strings() {
-    fn test_byte_string(s: &str, value: &[u8]) {
-        match lit(s) {
-            Lit::ByteStr(lit) => {
-                assert_eq!(lit.value(), value);
-                let again = lit.into_token_stream().to_string();
-                if again != s {
-                    test_byte_string(&again, value);
-                }
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_byte_string("b\"a\"", b"a");
-    test_byte_string("b\"\\n\"", b"\n");
-    test_byte_string("b\"\\r\"", b"\r");
-    test_byte_string("b\"\\t\"", b"\t");
-    test_byte_string("b\"\\\"\"", b"\"");
-    test_byte_string("b\"'\"", b"'");
-    test_byte_string("b\"\"", b"");
-    test_byte_string(
-        "b\"contains\nnewlines\\\nescaped newlines\"",
-        b"contains\nnewlinesescaped newlines",
-    );
-    test_byte_string("br\"raw\nstring\\\nhere\"", b"raw\nstring\\\nhere");
-    test_byte_string("b\"...\"q", b"...");
-    test_byte_string("br\"...\"q", b"...");
-    test_byte_string("br##\"...\"##q", b"...");
-}
-
-#[test]
-fn bytes() {
-    fn test_byte(s: &str, value: u8) {
-        match lit(s) {
-            Lit::Byte(lit) => {
-                assert_eq!(lit.value(), value);
-                let again = lit.into_token_stream().to_string();
-                assert_eq!(again, s);
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_byte("b'a'", b'a');
-    test_byte("b'\\n'", b'\n');
-    test_byte("b'\\r'", b'\r');
-    test_byte("b'\\t'", b'\t');
-    test_byte("b'\\''", b'\'');
-    test_byte("b'\"'", b'"');
-    test_byte("b'a'q", b'a');
-}
-
-#[test]
-fn chars() {
-    fn test_char(s: &str, value: char) {
-        match lit(s) {
-            Lit::Char(lit) => {
-                assert_eq!(lit.value(), value);
-                let again = lit.into_token_stream().to_string();
-                if again != s {
-                    test_char(&again, value);
-                }
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_char("'a'", 'a');
-    test_char("'\\n'", '\n');
-    test_char("'\\r'", '\r');
-    test_char("'\\t'", '\t');
-    test_char("'🐕'", '🐕'); // NOTE: This is an emoji
-    test_char("'\\''", '\'');
-    test_char("'\"'", '"');
-    test_char("'\\u{1F415}'", '\u{1F415}');
-    test_char("'a'q", 'a');
-}
-
-#[test]
-fn ints() {
-    fn test_int(s: &str, value: u64, suffix: &str) {
-        match lit(s) {
-            Lit::Int(lit) => {
-                assert_eq!(lit.base10_digits().parse::<u64>().unwrap(), value);
-                assert_eq!(lit.suffix(), suffix);
-                let again = lit.into_token_stream().to_string();
-                if again != s {
-                    test_int(&again, value, suffix);
-                }
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_int("5", 5, "");
-    test_int("5u32", 5, "u32");
-    test_int("0E", 0, "E");
-    test_int("0ECMA", 0, "ECMA");
-    test_int("0o0A", 0, "A");
-    test_int("5_0", 50, "");
-    test_int("5_____0_____", 50, "");
-    test_int("0x7f", 127, "");
-    test_int("0x7F", 127, "");
-    test_int("0b1001", 9, "");
-    test_int("0o73", 59, "");
-    test_int("0x7Fu8", 127, "u8");
-    test_int("0b1001i8", 9, "i8");
-    test_int("0o73u32", 59, "u32");
-    test_int("0x__7___f_", 127, "");
-    test_int("0x__7___F_", 127, "");
-    test_int("0b_1_0__01", 9, "");
-    test_int("0o_7__3", 59, "");
-    test_int("0x_7F__u8", 127, "u8");
-    test_int("0b__10__0_1i8", 9, "i8");
-    test_int("0o__7__________________3u32", 59, "u32");
-    test_int("0e1\u{5c5}", 0, "e1\u{5c5}");
-}
-
-#[test]
-fn floats() {
-    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
-    fn test_float(s: &str, value: f64, suffix: &str) {
-        match lit(s) {
-            Lit::Float(lit) => {
-                assert_eq!(lit.base10_digits().parse::<f64>().unwrap(), value);
-                assert_eq!(lit.suffix(), suffix);
-                let again = lit.into_token_stream().to_string();
-                if again != s {
-                    test_float(&again, value, suffix);
-                }
-            }
-            wrong => panic!("{:?}", wrong),
-        }
-    }
-
-    test_float("5.5", 5.5, "");
-    test_float("5.5E12", 5.5e12, "");
-    test_float("5.5e12", 5.5e12, "");
-    test_float("1.0__3e-12", 1.03e-12, "");
-    test_float("1.03e+12", 1.03e12, "");
-    test_float("9e99e99", 9e99, "e99");
-    test_float("1e_0", 1.0, "");
-    test_float("0.0ECMA", 0.0, "ECMA");
-}
-
-#[test]
-fn negative() {
-    let span = Span::call_site();
-    assert_eq!("-1", LitInt::new("-1", span).to_string());
-    assert_eq!("-1i8", LitInt::new("-1i8", span).to_string());
-    assert_eq!("-1i16", LitInt::new("-1i16", span).to_string());
-    assert_eq!("-1i32", LitInt::new("-1i32", span).to_string());
-    assert_eq!("-1i64", LitInt::new("-1i64", span).to_string());
-    assert_eq!("-1.5", LitFloat::new("-1.5", span).to_string());
-    assert_eq!("-1.5f32", LitFloat::new("-1.5f32", span).to_string());
-    assert_eq!("-1.5f64", LitFloat::new("-1.5f64", span).to_string());
-}
-
-#[test]
-fn negative_overflow() {
-    assert!(syn::parse_str::<LitFloat>("-1.0e99f64").is_ok());
-    assert!(syn::parse_str::<LitFloat>("-1.0e999f64").is_err());
-}
-
-#[test]
-fn suffix() {
-    fn get_suffix(token: &str) -> String {
-        let lit = syn::parse_str::<Lit>(token).unwrap();
-        match lit {
-            Lit::Str(lit) => lit.suffix().to_owned(),
-            Lit::ByteStr(lit) => lit.suffix().to_owned(),
-            Lit::Byte(lit) => lit.suffix().to_owned(),
-            Lit::Char(lit) => lit.suffix().to_owned(),
-            Lit::Int(lit) => lit.suffix().to_owned(),
-            Lit::Float(lit) => lit.suffix().to_owned(),
-            _ => unimplemented!(),
-        }
-    }
-
-    assert_eq!(get_suffix("\"\"s"), "s");
-    assert_eq!(get_suffix("r\"\"r"), "r");
-    assert_eq!(get_suffix("b\"\"b"), "b");
-    assert_eq!(get_suffix("br\"\"br"), "br");
-    assert_eq!(get_suffix("r#\"\"#r"), "r");
-    assert_eq!(get_suffix("'c'c"), "c");
-    assert_eq!(get_suffix("b'b'b"), "b");
-    assert_eq!(get_suffix("1i32"), "i32");
-    assert_eq!(get_suffix("1_i32"), "i32");
-    assert_eq!(get_suffix("1.0f32"), "f32");
-    assert_eq!(get_suffix("1.0_f32"), "f32");
-}
-
-#[test]
-fn test_deep_group_empty() {
-    let tokens = TokenStream::from_iter(vec![TokenTree::Group(Group::new(
-        Delimiter::None,
-        TokenStream::from_iter(vec![TokenTree::Group(Group::new(
-            Delimiter::None,
-            TokenStream::from_iter(vec![TokenTree::Literal(Literal::string("hi"))]),
-        ))]),
-    ))]);
-
-    snapshot!(tokens as Lit, @r#""hi""# );
-}
-
-#[test]
-fn test_error() {
-    let err = syn::parse_str::<LitStr>("...").unwrap_err();
-    assert_eq!("expected string literal", err.to_string());
-
-    let err = syn::parse_str::<LitStr>("5").unwrap_err();
-    assert_eq!("expected string literal", err.to_string());
-}
diff --git a/vendor/syn/tests/test_meta.rs b/vendor/syn/tests/test_meta.rs
deleted file mode 100644
index de6cc4da..00000000
--- a/vendor/syn/tests/test_meta.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-#[macro_use]
-mod macros;
-
-use syn::{Meta, MetaList, MetaNameValue, NestedMeta};
-
-#[test]
-fn test_parse_meta_item_word() {
-    let input = "hello";
-
-    snapshot!(input as Meta, @r###"
-    Path(Path {
-        segments: [
-            PathSegment {
-                ident: "hello",
-                arguments: None,
-            },
-        ],
-    })
-    "###);
-}
-
-#[test]
-fn test_parse_meta_name_value() {
-    let input = "foo = 5";
-    let (inner, meta) = (input, input);
-
-    snapshot!(inner as MetaNameValue, @r###"
-    MetaNameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    snapshot!(meta as Meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    assert_eq!(meta, inner.into());
-}
-
-#[test]
-fn test_parse_meta_name_value_with_keyword() {
-    let input = "static = 5";
-    let (inner, meta) = (input, input);
-
-    snapshot!(inner as MetaNameValue, @r###"
-    MetaNameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "static",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    snapshot!(meta as Meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "static",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    assert_eq!(meta, inner.into());
-}
-
-#[test]
-fn test_parse_meta_name_value_with_bool() {
-    let input = "true = 5";
-    let (inner, meta) = (input, input);
-
-    snapshot!(inner as MetaNameValue, @r###"
-    MetaNameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "true",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    snapshot!(meta as Meta, @r###"
-    Meta::NameValue {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "true",
-                    arguments: None,
-                },
-            ],
-        },
-        lit: 5,
-    }
-    "###);
-
-    assert_eq!(meta, inner.into());
-}
-
-#[test]
-fn test_parse_meta_item_list_lit() {
-    let input = "foo(5)";
-    let (inner, meta) = (input, input);
-
-    snapshot!(inner as MetaList, @r###"
-    MetaList {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Lit(5),
-        ],
-    }
-    "###);
-
-    snapshot!(meta as Meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Lit(5),
-        ],
-    }
-    "###);
-
-    assert_eq!(meta, inner.into());
-}
-
-#[test]
-fn test_parse_meta_item_multiple() {
-    let input = "foo(word, name = 5, list(name2 = 6), word2)";
-    let (inner, meta) = (input, input);
-
-    snapshot!(inner as MetaList, @r###"
-    MetaList {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word",
-                        arguments: None,
-                    },
-                ],
-            })),
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "name",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 5,
-            }),
-            Meta(Meta::List {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "list",
-                            arguments: None,
-                        },
-                    ],
-                },
-                nested: [
-                    Meta(Meta::NameValue {
-                        path: Path {
-                            segments: [
-                                PathSegment {
-                                    ident: "name2",
-                                    arguments: None,
-                                },
-                            ],
-                        },
-                        lit: 6,
-                    }),
-                ],
-            }),
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word2",
-                        arguments: None,
-                    },
-                ],
-            })),
-        ],
-    }
-    "###);
-
-    snapshot!(meta as Meta, @r###"
-    Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "foo",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word",
-                        arguments: None,
-                    },
-                ],
-            })),
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "name",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 5,
-            }),
-            Meta(Meta::List {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "list",
-                            arguments: None,
-                        },
-                    ],
-                },
-                nested: [
-                    Meta(Meta::NameValue {
-                        path: Path {
-                            segments: [
-                                PathSegment {
-                                    ident: "name2",
-                                    arguments: None,
-                                },
-                            ],
-                        },
-                        lit: 6,
-                    }),
-                ],
-            }),
-            Meta(Path(Path {
-                segments: [
-                    PathSegment {
-                        ident: "word2",
-                        arguments: None,
-                    },
-                ],
-            })),
-        ],
-    }
-    "###);
-
-    assert_eq!(meta, inner.into());
-}
-
-#[test]
-fn test_parse_nested_meta() {
-    let input = "5";
-    snapshot!(input as NestedMeta, @"Lit(5)");
-
-    let input = "list(name2 = 6)";
-    snapshot!(input as NestedMeta, @r###"
-    Meta(Meta::List {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "list",
-                    arguments: None,
-                },
-            ],
-        },
-        nested: [
-            Meta(Meta::NameValue {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "name2",
-                            arguments: None,
-                        },
-                    ],
-                },
-                lit: 6,
-            }),
-        ],
-    })
-    "###);
-}
-
-#[test]
-fn test_parse_path() {
-    let input = "::serde::Serialize";
-    snapshot!(input as Meta, @r###"
-    Path(Path {
-        leading_colon: Some,
-        segments: [
-            PathSegment {
-                ident: "serde",
-                arguments: None,
-            },
-            PathSegment {
-                ident: "Serialize",
-                arguments: None,
-            },
-        ],
-    })
-    "###);
-
-    let input = "::serde::Serialize";
-    snapshot!(input as NestedMeta, @r###"
-    Meta(Path(Path {
-        leading_colon: Some,
-        segments: [
-            PathSegment {
-                ident: "serde",
-                arguments: None,
-            },
-            PathSegment {
-                ident: "Serialize",
-                arguments: None,
-            },
-        ],
-    }))
-    "###);
-}
diff --git a/vendor/syn/tests/test_parse_buffer.rs b/vendor/syn/tests/test_parse_buffer.rs
deleted file mode 100644
index 57a3c7c3..00000000
--- a/vendor/syn/tests/test_parse_buffer.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use proc_macro2::{Delimiter, Group, Punct, Spacing, TokenStream, TokenTree};
-use std::iter::FromIterator;
-use syn::parse::{discouraged::Speculative, Parse, ParseStream, Parser, Result};
-use syn::{parenthesized, Token};
-
-#[test]
-#[should_panic(expected = "Fork was not derived from the advancing parse stream")]
-fn smuggled_speculative_cursor_between_sources() {
-    struct BreakRules;
-    impl Parse for BreakRules {
-        fn parse(input1: ParseStream) -> Result<Self> {
-            let nested = |input2: ParseStream| {
-                input1.advance_to(&input2);
-                Ok(Self)
-            };
-            nested.parse_str("")
-        }
-    }
-
-    syn::parse_str::<BreakRules>("").unwrap();
-}
-
-#[test]
-#[should_panic(expected = "Fork was not derived from the advancing parse stream")]
-fn smuggled_speculative_cursor_between_brackets() {
-    struct BreakRules;
-    impl Parse for BreakRules {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let a;
-            let b;
-            parenthesized!(a in input);
-            parenthesized!(b in input);
-            a.advance_to(&b);
-            Ok(Self)
-        }
-    }
-
-    syn::parse_str::<BreakRules>("()()").unwrap();
-}
-
-#[test]
-#[should_panic(expected = "Fork was not derived from the advancing parse stream")]
-fn smuggled_speculative_cursor_into_brackets() {
-    struct BreakRules;
-    impl Parse for BreakRules {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let a;
-            parenthesized!(a in input);
-            input.advance_to(&a);
-            Ok(Self)
-        }
-    }
-
-    syn::parse_str::<BreakRules>("()").unwrap();
-}
-
-#[test]
-fn trailing_empty_none_group() {
-    fn parse(input: ParseStream) -> Result<()> {
-        input.parse::<Token![+]>()?;
-
-        let content;
-        parenthesized!(content in input);
-        content.parse::<Token![+]>()?;
-
-        Ok(())
-    }
-
-    // `+ ( + <Ø Ø> ) <Ø <Ø Ø> Ø>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Punct(Punct::new('+', Spacing::Alone)),
-        TokenTree::Group(Group::new(
-            Delimiter::Parenthesis,
-            TokenStream::from_iter(vec![
-                TokenTree::Punct(Punct::new('+', Spacing::Alone)),
-                TokenTree::Group(Group::new(Delimiter::None, TokenStream::new())),
-            ]),
-        )),
-        TokenTree::Group(Group::new(Delimiter::None, TokenStream::new())),
-        TokenTree::Group(Group::new(
-            Delimiter::None,
-            TokenStream::from_iter(vec![TokenTree::Group(Group::new(
-                Delimiter::None,
-                TokenStream::new(),
-            ))]),
-        )),
-    ]);
-
-    parse.parse2(tokens).unwrap();
-}
diff --git a/vendor/syn/tests/test_parse_stream.rs b/vendor/syn/tests/test_parse_stream.rs
deleted file mode 100644
index 76bd0657..00000000
--- a/vendor/syn/tests/test_parse_stream.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use syn::ext::IdentExt;
-use syn::parse::ParseStream;
-use syn::{Ident, Token};
-
-#[test]
-fn test_peek() {
-    let _ = |input: ParseStream| {
-        let _ = input.peek(Ident);
-        let _ = input.peek(Ident::peek_any);
-        let _ = input.peek(Token![::]);
-    };
-}
diff --git a/vendor/syn/tests/test_pat.rs b/vendor/syn/tests/test_pat.rs
deleted file mode 100644
index 695e4736..00000000
--- a/vendor/syn/tests/test_pat.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
-use quote::quote;
-use std::iter::FromIterator;
-use syn::{Item, Pat, Stmt};
-
-#[test]
-fn test_pat_ident() {
-    match syn::parse2(quote!(self)).unwrap() {
-        Pat::Ident(_) => (),
-        value => panic!("expected PatIdent, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_pat_path() {
-    match syn::parse2(quote!(self::CONST)).unwrap() {
-        Pat::Path(_) => (),
-        value => panic!("expected PatPath, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_leading_vert() {
-    // https://github.com/rust-lang/rust/blob/1.43.0/src/test/ui/or-patterns/remove-leading-vert.rs
-
-    syn::parse_str::<Item>("fn f() {}").unwrap();
-    syn::parse_str::<Item>("fn fun1(| A: E) {}").unwrap_err();
-    syn::parse_str::<Item>("fn fun2(|| A: E) {}").unwrap_err();
-
-    syn::parse_str::<Stmt>("let | () = ();").unwrap();
-    syn::parse_str::<Stmt>("let (| A): E;").unwrap();
-    syn::parse_str::<Stmt>("let (|| A): (E);").unwrap_err();
-    syn::parse_str::<Stmt>("let (| A,): (E,);").unwrap();
-    syn::parse_str::<Stmt>("let [| A]: [E; 1];").unwrap();
-    syn::parse_str::<Stmt>("let [|| A]: [E; 1];").unwrap_err();
-    syn::parse_str::<Stmt>("let TS(| A): TS;").unwrap();
-    syn::parse_str::<Stmt>("let TS(|| A): TS;").unwrap_err();
-    syn::parse_str::<Stmt>("let NS { f: | A }: NS;").unwrap();
-    syn::parse_str::<Stmt>("let NS { f: || A }: NS;").unwrap_err();
-}
-
-#[test]
-fn test_group() {
-    let group = Group::new(Delimiter::None, quote!(Some(_)));
-    let tokens = TokenStream::from_iter(vec![TokenTree::Group(group)]);
-
-    snapshot!(tokens as Pat, @r###"
-    Pat::TupleStruct {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Some",
-                    arguments: None,
-                },
-            ],
-        },
-        pat: PatTuple {
-            elems: [
-                Pat::Wild,
-            ],
-        },
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_path.rs b/vendor/syn/tests/test_path.rs
deleted file mode 100644
index e05b52ee..00000000
--- a/vendor/syn/tests/test_path.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
-use quote::{quote, ToTokens};
-use std::iter::FromIterator;
-use syn::{parse_quote, Expr, Type, TypePath};
-
-#[test]
-fn parse_interpolated_leading_component() {
-    // mimics the token stream corresponding to `$mod::rest`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { first })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("rest", Span::call_site())),
-    ]);
-
-    snapshot!(tokens.clone() as Expr, @r###"
-    Expr::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "first",
-                    arguments: None,
-                },
-                PathSegment {
-                    ident: "rest",
-                    arguments: None,
-                },
-            ],
-        },
-    }
-    "###);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "first",
-                    arguments: None,
-                },
-                PathSegment {
-                    ident: "rest",
-                    arguments: None,
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn print_incomplete_qpath() {
-    // qpath with `as` token
-    let mut ty: TypePath = parse_quote!(<Self as A>::Q);
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self as A > :: Q`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self as A > ::`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self >`)
-    "###);
-    assert!(ty.path.segments.pop().is_none());
-
-    // qpath without `as` token
-    let mut ty: TypePath = parse_quote!(<Self>::A::B);
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self > :: A :: B`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self > :: A ::`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`< Self > ::`)
-    "###);
-    assert!(ty.path.segments.pop().is_none());
-
-    // normal path
-    let mut ty: TypePath = parse_quote!(Self::A::B);
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`Self :: A :: B`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`Self :: A ::`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(`Self ::`)
-    "###);
-    assert!(ty.path.segments.pop().is_some());
-    snapshot!(ty.to_token_stream(), @r###"
-    TokenStream(``)
-    "###);
-    assert!(ty.path.segments.pop().is_none());
-}
diff --git a/vendor/syn/tests/test_precedence.rs b/vendor/syn/tests/test_precedence.rs
deleted file mode 100644
index b4526308..00000000
--- a/vendor/syn/tests/test_precedence.rs
+++ /dev/null
@@ -1,416 +0,0 @@
-#![cfg(not(syn_disable_nightly_tests))]
-#![recursion_limit = "1024"]
-#![feature(rustc_private)]
-
-//! The tests in this module do the following:
-//!
-//! 1. Parse a given expression in both `syn` and `librustc`.
-//! 2. Fold over the expression adding brackets around each subexpression (with
-//!    some complications - see the `syn_brackets` and `librustc_brackets`
-//!    methods).
-//! 3. Serialize the `syn` expression back into a string, and re-parse it with
-//!    `librustc`.
-//! 4. Respan all of the expressions, replacing the spans with the default
-//!    spans.
-//! 5. Compare the expressions with one another, if they are not equal fail.
-
-extern crate rustc_ast;
-extern crate rustc_data_structures;
-extern crate rustc_span;
-
-use crate::common::eq::SpanlessEq;
-use crate::common::parse;
-use quote::quote;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use regex::Regex;
-use rustc_ast::ast;
-use rustc_ast::ptr::P;
-use rustc_span::edition::Edition;
-use std::fs;
-use std::process;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use walkdir::{DirEntry, WalkDir};
-
-#[macro_use]
-mod macros;
-
-#[allow(dead_code)]
-mod common;
-
-mod repo;
-
-/// Test some pre-set expressions chosen by us.
-#[test]
-fn test_simple_precedence() {
-    const EXPRS: &[&str] = &[
-        "1 + 2 * 3 + 4",
-        "1 + 2 * ( 3 + 4 )",
-        "{ for i in r { } *some_ptr += 1; }",
-        "{ loop { break 5; } }",
-        "{ if true { () }.mthd() }",
-        "{ for i in unsafe { 20 } { } }",
-    ];
-
-    let mut failed = 0;
-
-    for input in EXPRS {
-        let expr = if let Some(expr) = parse::syn_expr(input) {
-            expr
-        } else {
-            failed += 1;
-            continue;
-        };
-
-        let pf = match test_expressions(Edition::Edition2018, vec![expr]) {
-            (1, 0) => "passed",
-            (0, 1) => {
-                failed += 1;
-                "failed"
-            }
-            _ => unreachable!(),
-        };
-        errorf!("=== {}: {}\n", input, pf);
-    }
-
-    if failed > 0 {
-        panic!("Failed {} tests", failed);
-    }
-}
-
-/// Test expressions from rustc, like in `test_round_trip`.
-#[test]
-fn test_rustc_precedence() {
-    common::rayon_init();
-    repo::clone_rust();
-    let abort_after = common::abort_after();
-    if abort_after == 0 {
-        panic!("Skipping all precedence tests");
-    }
-
-    let passed = AtomicUsize::new(0);
-    let failed = AtomicUsize::new(0);
-
-    // 2018 edition is hard
-    let edition_regex = Regex::new(r"\b(async|try)[!(]").unwrap();
-
-    WalkDir::new("tests/rust")
-        .sort_by(|a, b| a.file_name().cmp(b.file_name()))
-        .into_iter()
-        .filter_entry(repo::base_dir_filter)
-        .collect::<Result<Vec<DirEntry>, walkdir::Error>>()
-        .unwrap()
-        .into_par_iter()
-        .for_each(|entry| {
-            let path = entry.path();
-            if path.is_dir() {
-                return;
-            }
-
-            let content = fs::read_to_string(path).unwrap();
-            let content = edition_regex.replace_all(&content, "_$0");
-
-            let (l_passed, l_failed) = match syn::parse_file(&content) {
-                Ok(file) => {
-                    let edition = repo::edition(path).parse().unwrap();
-                    let exprs = collect_exprs(file);
-                    test_expressions(edition, exprs)
-                }
-                Err(msg) => {
-                    errorf!("syn failed to parse\n{:?}\n", msg);
-                    (0, 1)
-                }
-            };
-
-            errorf!(
-                "=== {}: {} passed | {} failed\n",
-                path.display(),
-                l_passed,
-                l_failed
-            );
-
-            passed.fetch_add(l_passed, Ordering::SeqCst);
-            let prev_failed = failed.fetch_add(l_failed, Ordering::SeqCst);
-
-            if prev_failed + l_failed >= abort_after {
-                process::exit(1);
-            }
-        });
-
-    let passed = passed.load(Ordering::SeqCst);
-    let failed = failed.load(Ordering::SeqCst);
-
-    errorf!("\n===== Precedence Test Results =====\n");
-    errorf!("{} passed | {} failed\n", passed, failed);
-
-    if failed > 0 {
-        panic!("{} failures", failed);
-    }
-}
-
-fn test_expressions(edition: Edition, exprs: Vec<syn::Expr>) -> (usize, usize) {
-    let mut passed = 0;
-    let mut failed = 0;
-
-    rustc_span::create_session_if_not_set_then(edition, |_| {
-        for expr in exprs {
-            let raw = quote!(#expr).to_string();
-
-            let librustc_ast = if let Some(e) = librustc_parse_and_rewrite(&raw) {
-                e
-            } else {
-                failed += 1;
-                errorf!("\nFAIL - librustc failed to parse raw\n");
-                continue;
-            };
-
-            let syn_expr = syn_brackets(expr);
-            let syn_ast = if let Some(e) = parse::librustc_expr(&quote!(#syn_expr).to_string()) {
-                e
-            } else {
-                failed += 1;
-                errorf!("\nFAIL - librustc failed to parse bracketed\n");
-                continue;
-            };
-
-            if SpanlessEq::eq(&syn_ast, &librustc_ast) {
-                passed += 1;
-            } else {
-                failed += 1;
-                errorf!("\nFAIL\n{:?}\n!=\n{:?}\n", syn_ast, librustc_ast);
-            }
-        }
-    });
-
-    (passed, failed)
-}
-
-fn librustc_parse_and_rewrite(input: &str) -> Option<P<ast::Expr>> {
-    parse::librustc_expr(input).and_then(librustc_brackets)
-}
-
-/// Wrap every expression which is not already wrapped in parens with parens, to
-/// reveal the precidence of the parsed expressions, and produce a stringified
-/// form of the resulting expression.
-///
-/// This method operates on librustc objects.
-fn librustc_brackets(mut librustc_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
-    use rustc_ast::ast::{
-        Block, BorrowKind, Expr, ExprField, ExprKind, GenericArg, Pat, Stmt, StmtKind, StructExpr,
-        StructRest, Ty,
-    };
-    use rustc_ast::mut_visit::{noop_visit_generic_arg, MutVisitor};
-    use rustc_data_structures::map_in_place::MapInPlace;
-    use rustc_data_structures::thin_vec::ThinVec;
-    use rustc_span::DUMMY_SP;
-    use std::mem;
-    use std::ops::DerefMut;
-
-    struct BracketsVisitor {
-        failed: bool,
-    }
-
-    fn flat_map_field<T: MutVisitor>(mut f: ExprField, vis: &mut T) -> Vec<ExprField> {
-        if f.is_shorthand {
-            noop_visit_expr(&mut f.expr, vis);
-        } else {
-            vis.visit_expr(&mut f.expr);
-        }
-        vec![f]
-    }
-
-    fn flat_map_stmt<T: MutVisitor>(stmt: Stmt, vis: &mut T) -> Vec<Stmt> {
-        let kind = match stmt.kind {
-            // Don't wrap toplevel expressions in statements.
-            StmtKind::Expr(mut e) => {
-                noop_visit_expr(&mut e, vis);
-                StmtKind::Expr(e)
-            }
-            StmtKind::Semi(mut e) => {
-                noop_visit_expr(&mut e, vis);
-                StmtKind::Semi(e)
-            }
-            s => s,
-        };
-
-        vec![Stmt { kind, ..stmt }]
-    }
-
-    fn noop_visit_expr<T: MutVisitor>(e: &mut Expr, vis: &mut T) {
-        use rustc_ast::mut_visit::{noop_visit_expr, visit_thin_attrs};
-        match &mut e.kind {
-            ExprKind::AddrOf(BorrowKind::Raw, ..) => {}
-            ExprKind::Struct(expr) => {
-                let StructExpr {
-                    qself,
-                    path,
-                    fields,
-                    rest,
-                } = expr.deref_mut();
-                vis.visit_qself(qself);
-                vis.visit_path(path);
-                fields.flat_map_in_place(|field| flat_map_field(field, vis));
-                if let StructRest::Base(rest) = rest {
-                    vis.visit_expr(rest);
-                }
-                vis.visit_id(&mut e.id);
-                vis.visit_span(&mut e.span);
-                visit_thin_attrs(&mut e.attrs, vis);
-            }
-            _ => noop_visit_expr(e, vis),
-        }
-    }
-
-    impl MutVisitor for BracketsVisitor {
-        fn visit_expr(&mut self, e: &mut P<Expr>) {
-            match e.kind {
-                ExprKind::ConstBlock(..) => {}
-                _ => noop_visit_expr(e, self),
-            }
-            match e.kind {
-                ExprKind::If(..) | ExprKind::Block(..) | ExprKind::Let(..) => {}
-                _ => {
-                    let inner = mem::replace(
-                        e,
-                        P(Expr {
-                            id: ast::DUMMY_NODE_ID,
-                            kind: ExprKind::Err,
-                            span: DUMMY_SP,
-                            attrs: ThinVec::new(),
-                            tokens: None,
-                        }),
-                    );
-                    e.kind = ExprKind::Paren(inner);
-                }
-            }
-        }
-
-        fn visit_generic_arg(&mut self, arg: &mut GenericArg) {
-            match arg {
-                // Don't wrap const generic arg as that's invalid syntax.
-                GenericArg::Const(arg) => noop_visit_expr(&mut arg.value, self),
-                _ => noop_visit_generic_arg(arg, self),
-            }
-        }
-
-        fn visit_block(&mut self, block: &mut P<Block>) {
-            self.visit_id(&mut block.id);
-            block
-                .stmts
-                .flat_map_in_place(|stmt| flat_map_stmt(stmt, self));
-            self.visit_span(&mut block.span);
-        }
-
-        // We don't want to look at expressions that might appear in patterns or
-        // types yet. We'll look into comparing those in the future. For now
-        // focus on expressions appearing in other places.
-        fn visit_pat(&mut self, pat: &mut P<Pat>) {
-            let _ = pat;
-        }
-
-        fn visit_ty(&mut self, ty: &mut P<Ty>) {
-            let _ = ty;
-        }
-    }
-
-    let mut folder = BracketsVisitor { failed: false };
-    folder.visit_expr(&mut librustc_expr);
-    if folder.failed {
-        None
-    } else {
-        Some(librustc_expr)
-    }
-}
-
-/// Wrap every expression which is not already wrapped in parens with parens, to
-/// reveal the precedence of the parsed expressions, and produce a stringified
-/// form of the resulting expression.
-fn syn_brackets(syn_expr: syn::Expr) -> syn::Expr {
-    use syn::fold::*;
-    use syn::*;
-
-    struct ParenthesizeEveryExpr;
-    impl Fold for ParenthesizeEveryExpr {
-        fn fold_expr(&mut self, expr: Expr) -> Expr {
-            match expr {
-                Expr::Group(_) => unreachable!(),
-                Expr::If(..) | Expr::Unsafe(..) | Expr::Block(..) | Expr::Let(..) => {
-                    fold_expr(self, expr)
-                }
-                _ => Expr::Paren(ExprParen {
-                    attrs: Vec::new(),
-                    expr: Box::new(fold_expr(self, expr)),
-                    paren_token: token::Paren::default(),
-                }),
-            }
-        }
-
-        fn fold_generic_argument(&mut self, arg: GenericArgument) -> GenericArgument {
-            match arg {
-                // Don't wrap const generic arg as that's invalid syntax.
-                GenericArgument::Const(a) => GenericArgument::Const(fold_expr(self, a)),
-                _ => fold_generic_argument(self, arg),
-            }
-        }
-
-        fn fold_generic_method_argument(
-            &mut self,
-            arg: GenericMethodArgument,
-        ) -> GenericMethodArgument {
-            match arg {
-                // Don't wrap const generic arg as that's invalid syntax.
-                GenericMethodArgument::Const(a) => GenericMethodArgument::Const(fold_expr(self, a)),
-                _ => fold_generic_method_argument(self, arg),
-            }
-        }
-
-        fn fold_stmt(&mut self, stmt: Stmt) -> Stmt {
-            match stmt {
-                // Don't wrap toplevel expressions in statements.
-                Stmt::Expr(e) => Stmt::Expr(fold_expr(self, e)),
-                Stmt::Semi(e, semi) => Stmt::Semi(fold_expr(self, e), semi),
-                s => s,
-            }
-        }
-
-        // We don't want to look at expressions that might appear in patterns or
-        // types yet. We'll look into comparing those in the future. For now
-        // focus on expressions appearing in other places.
-        fn fold_pat(&mut self, pat: Pat) -> Pat {
-            pat
-        }
-
-        fn fold_type(&mut self, ty: Type) -> Type {
-            ty
-        }
-    }
-
-    let mut folder = ParenthesizeEveryExpr;
-    folder.fold_expr(syn_expr)
-}
-
-/// Walk through a crate collecting all expressions we can find in it.
-fn collect_exprs(file: syn::File) -> Vec<syn::Expr> {
-    use syn::fold::*;
-    use syn::punctuated::Punctuated;
-    use syn::*;
-
-    struct CollectExprs(Vec<Expr>);
-    impl Fold for CollectExprs {
-        fn fold_expr(&mut self, expr: Expr) -> Expr {
-            match expr {
-                Expr::Verbatim(tokens) if tokens.is_empty() => {}
-                _ => self.0.push(expr),
-            }
-
-            Expr::Tuple(ExprTuple {
-                attrs: vec![],
-                elems: Punctuated::new(),
-                paren_token: token::Paren::default(),
-            })
-        }
-    }
-
-    let mut folder = CollectExprs(vec![]);
-    folder.fold_file(file);
-    folder.0
-}
diff --git a/vendor/syn/tests/test_receiver.rs b/vendor/syn/tests/test_receiver.rs
deleted file mode 100644
index 923df96b..00000000
--- a/vendor/syn/tests/test_receiver.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use syn::{parse_quote, FnArg, Receiver, TraitItemMethod};
-
-#[test]
-fn test_by_value() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn by_value(self: Self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_by_mut_value() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn by_mut(mut self: Self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_by_ref() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn by_ref(self: &Self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_by_box() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn by_box(self: Box<Self>);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_by_pin() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn by_pin(self: Pin<Self>);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_explicit_type() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn explicit_type(self: Pin<MyType>);
-    };
-    match sig.receiver() {
-        Some(FnArg::Typed(_)) => (),
-        value => panic!("expected FnArg::Typed, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_value_shorthand() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn value_shorthand(self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Receiver(Receiver {
-            reference: None,
-            mutability: None,
-            ..
-        })) => (),
-        value => panic!("expected FnArg::Receiver without ref/mut, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_mut_value_shorthand() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn mut_value_shorthand(mut self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Receiver(Receiver {
-            reference: None,
-            mutability: Some(_),
-            ..
-        })) => (),
-        value => panic!("expected FnArg::Receiver with mut, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_ref_shorthand() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn ref_shorthand(&self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Receiver(Receiver {
-            reference: Some(_),
-            mutability: None,
-            ..
-        })) => (),
-        value => panic!("expected FnArg::Receiver with ref, got {:?}", value),
-    }
-}
-
-#[test]
-fn test_ref_mut_shorthand() {
-    let TraitItemMethod { sig, .. } = parse_quote! {
-        fn ref_mut_shorthand(&mut self);
-    };
-    match sig.receiver() {
-        Some(FnArg::Receiver(Receiver {
-            reference: Some(_),
-            mutability: Some(_),
-            ..
-        })) => (),
-        value => panic!("expected FnArg::Receiver with ref+mut, got {:?}", value),
-    }
-}
diff --git a/vendor/syn/tests/test_round_trip.rs b/vendor/syn/tests/test_round_trip.rs
deleted file mode 100644
index 0be16eb4..00000000
--- a/vendor/syn/tests/test_round_trip.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-#![cfg(not(syn_disable_nightly_tests))]
-#![recursion_limit = "1024"]
-#![feature(rustc_private)]
-
-extern crate rustc_ast;
-extern crate rustc_errors;
-extern crate rustc_expand;
-extern crate rustc_parse as parse;
-extern crate rustc_session;
-extern crate rustc_span;
-
-use crate::common::eq::SpanlessEq;
-use quote::quote;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use rustc_ast::ast::{
-    AngleBracketedArg, AngleBracketedArgs, Crate, GenericArg, GenericParamKind, Generics,
-};
-use rustc_ast::mut_visit::{self, MutVisitor};
-use rustc_errors::PResult;
-use rustc_session::parse::ParseSess;
-use rustc_span::source_map::FilePathMapping;
-use rustc_span::FileName;
-use std::fs;
-use std::panic;
-use std::path::Path;
-use std::process;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::Instant;
-use walkdir::{DirEntry, WalkDir};
-
-#[macro_use]
-mod macros;
-
-#[allow(dead_code)]
-mod common;
-
-mod repo;
-
-#[test]
-fn test_round_trip() {
-    common::rayon_init();
-    repo::clone_rust();
-    let abort_after = common::abort_after();
-    if abort_after == 0 {
-        panic!("Skipping all round_trip tests");
-    }
-
-    let failed = AtomicUsize::new(0);
-
-    WalkDir::new("tests/rust")
-        .sort_by(|a, b| a.file_name().cmp(b.file_name()))
-        .into_iter()
-        .filter_entry(repo::base_dir_filter)
-        .collect::<Result<Vec<DirEntry>, walkdir::Error>>()
-        .unwrap()
-        .into_par_iter()
-        .for_each(|entry| {
-            let path = entry.path();
-            if !path.is_dir() {
-                test(path, &failed, abort_after);
-            }
-        });
-
-    let failed = failed.load(Ordering::SeqCst);
-    if failed > 0 {
-        panic!("{} failures", failed);
-    }
-}
-
-fn test(path: &Path, failed: &AtomicUsize, abort_after: usize) {
-    let content = fs::read_to_string(path).unwrap();
-
-    let start = Instant::now();
-    let (krate, elapsed) = match syn::parse_file(&content) {
-        Ok(krate) => (krate, start.elapsed()),
-        Err(msg) => {
-            errorf!("=== {}: syn failed to parse\n{:?}\n", path.display(), msg);
-            let prev_failed = failed.fetch_add(1, Ordering::SeqCst);
-            if prev_failed + 1 >= abort_after {
-                process::exit(1);
-            }
-            return;
-        }
-    };
-    let back = quote!(#krate).to_string();
-    let edition = repo::edition(path).parse().unwrap();
-
-    rustc_span::create_session_if_not_set_then(edition, |_| {
-        let equal = match panic::catch_unwind(|| {
-            let sess = ParseSess::new(FilePathMapping::empty());
-            let before = match librustc_parse(content, &sess) {
-                Ok(before) => before,
-                Err(mut diagnostic) => {
-                    diagnostic.cancel();
-                    if diagnostic
-                        .message()
-                        .starts_with("file not found for module")
-                    {
-                        errorf!("=== {}: ignore\n", path.display());
-                    } else {
-                        errorf!(
-                            "=== {}: ignore - librustc failed to parse original content: {}\n",
-                            path.display(),
-                            diagnostic.message(),
-                        );
-                    }
-                    return Err(true);
-                }
-            };
-            let after = match librustc_parse(back, &sess) {
-                Ok(after) => after,
-                Err(mut diagnostic) => {
-                    errorf!("=== {}: librustc failed to parse", path.display());
-                    diagnostic.emit();
-                    return Err(false);
-                }
-            };
-            Ok((before, after))
-        }) {
-            Err(_) => {
-                errorf!("=== {}: ignoring librustc panic\n", path.display());
-                true
-            }
-            Ok(Err(equal)) => equal,
-            Ok(Ok((mut before, mut after))) => {
-                normalize(&mut before);
-                normalize(&mut after);
-                if SpanlessEq::eq(&before, &after) {
-                    errorf!(
-                        "=== {}: pass in {}ms\n",
-                        path.display(),
-                        elapsed.as_secs() * 1000 + u64::from(elapsed.subsec_nanos()) / 1_000_000
-                    );
-                    true
-                } else {
-                    errorf!(
-                        "=== {}: FAIL\nbefore: {:#?}\nafter: {:#?}\n",
-                        path.display(),
-                        before,
-                        after,
-                    );
-                    false
-                }
-            }
-        };
-        if !equal {
-            let prev_failed = failed.fetch_add(1, Ordering::SeqCst);
-            if prev_failed + 1 >= abort_after {
-                process::exit(1);
-            }
-        }
-    });
-}
-
-fn librustc_parse(content: String, sess: &ParseSess) -> PResult<Crate> {
-    static COUNTER: AtomicUsize = AtomicUsize::new(0);
-    let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
-    let name = FileName::Custom(format!("test_round_trip{}", counter));
-    parse::parse_crate_from_source_str(name, content, sess)
-}
-
-fn normalize(krate: &mut Crate) {
-    struct NormalizeVisitor;
-
-    impl MutVisitor for NormalizeVisitor {
-        fn visit_angle_bracketed_parameter_data(&mut self, e: &mut AngleBracketedArgs) {
-            #[derive(Ord, PartialOrd, Eq, PartialEq)]
-            enum Group {
-                Lifetimes,
-                TypesAndConsts,
-                Constraints,
-            }
-            e.args.sort_by_key(|arg| match arg {
-                AngleBracketedArg::Arg(arg) => match arg {
-                    GenericArg::Lifetime(_) => Group::Lifetimes,
-                    GenericArg::Type(_) | GenericArg::Const(_) => Group::TypesAndConsts,
-                },
-                AngleBracketedArg::Constraint(_) => Group::Constraints,
-            });
-            mut_visit::noop_visit_angle_bracketed_parameter_data(e, self);
-        }
-
-        fn visit_generics(&mut self, e: &mut Generics) {
-            #[derive(Ord, PartialOrd, Eq, PartialEq)]
-            enum Group {
-                Lifetimes,
-                TypesAndConsts,
-            }
-            e.params.sort_by_key(|param| match param.kind {
-                GenericParamKind::Lifetime => Group::Lifetimes,
-                GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
-                    Group::TypesAndConsts
-                }
-            });
-            mut_visit::noop_visit_generics(e, self);
-        }
-    }
-
-    NormalizeVisitor.visit_crate(krate);
-}
diff --git a/vendor/syn/tests/test_shebang.rs b/vendor/syn/tests/test_shebang.rs
deleted file mode 100644
index dc26b9aa..00000000
--- a/vendor/syn/tests/test_shebang.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#[macro_use]
-mod macros;
-
-#[test]
-fn test_basic() {
-    let content = "#!/usr/bin/env rustx\nfn main() {}";
-    let file = syn::parse_file(content).unwrap();
-    snapshot!(file, @r###"
-    File {
-        shebang: Some("#!/usr/bin/env rustx"),
-        items: [
-            Item::Fn {
-                vis: Inherited,
-                sig: Signature {
-                    ident: "main",
-                    generics: Generics,
-                    output: Default,
-                },
-                block: Block,
-            },
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_comment() {
-    let content = "#!//am/i/a/comment\n[allow(dead_code)] fn main() {}";
-    let file = syn::parse_file(content).unwrap();
-    snapshot!(file, @r###"
-    File {
-        attrs: [
-            Attribute {
-                style: Inner,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "allow",
-                            arguments: None,
-                        },
-                    ],
-                },
-                tokens: TokenStream(`(dead_code)`),
-            },
-        ],
-        items: [
-            Item::Fn {
-                vis: Inherited,
-                sig: Signature {
-                    ident: "main",
-                    generics: Generics,
-                    output: Default,
-                },
-                block: Block,
-            },
-        ],
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/test_should_parse.rs b/vendor/syn/tests/test_should_parse.rs
deleted file mode 100644
index 180d8599..00000000
--- a/vendor/syn/tests/test_should_parse.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-macro_rules! should_parse {
-    ($name:ident, { $($in:tt)* }) => {
-        #[test]
-        fn $name() {
-            // Make sure we can parse the file!
-            syn::parse_file(stringify!($($in)*)).unwrap();
-        }
-    }
-}
-
-should_parse!(generic_associated_type, {
-    impl Foo {
-        type Item = &'a i32;
-        fn foo<'a>(&'a self) -> Self::Item<'a> {}
-    }
-});
-
-#[rustfmt::skip]
-should_parse!(const_generics_use, {
-    type X = Foo<5>;
-    type Y = Foo<"foo">;
-    type Z = Foo<X>;
-    type W = Foo<{ X + 10 }>;
-});
-
-should_parse!(trailing_plus_type, {
-    type A = Box<Foo>;
-    type A = Box<Foo + 'a>;
-    type A = Box<'a + Foo>;
-});
-
-should_parse!(generic_associated_type_where, {
-    trait Foo {
-        type Item;
-        fn foo<T>(&self, t: T) -> Self::Item<T>;
-    }
-});
-
-should_parse!(match_with_block_expr, {
-    fn main() {
-        match false {
-            _ => {}.a(),
-        }
-    }
-});
diff --git a/vendor/syn/tests/test_size.rs b/vendor/syn/tests/test_size.rs
deleted file mode 100644
index 01e84011..00000000
--- a/vendor/syn/tests/test_size.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![cfg(target_pointer_width = "64")]
-
-use std::mem;
-use syn::*;
-
-#[test]
-fn test_expr_size() {
-    assert_eq!(mem::size_of::<Expr>(), 280);
-}
-
-#[test]
-fn test_item_size() {
-    assert_eq!(mem::size_of::<Item>(), 344);
-}
-
-#[test]
-fn test_type_size() {
-    assert_eq!(mem::size_of::<Type>(), 304);
-}
-
-#[test]
-fn test_pat_size() {
-    assert_eq!(mem::size_of::<Pat>(), 144);
-}
-
-#[test]
-fn test_lit_size() {
-    assert_eq!(mem::size_of::<Lit>(), 40);
-}
diff --git a/vendor/syn/tests/test_stmt.rs b/vendor/syn/tests/test_stmt.rs
deleted file mode 100644
index 943d856e..00000000
--- a/vendor/syn/tests/test_stmt.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
-use std::iter::FromIterator;
-use syn::Stmt;
-
-#[test]
-fn test_raw_operator() {
-    let stmt = syn::parse_str::<Stmt>("let _ = &raw const x;").unwrap();
-
-    snapshot!(stmt, @r###"
-    Local(Local {
-        pat: Pat::Wild,
-        init: Some(Verbatim(`& raw const x`)),
-    })
-    "###);
-}
-
-#[test]
-fn test_raw_variable() {
-    let stmt = syn::parse_str::<Stmt>("let _ = &raw;").unwrap();
-
-    snapshot!(stmt, @r###"
-    Local(Local {
-        pat: Pat::Wild,
-        init: Some(Expr::Reference {
-            expr: Expr::Path {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "raw",
-                            arguments: None,
-                        },
-                    ],
-                },
-            },
-        }),
-    })
-    "###);
-}
-
-#[test]
-fn test_raw_invalid() {
-    assert!(syn::parse_str::<Stmt>("let _ = &raw x;").is_err());
-}
-
-#[test]
-fn test_none_group() {
-    // <Ø async fn f() {} Ø>
-    let tokens = TokenStream::from_iter(vec![TokenTree::Group(Group::new(
-        Delimiter::None,
-        TokenStream::from_iter(vec![
-            TokenTree::Ident(Ident::new("async", Span::call_site())),
-            TokenTree::Ident(Ident::new("fn", Span::call_site())),
-            TokenTree::Ident(Ident::new("f", Span::call_site())),
-            TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-            TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::new())),
-        ]),
-    ))]);
-
-    snapshot!(tokens as Stmt, @r###"
-    Item(Item::Fn {
-        vis: Inherited,
-        sig: Signature {
-            asyncness: Some,
-            ident: "f",
-            generics: Generics,
-            output: Default,
-        },
-        block: Block,
-    })
-    "###);
-}
diff --git a/vendor/syn/tests/test_token_trees.rs b/vendor/syn/tests/test_token_trees.rs
deleted file mode 100644
index 5b00448a..00000000
--- a/vendor/syn/tests/test_token_trees.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::Lit;
-
-#[test]
-fn test_struct() {
-    let input = "
-        #[derive(Debug, Clone)]
-        pub struct Item {
-            pub ident: Ident,
-            pub attrs: Vec<Attribute>,
-        }
-    ";
-
-    snapshot!(input as TokenStream, @r###"
-    TokenStream(
-        `# [derive (Debug , Clone)] pub struct Item { pub ident : Ident , pub attrs : Vec < Attribute >, }`,
-    )
-    "###);
-}
-
-#[test]
-fn test_literal_mangling() {
-    let code = "0_4";
-    let parsed: Lit = syn::parse_str(code).unwrap();
-    assert_eq!(code, quote!(#parsed).to_string());
-}
diff --git a/vendor/syn/tests/test_ty.rs b/vendor/syn/tests/test_ty.rs
deleted file mode 100644
index 907fb201..00000000
--- a/vendor/syn/tests/test_ty.rs
+++ /dev/null
@@ -1,287 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
-use quote::quote;
-use std::iter::FromIterator;
-use syn::Type;
-
-#[test]
-fn test_mut_self() {
-    syn::parse_str::<Type>("fn(mut self)").unwrap();
-    syn::parse_str::<Type>("fn(mut self: ())").unwrap();
-    syn::parse_str::<Type>("fn(mut self: ...)").unwrap_err();
-    syn::parse_str::<Type>("fn(mut self: mut self)").unwrap_err();
-    syn::parse_str::<Type>("fn(mut self::T)").unwrap_err();
-}
-
-#[test]
-fn test_macro_variable_type() {
-    // mimics the token stream corresponding to `$ty<T>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { ty })),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("T", Span::call_site())),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "ty",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "T",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-
-    // mimics the token stream corresponding to `$ty::<T>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { ty })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("T", Span::call_site())),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "ty",
-                    arguments: PathArguments::AngleBracketed {
-                        colon2_token: Some,
-                        args: [
-                            Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "T",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_group_angle_brackets() {
-    // mimics the token stream corresponding to `Option<$ty>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Ident(Ident::new("Option", Span::call_site())),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Group(Group::new(Delimiter::None, quote! { Vec<u8> })),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Option",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            Type(Type::Group {
-                                elem: Type::Path {
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "Vec",
-                                                arguments: PathArguments::AngleBracketed {
-                                                    args: [
-                                                        Type(Type::Path {
-                                                            path: Path {
-                                                                segments: [
-                                                                    PathSegment {
-                                                                        ident: "u8",
-                                                                        arguments: None,
-                                                                    },
-                                                                ],
-                                                            },
-                                                        }),
-                                                    ],
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_group_colons() {
-    // mimics the token stream corresponding to `$ty::Item`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { Vec<u8> })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("Item", Span::call_site())),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Vec",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "u8",
-                                            arguments: None,
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-                PathSegment {
-                    ident: "Item",
-                    arguments: None,
-                },
-            ],
-        },
-    }
-    "###);
-
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { [T] })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("Element", Span::call_site())),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        qself: Some(QSelf {
-            ty: Type::Slice {
-                elem: Type::Path {
-                    path: Path {
-                        segments: [
-                            PathSegment {
-                                ident: "T",
-                                arguments: None,
-                            },
-                        ],
-                    },
-                },
-            },
-            position: 0,
-        }),
-        path: Path {
-            leading_colon: Some,
-            segments: [
-                PathSegment {
-                    ident: "Element",
-                    arguments: None,
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_trait_object() {
-    let tokens = quote!(dyn for<'a> Trait<'a> + 'static);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        dyn_token: Some,
-        bounds: [
-            Trait(TraitBound {
-                modifier: None,
-                lifetimes: Some(BoundLifetimes {
-                    lifetimes: [
-                        LifetimeDef {
-                            lifetime: Lifetime {
-                                ident: "a",
-                            },
-                        },
-                    ],
-                }),
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                            arguments: PathArguments::AngleBracketed {
-                                args: [
-                                    Lifetime(Lifetime {
-                                        ident: "a",
-                                    }),
-                                ],
-                            },
-                        },
-                    ],
-                },
-            }),
-            Lifetime(Lifetime {
-                ident: "static",
-            }),
-        ],
-    }
-    "###);
-
-    let tokens = quote!(dyn 'a + Trait);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        dyn_token: Some,
-        bounds: [
-            Lifetime(Lifetime {
-                ident: "a",
-            }),
-            Trait(TraitBound {
-                modifier: None,
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                            arguments: None,
-                        },
-                    ],
-                },
-            }),
-        ],
-    }
-    "###);
-
-    // None of the following are valid Rust types.
-    syn::parse_str::<Type>("for<'a> dyn Trait<'a>").unwrap_err();
-    syn::parse_str::<Type>("dyn for<'a> 'a + Trait").unwrap_err();
-}
diff --git a/vendor/syn/tests/test_visibility.rs b/vendor/syn/tests/test_visibility.rs
deleted file mode 100644
index 7b2c00ba..00000000
--- a/vendor/syn/tests/test_visibility.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
-use std::iter::FromIterator;
-use syn::parse::{Parse, ParseStream};
-use syn::{DeriveInput, Result, Visibility};
-
-#[derive(Debug)]
-struct VisRest {
-    vis: Visibility,
-    rest: TokenStream,
-}
-
-impl Parse for VisRest {
-    fn parse(input: ParseStream) -> Result<Self> {
-        Ok(VisRest {
-            vis: input.parse()?,
-            rest: input.parse()?,
-        })
-    }
-}
-
-macro_rules! assert_vis_parse {
-    ($input:expr, Ok($p:pat)) => {
-        assert_vis_parse!($input, Ok($p) + "");
-    };
-
-    ($input:expr, Ok($p:pat) + $rest:expr) => {
-        let expected = $rest.parse::<TokenStream>().unwrap();
-        let parse: VisRest = syn::parse_str($input).unwrap();
-
-        match parse.vis {
-            $p => {}
-            _ => panic!("Expected {}, got {:?}", stringify!($p), parse.vis),
-        }
-
-        // NOTE: Round-trips through `to_string` to avoid potential whitespace
-        // diffs.
-        assert_eq!(parse.rest.to_string(), expected.to_string());
-    };
-
-    ($input:expr, Err) => {
-        syn::parse2::<VisRest>($input.parse().unwrap()).unwrap_err();
-    };
-}
-
-#[test]
-fn test_pub() {
-    assert_vis_parse!("pub", Ok(Visibility::Public(_)));
-}
-
-#[test]
-fn test_crate() {
-    assert_vis_parse!("crate", Ok(Visibility::Crate(_)));
-}
-
-#[test]
-fn test_inherited() {
-    assert_vis_parse!("", Ok(Visibility::Inherited));
-}
-
-#[test]
-fn test_in() {
-    assert_vis_parse!("pub(in foo::bar)", Ok(Visibility::Restricted(_)));
-}
-
-#[test]
-fn test_pub_crate() {
-    assert_vis_parse!("pub(crate)", Ok(Visibility::Restricted(_)));
-}
-
-#[test]
-fn test_pub_self() {
-    assert_vis_parse!("pub(self)", Ok(Visibility::Restricted(_)));
-}
-
-#[test]
-fn test_pub_super() {
-    assert_vis_parse!("pub(super)", Ok(Visibility::Restricted(_)));
-}
-
-#[test]
-fn test_missing_in() {
-    assert_vis_parse!("pub(foo::bar)", Ok(Visibility::Public(_)) + "(foo::bar)");
-}
-
-#[test]
-fn test_missing_in_path() {
-    assert_vis_parse!("pub(in)", Err);
-}
-
-#[test]
-fn test_crate_path() {
-    assert_vis_parse!(
-        "pub(crate::A, crate::B)",
-        Ok(Visibility::Public(_)) + "(crate::A, crate::B)"
-    );
-}
-
-#[test]
-fn test_junk_after_in() {
-    assert_vis_parse!("pub(in some::path @@garbage)", Err);
-}
-
-#[test]
-fn test_empty_group_vis() {
-    // mimics `struct S { $vis $field: () }` where $vis is empty
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Ident(Ident::new("struct", Span::call_site())),
-        TokenTree::Ident(Ident::new("S", Span::call_site())),
-        TokenTree::Group(Group::new(
-            Delimiter::Brace,
-            TokenStream::from_iter(vec![
-                TokenTree::Group(Group::new(Delimiter::None, TokenStream::new())),
-                TokenTree::Group(Group::new(
-                    Delimiter::None,
-                    TokenStream::from_iter(vec![TokenTree::Ident(Ident::new(
-                        "f",
-                        Span::call_site(),
-                    ))]),
-                )),
-                TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-                TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
-            ]),
-        )),
-    ]);
-
-    snapshot!(tokens as DeriveInput, @r###"
-    DeriveInput {
-        vis: Inherited,
-        ident: "S",
-        generics: Generics,
-        data: Data::Struct {
-            fields: Fields::Named {
-                named: [
-                    Field {
-                        vis: Inherited,
-                        ident: Some("f"),
-                        colon_token: Some,
-                        ty: Type::Tuple,
-                    },
-                ],
-            },
-        },
-    }
-    "###);
-}
diff --git a/vendor/syn/tests/zzz_stable.rs b/vendor/syn/tests/zzz_stable.rs
deleted file mode 100644
index a1a670d9..00000000
--- a/vendor/syn/tests/zzz_stable.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![cfg(syn_disable_nightly_tests)]
-
-use std::io::{self, Write};
-use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
-
-const MSG: &str = "\
-‖
-‖   WARNING:
-‖   This is not a nightly compiler so not all tests were able to
-‖   run. Syn includes tests that compare Syn's parser against the
-‖   compiler's parser, which requires access to unstable librustc
-‖   data structures and a nightly compiler.
-‖
-";
-
-#[test]
-fn notice() -> io::Result<()> {
-    let header = "WARNING";
-    let index_of_header = MSG.find(header).unwrap();
-    let before = &MSG[..index_of_header];
-    let after = &MSG[index_of_header + header.len()..];
-
-    let mut stderr = StandardStream::stderr(ColorChoice::Auto);
-    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
-    write!(&mut stderr, "{}", before)?;
-    stderr.set_color(ColorSpec::new().set_bold(true).set_fg(Some(Color::Yellow)))?;
-    write!(&mut stderr, "{}", header)?;
-    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
-    write!(&mut stderr, "{}", after)?;
-    stderr.reset()?;
-
-    Ok(())
-}
diff --git a/vendor/target-tuples-0.4.1/.cargo-checksum.json b/vendor/target-tuples-0.4.1/.cargo-checksum.json
deleted file mode 100644
index b04da552..00000000
--- a/vendor/target-tuples-0.4.1/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.lock":"abb567fa0d22512650ab3f661e39ffc0f011f7799a950bcdd181bc62e952fb50","Cargo.toml":"0c76ae376f11d7d3cf9fbde128fd592c6dff1f9d498b17474deaec7db2a47971","LICENSE-APACHE":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","LICENSE-MIT":"57613ec8df284b15e3817ea41d737621316d1e3c447522b6f9ba6b2b73481c92","Makefile.in":"d48b3239d5b52e87632bede7f14c4e409df244032ccf9e37612f832ae508513a","README.md":"5f72e3394c3ea2af717c4348a9b46993d09ad32521486a12e089d4d549847236","aclocal.m4":"a26093944b5ad2103cf81f8f3e919206fb397ea21e87fc1c9719ad70bf1d8c3c","config.guess":"19c12bb2ca19e68724c2854ed0512469518df19b0710cc2011a5ca540810979c","config.sub":"f7197ddfb309e86d5fbd7d3b440a5ababfbd4aac1e1f53b492e28e54db58b222","config.sub.1":"6d3def0a3d0485848263ab0ac507156e5358e33e12dbb12506629789268b8fd0","configure":"be3c5f0ba322d96c25fc1894c40043aafacb2f112b55d6a960b1bab6fc780bbc","configure.ac":"c1018510147f598754a880ae12577d2fb654e018cf41054b0164456444924436","install-sh":"3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2","m4/lcrust_prog_rustc.m4":"1edafd2cf2b9bd1d68d980476b44c19a948761d40550932598939a705c1668c1","run-tests.sh":"6301cdd717d770d946503076778ccd7fecb712acaadc6379372cf35740a5b5a9","src/config-sub.rs":"73311c6a3c354aa52364575ea8da7d50ce4e3beef9428a5075d091cf5f1014cc","src/lib.rs":"632a947e82aa2be4a70f9ae3a19a211c7715f4d8cf4a6b6e50b4cc6ca1b3eca4","src/pieces.rs":"7522196dcde678e258100856c4c4cbcc3027e2db6af0d09f62e3d5478a983d0e","tests/config-sub.data":"c2acf0a21a466b91ceb9d30f94bcd1d7eabf95d5cd9f83a1dcd7930b4cb9d1ac","tests/sub_tests.rs":"0c75901d86352c522c43b8e4545f5cd52a7c03f2760130c36c56ddbb3d6fd19e"},"package":"a50e80f6ada7860f52175c48679e22005d0d6df8a4ff87b66aeef976ea1481fe"}
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/Cargo.lock b/vendor/target-tuples-0.4.1/Cargo.lock
deleted file mode 100644
index 2260f560..00000000
--- a/vendor/target-tuples-0.4.1/Cargo.lock
+++ /dev/null
@@ -1,6 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "target-tuples"
-version = "0.4.1"
-
diff --git a/vendor/target-tuples-0.4.1/Cargo.toml b/vendor/target-tuples-0.4.1/Cargo.toml
deleted file mode 100644
index 22cb3951..00000000
--- a/vendor/target-tuples-0.4.1/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "target-tuples"
-version = "0.4.1"
-authors = ["Connor Horman <chorman64@gmail.com>"]
-description = "    A library to parse target tuples of the form <arch>-<vendor>-<system>, similar to those used by autoconf.\n"
-readme = "README.md"
-license = "Apache-2.0 AND MIT"
-repository = "https://github.com/chorman0773/rust-target-tuples"
-[package.metadata.install-targets.config-sub]
-installed-path = "config.sub"
-
-[package.metadata.install-targets.config-sub-man]
-installed-path = "<mandir>/man1/config.sub.1"
-target-file = "config.sub.1"
-type = "man"
-
-[[bin]]
-name = "config-sub"
-path = "src/config-sub.rs"
-
-[dependencies]
diff --git a/vendor/target-tuples-0.4.1/LICENSE-APACHE b/vendor/target-tuples-0.4.1/LICENSE-APACHE
deleted file mode 100644
index e69de29b..00000000
diff --git a/vendor/target-tuples-0.4.1/LICENSE-MIT b/vendor/target-tuples-0.4.1/LICENSE-MIT
deleted file mode 100644
index 6d6b881f..00000000
--- a/vendor/target-tuples-0.4.1/LICENSE-MIT
+++ /dev/null
@@ -1,6 +0,0 @@
-Copyright (C) 2020 Connor Horman
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/Makefile.in b/vendor/target-tuples-0.4.1/Makefile.in
deleted file mode 100644
index e6e7c092..00000000
--- a/vendor/target-tuples-0.4.1/Makefile.in
+++ /dev/null
@@ -1,133 +0,0 @@
-# Root Options
-
-
-
-srcdir = @srcdir@
-builddir = @builddir@
-abs_builddir = @abs_builddir@
-
-RUSTC = @RUSTC@
-RUSTFLAGS := @RUSTFLAGS@
-
-INSTALL := @INSTALL@
-
-RUSTC_IS_LCCC = @rustc_is_lccc@
-
-## Install directories
-
-prefix = @prefix@
-exec_prefix = @exec_prefix@
-bindir = @bindir@
-libdir = @libdir@
-includedir = @includedir@
-sbindir = @sbindir@
-libexecdir = @libexecdir@
-datarootdir = @datarootdir@
-datadir = @datadir@
-mandir = @mandir@
-docdir = @docdir@
-infodir = @infodir@
-localedir = @localedir@
-sysconfdir = @sysconfdir@
-localstatedir = @localstatedir@
-runstatedir = @runstatedir@
-sharedstatedir = @sharedstatedir@
-
-
-# Other Configuration
-
-features = 
-binaries = config-sub
-tests = tests/sub_tests.rs
-# Package specific Configuration
-
-EDITION = 2018
-
-version = 0.4.0
-
-OUTPUT = libtarget-tuples.rlib
-
-CRATE_NAME = target_tuples
-
-DEPENDENCIES = 
-
-# Autogenerated variables
-
-file_to_crate = $(subst -,_,$(1))
-
-binary_outputs = $(foreach bin,$(binaries),$(bin)@EXEEXT@)
-
-CFG = $(foreach feature,$(features),feature="$feature") 
-
-SUBDIRS =
-
-EXTERN_CRATES = $(foreach dep,$(DEPENDENCIES),--extern $(call file_to_crate,$(dep))=$(abs_bindir)/vendor/$(dep)/lib$(dep).rlib)
-
-export CARGO_PKG_VERSION=$(version)
-export CARGO_MANIFEST_DIR=@abs_srcdir@
-
-# Targets
-
-all: stamp
-
-.PHONY: all clean distclean install install-strip
-
-
-Makefile: config.status @srcdir@/Makefile.in
-	@builddir@/config.status Makefile
-
-
-config.status: @srcdir@/configure
-	@builddir@/config.status --recheck
-
-
-stamp: $(binaries) $(OUTPUT)
-	touch stamp
-
-$(OUTPUT): Makefile
-
-
-include $(OUTPUT).d
-
-$(OUTPUT).d: $(srcdir)/src/lib.rs
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-$(OUTPUT): $(srcdir)/src/lib.rs
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d --emit link=@abs_builddir@/$(OUTPUT) -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-include $(foreach bin,$(binary_outputs),$(bin).d)
-
-$(foreach out,$(binary_outputs),$(out).d): %@EXEEXT@.d: $(srcdir)/src/%.rs $(OUTPUT)
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@ -o$*@EXEEXT@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-$(binary_outputs): %@EXEEXT@: $(srcdir)/src/%.rs $(OUTPUT)
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-clean: 
-	rm -f $(OUTPUT) $(binary_outputs) test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=%@EXEEXT@) stamp
-
-distclean: clean
-	rm -f config.status config.log $(OUTPUT).d test-$(OUTPUT:%.rlib=%@EXEEXT@).d $(foreach out,$(binary_outputs),$(out).d) Makefile
-
-install: $(binary_outputs)
-	$(INSTALL) -m755 $(binary_outputs) ${bindir}/
-
-install-strip: $(binary_outputs)
-	$(INSTALL) -s -m755 $(binary_outputs) ${bindir}/
-
-include test-$(OUTPUT:%.rlib=%@EXEEXT@).d
-
-tests/:
-	mkdir tests/
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@).d: $(srcdir)/src/lib.rs
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d -otest-$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@): $(srcdir)/src/lib.rs
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d --emit link=@abs_builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) -o$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-$(tests:%.rs=%@EXEEXT@): %@EXEEXT@: $(srcdir)/%.rs $(OUTPUT) tests/
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$(*F)) --test --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-check: @builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=@builddir@/%@EXEEXT@)
-	$(srcdir)/run-tests.sh $(foreach file,$^,@builddir@/$(file))
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/README.md b/vendor/target-tuples-0.4.1/README.md
deleted file mode 100644
index 4a8bc3df..00000000
--- a/vendor/target-tuples-0.4.1/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# rust target-tuples
-
-Implements parsing of target tuples. Additionally provides a small program that implements config.sub. 
-
-## Copyright
-
-Copyright (C) 2020 Connor Horman
-
-This program is dual-licensed under the terms of the MIT and Apache v2 licenses. 
-See <LICENSE-MIT> and <LICENSE-APACHE> for details. 
-
-Persuant to the Apache v2 License, if you contribute to this software,
- you agree to allow the copyright holder to dual-license those contributions as above.
-
-
-## Building
-
-This library and it's associated programs can be built using cargo. 
-
-Additionally, it can be configured and built by running the configure script present in this repo with a Bourne-compatible shell. The standard options are available for the configure scripts. 
-
-## Semver Policy
-
-The MSRV for rust-target-tuples is rust 1.38. Increases to this value represents a semver major change.
-
-This library does not guarantee the output of any of it's string parsing methods, or the canonical name of any component. Changes to both parsing and canonicalization may happen in a minor release. Additional component values may also be added in a minor release. 
-
-
-
-
diff --git a/vendor/target-tuples-0.4.1/aclocal.m4 b/vendor/target-tuples-0.4.1/aclocal.m4
deleted file mode 100644
index 93288360..00000000
--- a/vendor/target-tuples-0.4.1/aclocal.m4
+++ /dev/null
@@ -1,15 +0,0 @@
-# generated automatically by aclocal 1.16.3 -*- Autoconf -*-
-
-# Copyright (C) 1996-2020 Free Software Foundation, Inc.
-
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
-m4_include([m4/lcrust_prog_rustc.m4])
diff --git a/vendor/target-tuples-0.4.1/config.guess b/vendor/target-tuples-0.4.1/config.guess
deleted file mode 100755
index f50dcdb6..00000000
--- a/vendor/target-tuples-0.4.1/config.guess
+++ /dev/null
@@ -1,1480 +0,0 @@
-#! /bin/sh
-# Attempt to guess a canonical system name.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-24'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-#
-# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
-#
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-#
-# Please send patches to <config-patches@gnu.org>.
-
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION]
-
-Output the configuration name of the system \`$me' is run on.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.guess ($timestamp)
-
-Originally written by Per Bothner.
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-    * )
-       break ;;
-  esac
-done
-
-if test $# != 0; then
-  echo "$me: too many arguments$help" >&2
-  exit 1
-fi
-
-trap 'exit 1' 1 2 15
-
-# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
-# compiler to aid in system detection is discouraged as it requires
-# temporary files to be created and, as you can see below, it is a
-# headache to deal with in a portable fashion.
-
-# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
-# use `HOST_CC' if defined, but it is deprecated.
-
-# Portable tmp directory creation inspired by the Autoconf team.
-
-set_cc_for_build='
-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
-: ${TMPDIR=/tmp} ;
- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
-dummy=$tmp/dummy ;
-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > "$dummy.c" ;
-	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-	     CC_FOR_BUILD="$c"; break ;
-	  fi ;
-	done ;
-	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found ;
-	fi
-	;;
- ,,*)   CC_FOR_BUILD=$CC ;;
- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac ; set_cc_for_build= ;'
-
-# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 1994-08-24)
-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
-	PATH=$PATH:/.attbin ; export PATH
-fi
-
-UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
-UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
-UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
-
-case "$UNAME_SYSTEM" in
-Linux|GNU|GNU/*)
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	LIBC=gnu
-
-	eval "$set_cc_for_build"
-	cat <<-EOF > "$dummy.c"
-	#include <features.h>
-	#if defined(__UCLIBC__)
-	LIBC=uclibc
-	#elif defined(__dietlibc__)
-	LIBC=dietlibc
-	#else
-	LIBC=gnu
-	#endif
-	EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
-
-	# If ldd exists, use it to detect musl libc.
-	if command -v ldd >/dev/null && \
-		ldd --version 2>&1 | grep -q ^musl
-	then
-	    LIBC=musl
-	fi
-	;;
-esac
-
-# Note: order is significant - the case branches are not exclusive.
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
-    *:NetBSD:*:*)
-	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
-	# switched to ELF, *-*-netbsd* would select the old
-	# object file format.  This provides both forward
-	# compatibility and a consistent mechanism for selecting the
-	# object file format.
-	#
-	# Note: NetBSD doesn't particularly care about the vendor
-	# portion of the name.  We always set it to "unknown".
-	sysctl="sysctl -n hw.machine_arch"
-	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    "/sbin/$sysctl" 2>/dev/null || \
-	    "/usr/sbin/$sysctl" 2>/dev/null || \
-	    echo unknown)`
-	case "$UNAME_MACHINE_ARCH" in
-	    armeb) machine=armeb-unknown ;;
-	    arm*) machine=arm-unknown ;;
-	    sh3el) machine=shl-unknown ;;
-	    sh3eb) machine=sh-unknown ;;
-	    sh5el) machine=sh5le-unknown ;;
-	    earmv*)
-		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
-		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
-		machine="${arch}${endian}"-unknown
-		;;
-	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
-	esac
-	# The Operating System including object format, if it has switched
-	# to ELF recently (or will in the future) and ABI.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		os=netbsdelf
-		;;
-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval "$set_cc_for_build"
-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep -q __ELF__
-		then
-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-		    # Return netbsd for either.  FIX?
-		    os=netbsd
-		else
-		    os=netbsdelf
-		fi
-		;;
-	    *)
-		os=netbsd
-		;;
-	esac
-	# Determine ABI tags.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
-		;;
-	esac
-	# The OS release
-	# Debian GNU/NetBSD machines have a different userland, and
-	# thus, need a distinct triplet. However, they do not need
-	# kernel version information, so it can be replaced with a
-	# suitable tag, in the style of linux-gnu.
-	case "$UNAME_VERSION" in
-	    Debian*)
-		release='-gnu'
-		;;
-	    *)
-		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
-		;;
-	esac
-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
-	# contains redundant information, the shorter form:
-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "$machine-${os}${release}${abi}"
-	exit ;;
-    *:Bitrig:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
-	exit ;;
-    *:OpenBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
-	exit ;;
-    *:LibertyBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
-	exit ;;
-    *:MidnightBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
-	exit ;;
-    *:ekkoBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
-	exit ;;
-    *:SolidBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
-	exit ;;
-    macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:MirBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:Sortix:*:*)
-	echo "$UNAME_MACHINE"-unknown-sortix
-	exit ;;
-    *:Redox:*:*)
-	echo "$UNAME_MACHINE"-unknown-redox
-	exit ;;
-    mips:OSF1:*.*)
-        echo mips-dec-osf1
-        exit ;;
-    alpha:OSF1:*:*)
-	case $UNAME_RELEASE in
-	*4.0)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
-		;;
-	*5.*)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
-		;;
-	esac
-	# According to Compaq, /usr/sbin/psrinfo has been available on
-	# OSF/1 and Tru64 systems produced since 1995.  I hope that
-	# covers most systems running today.  This code pipes the CPU
-	# types through head -n 1, so we only detect the type of CPU 0.
-	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case "$ALPHA_CPU_TYPE" in
-	    "EV4 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "EV4.5 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "LCA4 (21066/21068)")
-		UNAME_MACHINE=alpha ;;
-	    "EV5 (21164)")
-		UNAME_MACHINE=alphaev5 ;;
-	    "EV5.6 (21164A)")
-		UNAME_MACHINE=alphaev56 ;;
-	    "EV5.6 (21164PC)")
-		UNAME_MACHINE=alphapca56 ;;
-	    "EV5.7 (21164PC)")
-		UNAME_MACHINE=alphapca57 ;;
-	    "EV6 (21264)")
-		UNAME_MACHINE=alphaev6 ;;
-	    "EV6.7 (21264A)")
-		UNAME_MACHINE=alphaev67 ;;
-	    "EV6.8CB (21264C)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8AL (21264B)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8CX (21264D)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE=alphaev69 ;;
-	    "EV7 (21364)")
-		UNAME_MACHINE=alphaev7 ;;
-	    "EV7.9 (21364A)")
-		UNAME_MACHINE=alphaev79 ;;
-	esac
-	# A Pn.n version is a patched version.
-	# A Vn.n version is a released version.
-	# A Tn.n version is a released field test version.
-	# A Xn.n version is an unreleased experimental baselevel.
-	# 1.2 uses "1.2" for uname -r.
-	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
-    Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
-    *:[Aa]miga[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-amigaos
-	exit ;;
-    *:[Mm]orph[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-morphos
-	exit ;;
-    *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
-    *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
-    *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix"$UNAME_RELEASE"
-	exit ;;
-    arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "`(/bin/universe) 2>/dev/null`" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
-    NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
-    DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
-	case `/usr/bin/uname -p` in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
-    s390x:SunOS:*:*)
-	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux"$UNAME_RELEASE"
-	exit ;;
-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval "$set_cc_for_build"
-	SUN_ARCH=i386
-	# If there is a compiler, see if it is configured for 64-bit objects.
-	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
-	# This test works for both compilers.
-	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		SUN_ARCH=x86_64
-	    fi
-	fi
-	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:6*:*)
-	# According to config.sub, this is the proper way to canonicalize
-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
-	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:*:*)
-	case "`/usr/bin/arch -k`" in
-	    Series*|S4*)
-		UNAME_RELEASE=`uname -v`
-		;;
-	esac
-	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
-	exit ;;
-    sun3*:SunOS:*:*)
-	echo m68k-sun-sunos"$UNAME_RELEASE"
-	exit ;;
-    sun*:*:4.2BSD:*)
-	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case "`/bin/arch`" in
-	    sun3)
-		echo m68k-sun-sunos"$UNAME_RELEASE"
-		;;
-	    sun4)
-		echo sparc-sun-sunos"$UNAME_RELEASE"
-		;;
-	esac
-	exit ;;
-    aushp:SunOS:*:*)
-	echo sparc-auspex-sunos"$UNAME_RELEASE"
-	exit ;;
-    # The situation for MiNT is a little confusing.  The machine name
-    # can be virtually everything (everything which is not
-    # "atarist" or "atariste" at least should have a processor
-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
-    # to the lowercase version "mint" (or "freemint").  Finally
-    # the system name "TOS" denotes a system which is actually not
-    # MiNT.  But MiNT is downward compatible to TOS, so this should
-    # be no problem.
-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint"$UNAME_RELEASE"
-	exit ;;
-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint"$UNAME_RELEASE"
-	exit ;;
-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint"$UNAME_RELEASE"
-	exit ;;
-    m68k:machten:*:*)
-	echo m68k-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    powerpc:machten:*:*)
-	echo powerpc-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
-    RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix"$UNAME_RELEASE"
-	exit ;;
-    mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-	#if defined (host_mips) && defined (MIPSEB)
-	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
-	#endif
-	#endif
-	  exit (-1);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
-	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
-	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
-	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos"$UNAME_RELEASE"
-	exit ;;
-    Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
-    Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
-    m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
-    m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
-    m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
-    AViiON:dgux:*:*)
-	# DG/UX returns AViiON for all architectures
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ]
-	then
-	    if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \
-	       [ "$TARGET_BINARY_INTERFACE"x = x ]
-	    then
-		echo m88k-dg-dgux"$UNAME_RELEASE"
-	    else
-		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
-	    fi
-	else
-	    echo i586-dg-dgux"$UNAME_RELEASE"
-	fi
-	exit ;;
-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
-    M88*:*:R3*:*)
-	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
-    *:IRIX*:*:*)
-	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
-	exit ;;
-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
-    i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
-    ia64:AIX:*:*)
-	if [ -x /usr/bin/oslevel ] ; then
-		IBM_REV=`/usr/bin/oslevel`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:2:3)
-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval "$set_cc_for_build"
-		sed 's/^		//' << EOF > "$dummy.c"
-		#include <sys/systemcfg.h>
-
-		main()
-			{
-			if (!__power_pc())
-				exit(1);
-			puts("powerpc-ibm-aix3.2.5");
-			exit(0);
-			}
-EOF
-		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
-		then
-			echo "$SYSTEM_NAME"
-		else
-			echo rs6000-ibm-aix3.2.5
-		fi
-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
-	else
-		echo rs6000-ibm-aix3.2
-	fi
-	exit ;;
-    *:AIX:*:[4567])
-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
-		IBM_ARCH=rs6000
-	else
-		IBM_ARCH=powerpc
-	fi
-	if [ -x /usr/bin/lslpp ] ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
-			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
-    *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
-    DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
-    9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
-    9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	case "$UNAME_MACHINE" in
-	    9000/31?)            HP_ARCH=m68000 ;;
-	    9000/[34]??)         HP_ARCH=m68k ;;
-	    9000/[678][0-9][0-9])
-		if [ -x /usr/bin/getconf ]; then
-		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
-		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "$sc_cpu_version" in
-		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
-		      532)                      # CPU_PA_RISC2_0
-			case "$sc_kernel_bits" in
-			  32) HP_ARCH=hppa2.0n ;;
-			  64) HP_ARCH=hppa2.0w ;;
-			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
-			esac ;;
-		    esac
-		fi
-		if [ "$HP_ARCH" = "" ]; then
-		    eval "$set_cc_for_build"
-		    sed 's/^		//' << EOF > "$dummy.c"
-
-		#define _HPUX_SOURCE
-		#include <stdlib.h>
-		#include <unistd.h>
-
-		int main ()
-		{
-		#if defined(_SC_KERNEL_BITS)
-		    long bits = sysconf(_SC_KERNEL_BITS);
-		#endif
-		    long cpu  = sysconf (_SC_CPU_VERSION);
-
-		    switch (cpu)
-			{
-			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-			case CPU_PA_RISC2_0:
-		#if defined(_SC_KERNEL_BITS)
-			    switch (bits)
-				{
-				case 64: puts ("hppa2.0w"); break;
-				case 32: puts ("hppa2.0n"); break;
-				default: puts ("hppa2.0"); break;
-				} break;
-		#else  /* !defined(_SC_KERNEL_BITS) */
-			    puts ("hppa2.0"); break;
-		#endif
-			default: puts ("hppa1.0"); break;
-			}
-		    exit (0);
-		}
-EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
-		    test -z "$HP_ARCH" && HP_ARCH=hppa
-		fi ;;
-	esac
-	if [ "$HP_ARCH" = hppa2.0w ]
-	then
-	    eval "$set_cc_for_build"
-
-	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
-	    # generating 64-bit code.  GNU and HP use different nomenclature:
-	    #
-	    # $ CC_FOR_BUILD=cc ./config.guess
-	    # => hppa2.0w-hp-hpux11.23
-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
-	    # => hppa64-hp-hpux11.23
-
-	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep -q __LP64__
-	    then
-		HP_ARCH=hppa2.0w
-	    else
-		HP_ARCH=hppa64
-	    fi
-	fi
-	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
-	exit ;;
-    ia64:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	echo ia64-hp-hpux"$HPUX_REV"
-	exit ;;
-    3050*:HI-UX:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#include <unistd.h>
-	int
-	main ()
-	{
-	  long cpu = sysconf (_SC_CPU_VERSION);
-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
-	     results, however.  */
-	  if (CPU_IS_PA_RISC (cpu))
-	    {
-	      switch (cpu)
-		{
-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
-		  default: puts ("hppa-hitachi-hiuxwe2"); break;
-		}
-	    }
-	  else if (CPU_IS_HP_MC68K (cpu))
-	    puts ("m68k-hitachi-hiuxwe2");
-	  else puts ("unknown-hitachi-hiuxwe2");
-	  exit (0);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
-		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	echo hppa1.1-hp-bsd
-	exit ;;
-    9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	echo hppa1.1-hp-osf
-	exit ;;
-    hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
-    i*86:OSF1:*:*)
-	if [ -x /usr/sbin/sysversion ] ; then
-	    echo "$UNAME_MACHINE"-unknown-osf1mk
-	else
-	    echo "$UNAME_MACHINE"-unknown-osf1
-	fi
-	exit ;;
-    parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
-    CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*[A-Z]90:*:*:*)
-	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-	      -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*TS:*:*:*)
-	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
-	exit ;;
-    sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:BSD/OS:*:*)
-	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:FreeBSD:*:*)
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case "$UNAME_PROCESSOR" in
-	    amd64)
-		UNAME_PROCESSOR=x86_64 ;;
-	    i386)
-		UNAME_PROCESSOR=i586 ;;
-	esac
-	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    i*:CYGWIN*:*)
-	echo "$UNAME_MACHINE"-pc-cygwin
-	exit ;;
-    *:MINGW64*:*)
-	echo "$UNAME_MACHINE"-pc-mingw64
-	exit ;;
-    *:MINGW*:*)
-	echo "$UNAME_MACHINE"-pc-mingw32
-	exit ;;
-    *:MSYS*:*)
-	echo "$UNAME_MACHINE"-pc-msys
-	exit ;;
-    i*:PW*:*)
-	echo "$UNAME_MACHINE"-pc-pw32
-	exit ;;
-    *:Interix*:*)
-	case "$UNAME_MACHINE" in
-	    x86)
-		echo i586-pc-interix"$UNAME_RELEASE"
-		exit ;;
-	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	    IA64)
-		echo ia64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	esac ;;
-    i*:UWIN*:*)
-	echo "$UNAME_MACHINE"-pc-uwin
-	exit ;;
-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-unknown-cygwin
-	exit ;;
-    prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    *:GNU:*:*)
-	# the GNU system
-	echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
-	exit ;;
-    *:GNU/*:*:*)
-	# other systems with GNU libc and userland
-	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC"
-	exit ;;
-    i*86:Minix:*:*)
-	echo "$UNAME_MACHINE"-pc-minix
-	exit ;;
-    aarch64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    aarch64_be:Linux:*:*)
-	UNAME_MACHINE=aarch64_be
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
-	  EV5)   UNAME_MACHINE=alphaev5 ;;
-	  EV56)  UNAME_MACHINE=alphaev56 ;;
-	  PCA56) UNAME_MACHINE=alphapca56 ;;
-	  PCA57) UNAME_MACHINE=alphapca56 ;;
-	  EV6)   UNAME_MACHINE=alphaev6 ;;
-	  EV67)  UNAME_MACHINE=alphaev67 ;;
-	  EV68*) UNAME_MACHINE=alphaev68 ;;
-	esac
-	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arm*:Linux:*:*)
-	eval "$set_cc_for_build"
-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_EABI__
-	then
-	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	else
-	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep -q __ARM_PCS_VFP
-	    then
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
-	    else
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
-	    fi
-	fi
-	exit ;;
-    avr32*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    cris:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    crisv32:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    e2k:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    frv:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    hexagon:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:Linux:*:*)
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	exit ;;
-    ia64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    k1om:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m32r*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m68*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    mips:Linux:*:* | mips64:Linux:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#undef CPU
-	#undef ${UNAME_MACHINE}
-	#undef ${UNAME_MACHINE}el
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=${UNAME_MACHINE}el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=${UNAME_MACHINE}
-	#else
-	CPU=
-	#endif
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
-	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
-	;;
-    mips64el:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-"$LIBC"
-	exit ;;
-    or32:Linux:*:* | or1k*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    padre:Linux:*:*)
-	echo sparc-unknown-linux-"$LIBC"
-	exit ;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-"$LIBC"
-	exit ;;
-    parisc:Linux:*:* | hppa:Linux:*:*)
-	# Look for CPU level
-	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
-	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
-	  *)    echo hppa-unknown-linux-"$LIBC" ;;
-	esac
-	exit ;;
-    ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-"$LIBC"
-	exit ;;
-    ppc:Linux:*:*)
-	echo powerpc-unknown-linux-"$LIBC"
-	exit ;;
-    ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-"$LIBC"
-	exit ;;
-    ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-"$LIBC"
-	exit ;;
-    riscv32:Linux:*:* | riscv64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    s390:Linux:*:* | s390x:Linux:*:*)
-	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
-	exit ;;
-    sh64*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sh*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    tile*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    vax:Linux:*:*)
-	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
-	exit ;;
-    x86_64:Linux:*:*)
-	if objdump -f /bin/sh | grep -q elf32-x86-64; then
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
-	else
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	fi
-	exit ;;
-    xtensa*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:DYNIX/ptx:4*:*)
-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
-	# earlier versions are messed up and put the nodename in both
-	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
-    i*86:UNIX_SV:4.2MP:2.*)
-	# Unixware is an offshoot of SVR4, but it has its own version
-	# number series starting with 2...
-	# I am not positive that other SVR4 systems won't match this,
-	# I just have to hope.  -- rms.
-	# Use sysv4.2uw... so that sysv4* matches it.
-	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
-	exit ;;
-    i*86:OS/2:*:*)
-	# If we were able to find `uname', then EMX Unix compatibility
-	# is probably installed.
-	echo "$UNAME_MACHINE"-pc-os2-emx
-	exit ;;
-    i*86:XTS-300:*:STOP)
-	echo "$UNAME_MACHINE"-unknown-stop
-	exit ;;
-    i*86:atheos:*:*)
-	echo "$UNAME_MACHINE"-unknown-atheos
-	exit ;;
-    i*86:syllable:*:*)
-	echo "$UNAME_MACHINE"-pc-syllable
-	exit ;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    i*86:*DOS:*:*)
-	echo "$UNAME_MACHINE"-pc-msdosdjgpp
-	exit ;;
-    i*86:*:4.*:*)
-	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
-	fi
-	exit ;;
-    i*86:*:5:[678]*)
-	# UnixWare 7.x, OpenUNIX and OpenServer 6.
-	case `/bin/uname -X | grep "^Machine"` in
-	    *486*)	     UNAME_MACHINE=i486 ;;
-	    *Pentium)	     UNAME_MACHINE=i586 ;;
-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
-	esac
-	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
-	exit ;;
-    i*86:*:3.2:*)
-	if test -f /usr/options/cb.name; then
-		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
-	elif /bin/uname -X 2>/dev/null >/dev/null ; then
-		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
-			&& UNAME_MACHINE=i586
-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv32
-	fi
-	exit ;;
-    pc:*:*:*)
-	# Left here for compatibility:
-	# uname -m prints for DJGPP always 'pc', but it prints nothing about
-	# the processor, so we play safe by assuming i586.
-	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configure will decide that
-	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
-    Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
-    paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
-    i860:*:4.*:*) # i860-SVR4
-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
-	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
-	fi
-	exit ;;
-    mini*:CTIX:SYS*5:*)
-	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
-    mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
-    M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
-    M68*:*:R3V[5678]*:*)
-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
-	OS_REL=''
-	test -r /etc/.relid \
-	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4; exit; } ;;
-    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
-	OS_REL='.3'
-	test -r /etc/.relid \
-	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
-    TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv"$UNAME_RELEASE"
-	exit ;;
-    RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    *:SINIX-*:*:*)
-	if uname -p 2>/dev/null >/dev/null ; then
-		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo "$UNAME_MACHINE"-sni-sysv4
-	else
-		echo ns32k-sni-sysv
-	fi
-	exit ;;
-    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
-    *:UNIX_System_V:4*:FTX*)
-	# From Gerald Hewes <hewes@openmarket.com>.
-	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
-    *:*:*:FTX*)
-	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
-    i*86:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo "$UNAME_MACHINE"-stratus-vos
-	exit ;;
-    *:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
-    mc68*:A/UX:*:*)
-	echo m68k-apple-aux"$UNAME_RELEASE"
-	exit ;;
-    news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if [ -d /usr/nec ]; then
-		echo mips-nec-sysv"$UNAME_RELEASE"
-	else
-		echo mips-unknown-sysv"$UNAME_RELEASE"
-	fi
-	exit ;;
-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
-    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
-    x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
-    SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Rhapsody:*:*)
-	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval "$set_cc_for_build"
-	if test "$UNAME_PROCESSOR" = unknown ; then
-	    UNAME_PROCESSOR=powerpc
-	fi
-	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
-	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_64BIT_ARCH >/dev/null
-		then
-		    case $UNAME_PROCESSOR in
-			i386) UNAME_PROCESSOR=x86_64 ;;
-			powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		    esac
-		fi
-		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_PPC >/dev/null
-		then
-		    UNAME_PROCESSOR=powerpc
-		fi
-	    fi
-	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # Avoid executing cc on OS X 10.9, as it ships with a stub
-	    # that puts up a graphical alert prompting to install
-	    # developer tools.  Any system running Mac OS X 10.7 or
-	    # later (Darwin 11 and later) is required to have a 64-bit
-	    # processor. This is not true of the ARM version of Darwin
-	    # that Apple uses in portable devices.
-	    UNAME_PROCESSOR=x86_64
-	fi
-	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
-	exit ;;
-    *:procnto*:*:* | *:QNX:[0123456789]*:*)
-	UNAME_PROCESSOR=`uname -p`
-	if test "$UNAME_PROCESSOR" = x86; then
-		UNAME_PROCESSOR=i386
-		UNAME_MACHINE=pc
-	fi
-	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
-	exit ;;
-    *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
-    NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSV-*:NONSTOP_KERNEL:*:*)
-	echo nsv-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
-    BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
-    DS/*:UNIX_System_V:*:*)
-	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
-	exit ;;
-    *:Plan9:*:*)
-	# "uname -m" is not consistent, so use $cputype instead. 386
-	# is converted to i386 for consistency with other x86
-	# operating systems.
-	if test "$cputype" = 386; then
-	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
-	fi
-	echo "$UNAME_MACHINE"-unknown-plan9
-	exit ;;
-    *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
-    *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
-    *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
-    *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
-    SEI:*:*:SEIUX)
-	echo mips-sei-seiux"$UNAME_RELEASE"
-	exit ;;
-    *:DragonFly:*:*)
-	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    *:*VMS:*:*)
-	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "$UNAME_MACHINE" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
-	esac ;;
-    *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
-    i*86:skyos:*:*)
-	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
-	exit ;;
-    i*86:rdos:*:*)
-	echo "$UNAME_MACHINE"-pc-rdos
-	exit ;;
-    i*86:AROS:*:*)
-	echo "$UNAME_MACHINE"-pc-aros
-	exit ;;
-    x86_64:VMkernel:*:*)
-	echo "$UNAME_MACHINE"-unknown-esx
-	exit ;;
-    amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
-esac
-
-echo "$0: unable to guess system type" >&2
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM" in
-    mips:Linux | mips64:Linux)
-	# If we got here on MIPS GNU/Linux, output extra information.
-	cat >&2 <<EOF
-
-NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
-the system type. Please install a C compiler and try again.
-EOF
-	;;
-esac
-
-cat >&2 <<EOF
-
-This script (version $timestamp), has failed to recognize the
-operating system you are using. If your script is old, overwrite *all*
-copies of config.guess and config.sub with the latest versions from:
-
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-and
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-If $0 has already been updated, send the following data and any
-information you think might be pertinent to config-patches@gnu.org to
-provide the necessary information to handle your system.
-
-config.guess timestamp = $timestamp
-
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
-
-hostinfo               = `(hostinfo) 2>/dev/null`
-/bin/universe          = `(/bin/universe) 2>/dev/null`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
-/bin/arch              = `(/bin/arch) 2>/dev/null`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
-
-UNAME_MACHINE = "$UNAME_MACHINE"
-UNAME_RELEASE = "$UNAME_RELEASE"
-UNAME_SYSTEM  = "$UNAME_SYSTEM"
-UNAME_VERSION = "$UNAME_VERSION"
-EOF
-
-exit 1
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/target-tuples-0.4.1/config.sub b/vendor/target-tuples-0.4.1/config.sub
deleted file mode 100755
index 1d8e98bc..00000000
--- a/vendor/target-tuples-0.4.1/config.sub
+++ /dev/null
@@ -1,1801 +0,0 @@
-#! /bin/sh
-# Configuration validation subroutine script.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-22'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-
-
-# Please send patches to <config-patches@gnu.org>.
-#
-# Configuration subroutine to validate and canonicalize a configuration type.
-# Supply the specified configuration type as an argument.
-# If it is invalid, we print an error message on stderr and exit with code 1.
-# Otherwise, we print the canonical config type on stdout and succeed.
-
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-# This file is supposed to be the same for all GNU packages
-# and recognize all the CPU types, system types and aliases
-# that are meaningful with *any* GNU software.
-# Each package is responsible for reporting which valid configurations
-# it does not support.  The user should be able to distinguish
-# a failure to support a valid configuration from a meaningless
-# configuration.
-
-# The goal of this file is to map all the various variations of a given
-# machine specification into a single specification in the form:
-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or in some cases, the newer four-part form:
-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# It is wrong to echo any other type of specification.
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
-
-Canonicalize a configuration name.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.sub ($timestamp)
-
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help"
-       exit 1 ;;
-
-    *local*)
-       # First pass through any local machine types.
-       echo "$1"
-       exit ;;
-
-    * )
-       break ;;
-  esac
-done
-
-case $# in
- 0) echo "$me: missing argument$help" >&2
-    exit 1;;
- 1) ;;
- *) echo "$me: too many arguments$help" >&2
-    exit 1;;
-esac
-
-# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
-# Here we must recognize all the valid KERNEL-OS combinations.
-maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
-case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | cloudabi*-eabi* | \
-  storm-chaos* | os2-emx* | rtmk-nova*)
-    os=-$maybe_os
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
-    ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
-  *)
-    basic_machine=`echo "$1" | sed 's/-[^-]*$//'`
-    if [ "$basic_machine" != "$1" ]
-    then os=`echo "$1" | sed 's/.*-/-/'`
-    else os=; fi
-    ;;
-esac
-
-### Let's recognize common machines as not being operating systems so
-### that things like config.sub decstation-3100 work.  We also
-### recognize some manufacturers as not being operating systems, so we
-### can provide default operating systems below.
-case $os in
-	-sun*os*)
-		# Prevent following clause from handling this invalid input.
-		;;
-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
-		os=
-		basic_machine=$1
-		;;
-	-bluegene*)
-		os=-cnk
-		;;
-	-sim | -cisco | -oki | -wec | -winbond)
-		os=
-		basic_machine=$1
-		;;
-	-scout)
-		;;
-	-wrs)
-		os=-vxworks
-		basic_machine=$1
-		;;
-	-chorusos*)
-		os=-chorusos
-		basic_machine=$1
-		;;
-	-chorusrdb)
-		os=-chorusrdb
-		basic_machine=$1
-		;;
-	-hiux*)
-		os=-hiuxwe2
-		;;
-	-sco6)
-		os=-sco5v6
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5)
-		os=-sco3.2v5
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco4)
-		os=-sco3.2v4
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2.[4-9]*)
-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2v[4-9]*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco*)
-		os=-sco3.2v2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-udk*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-isc)
-		os=-isc2.2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-clix*)
-		basic_machine=clipper-intergraph
-		;;
-	-isc*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
-		;;
-	-lynx*)
-		os=-lynxos
-		;;
-	-ptx*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'`
-		;;
-	-psos*)
-		os=-psos
-		;;
-	-mint | -mint[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-esac
-
-# Decode aliases for certain CPU-COMPANY combinations.
-case $basic_machine in
-	# Recognize the basic CPU types without company name.
-	# Some are omitted here because they have special meanings below.
-	1750a | 580 \
-	| a29k \
-	| aarch64 | aarch64_be \
-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
-	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| ba \
-	| be32 | be64 \
-	| bfin \
-	| c4x | c8051 | clipper \
-	| d10v | d30v | dlx | dsp16xx \
-	| e2k | epiphany \
-	| fido | fr30 | frv | ft32 \
-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
-	| i370 | i860 | i960 | ia16 | ia64 \
-	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
-	| mips | mipsbe | mipseb | mipsel | mipsle \
-	| mips16 \
-	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
-	| mips64vr | mips64vrel \
-	| mips64vr4100 | mips64vr4100el \
-	| mips64vr4300 | mips64vr4300el \
-	| mips64vr5000 | mips64vr5000el \
-	| mips64vr5900 | mips64vr5900el \
-	| mipsisa32 | mipsisa32el \
-	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
-	| mipsisa64 | mipsisa64el \
-	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
-	| mipsisa64sb1 | mipsisa64sb1el \
-	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
-	| mipstx39 | mipstx39el \
-	| mn10200 | mn10300 \
-	| moxie \
-	| mt \
-	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
-	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
-	| pdp10 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
-	| pru \
-	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
-	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
-	| sh64 | sh64le \
-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
-	| wasm32 \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
-		basic_machine=$basic_machine-unknown
-		;;
-	c54x)
-		basic_machine=tic54x-unknown
-		;;
-	c55x)
-		basic_machine=tic55x-unknown
-		;;
-	c6x)
-		basic_machine=tic6x-unknown
-		;;
-	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
-		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65)
-		;;
-	ms1)
-		basic_machine=mt-unknown
-		;;
-
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
-		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
-		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
-		;;
-
-	# We use `pc' rather than `unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-	  basic_machine=$basic_machine-pc
-	  ;;
-	# Object if more than one company name word.
-	*-*-*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-	# Recognize the basic CPU types with company name.
-	580-* \
-	| a29k-* \
-	| aarch64-* | aarch64_be-* \
-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
-	| avr-* | avr32-* \
-	| ba-* \
-	| be32-* | be64-* \
-	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
-	| d10v-* | d30v-* | dlx-* \
-	| e2k-* | elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
-	| h8300-* | h8500-* \
-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
-	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
-	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
-	| m32c-* | m32r-* | m32rle-* \
-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
-	| mips16-* \
-	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
-	| mips64vr-* | mips64vrel-* \
-	| mips64vr4100-* | mips64vr4100el-* \
-	| mips64vr4300-* | mips64vr4300el-* \
-	| mips64vr5000-* | mips64vr5000el-* \
-	| mips64vr5900-* | mips64vr5900el-* \
-	| mipsisa32-* | mipsisa32el-* \
-	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
-	| mipsisa64-* | mipsisa64el-* \
-	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
-	| mipsisa64sb1-* | mipsisa64sb1el-* \
-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
-	| mipstx39-* | mipstx39el-* \
-	| mmix-* \
-	| mt-* \
-	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
-	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
-	| orion-* \
-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
-	| pru-* \
-	| pyramid-* \
-	| riscv32-* | riscv64-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
-	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
-	| tahoe-* \
-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
-	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
-	| wasm32-* \
-	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
-	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
-		;;
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	386bsd)
-		basic_machine=i386-pc
-		os=-bsd
-		;;
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		basic_machine=m68000-att
-		;;
-	3b*)
-		basic_machine=we32k-att
-		;;
-	a29khif)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	abacus)
-		basic_machine=abacus-unknown
-		;;
-	adobe68k)
-		basic_machine=m68010-adobe
-		os=-scout
-		;;
-	alliant | fx80)
-		basic_machine=fx80-alliant
-		;;
-	altos | altos3068)
-		basic_machine=m68k-altos
-		;;
-	am29k)
-		basic_machine=a29k-none
-		os=-bsd
-		;;
-	amd64)
-		basic_machine=x86_64-pc
-		;;
-	amd64-*)
-		basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	amdahl)
-		basic_machine=580-amdahl
-		os=-sysv
-		;;
-	amiga | amiga-*)
-		basic_machine=m68k-unknown
-		;;
-	amigaos | amigados)
-		basic_machine=m68k-unknown
-		os=-amigaos
-		;;
-	amigaunix | amix)
-		basic_machine=m68k-unknown
-		os=-sysv4
-		;;
-	apollo68)
-		basic_machine=m68k-apollo
-		os=-sysv
-		;;
-	apollo68bsd)
-		basic_machine=m68k-apollo
-		os=-bsd
-		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
-	asmjs)
-		basic_machine=asmjs-unknown
-		;;
-	aux)
-		basic_machine=m68k-apple
-		os=-aux
-		;;
-	balance)
-		basic_machine=ns32k-sequent
-		os=-dynix
-		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c90)
-		basic_machine=c90-cray
-		os=-unicos
-		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
-	convex-c1)
-		basic_machine=c1-convex
-		os=-bsd
-		;;
-	convex-c2)
-		basic_machine=c2-convex
-		os=-bsd
-		;;
-	convex-c32)
-		basic_machine=c32-convex
-		os=-bsd
-		;;
-	convex-c34)
-		basic_machine=c34-convex
-		os=-bsd
-		;;
-	convex-c38)
-		basic_machine=c38-convex
-		os=-bsd
-		;;
-	cray | j90)
-		basic_machine=j90-cray
-		os=-unicos
-		;;
-	craynv)
-		basic_machine=craynv-cray
-		os=-unicosmp
-		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
-		os=-elf
-		;;
-	crds | unos)
-		basic_machine=m68k-crds
-		;;
-	crisv32 | crisv32-* | etraxfs*)
-		basic_machine=crisv32-axis
-		;;
-	cris | cris-* | etrax*)
-		basic_machine=cris-axis
-		;;
-	crx)
-		basic_machine=crx-unknown
-		os=-elf
-		;;
-	da30 | da30-*)
-		basic_machine=m68k-da30
-		;;
-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
-		basic_machine=mips-dec
-		;;
-	decsystem10* | dec10*)
-		basic_machine=pdp10-dec
-		os=-tops10
-		;;
-	decsystem20* | dec20*)
-		basic_machine=pdp10-dec
-		os=-tops20
-		;;
-	delta | 3300 | motorola-3300 | motorola-delta \
-	      | 3300-motorola | delta-motorola)
-		basic_machine=m68k-motorola
-		;;
-	delta88)
-		basic_machine=m88k-motorola
-		os=-sysv3
-		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
-	djgpp)
-		basic_machine=i586-pc
-		os=-msdosdjgpp
-		;;
-	dpx20 | dpx20-*)
-		basic_machine=rs6000-bull
-		os=-bosx
-		;;
-	dpx2*)
-		basic_machine=m68k-bull
-		os=-sysv3
-		;;
-	e500v[12])
-		basic_machine=powerpc-unknown
-		os=$os"spe"
-		;;
-	e500v[12]-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=$os"spe"
-		;;
-	ebmon29k)
-		basic_machine=a29k-amd
-		os=-ebmon
-		;;
-	elxsi)
-		basic_machine=elxsi-elxsi
-		os=-bsd
-		;;
-	encore | umax | mmax)
-		basic_machine=ns32k-encore
-		;;
-	es1800 | OSE68k | ose68k | ose | OSE)
-		basic_machine=m68k-ericsson
-		os=-ose
-		;;
-	fx2800)
-		basic_machine=i860-alliant
-		;;
-	genix)
-		basic_machine=ns32k-ns
-		;;
-	gmicro)
-		basic_machine=tron-gmicro
-		os=-sysv
-		;;
-	go32)
-		basic_machine=i386-pc
-		os=-go32
-		;;
-	h3050r* | hiux*)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	h8300hms)
-		basic_machine=h8300-hitachi
-		os=-hms
-		;;
-	h8300xray)
-		basic_machine=h8300-hitachi
-		os=-xray
-		;;
-	h8500hms)
-		basic_machine=h8500-hitachi
-		os=-hms
-		;;
-	harris)
-		basic_machine=m88k-harris
-		os=-sysv3
-		;;
-	hp300-*)
-		basic_machine=m68k-hp
-		;;
-	hp300bsd)
-		basic_machine=m68k-hp
-		os=-bsd
-		;;
-	hp300hpux)
-		basic_machine=m68k-hp
-		os=-hpux
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		basic_machine=m68000-hp
-		;;
-	hp9k3[2-9][0-9])
-		basic_machine=m68k-hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hppaosf)
-		basic_machine=hppa1.1-hp
-		os=-osf
-		;;
-	hppro)
-		basic_machine=hppa1.1-hp
-		os=-proelf
-		;;
-	i370-ibm* | ibm*)
-		basic_machine=i370-ibm
-		;;
-	i*86v32)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv32
-		;;
-	i*86v4*)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv4
-		;;
-	i*86v)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv
-		;;
-	i*86sol2)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-solaris2
-		;;
-	i386mach)
-		basic_machine=i386-mach
-		os=-mach
-		;;
-	vsta)
-		basic_machine=i386-unknown
-		os=-vsta
-		;;
-	iris | iris4d)
-		basic_machine=mips-sgi
-		case $os in
-		    -irix*)
-			;;
-		    *)
-			os=-irix4
-			;;
-		esac
-		;;
-	isi68 | isi)
-		basic_machine=m68k-isi
-		os=-sysv
-		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	magnum | m3230)
-		basic_machine=mips-mips
-		os=-sysv
-		;;
-	merlin)
-		basic_machine=ns32k-utek
-		os=-sysv
-		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
-	mingw32)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
-	miniframe)
-		basic_machine=m68000-convergent
-		;;
-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-	mips3*-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`
-		;;
-	mips3*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown
-		;;
-	monitor)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	morphos)
-		basic_machine=powerpc-unknown
-		os=-morphos
-		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
-		;;
-	msdos)
-		basic_machine=i386-pc
-		os=-msdos
-		;;
-	ms1-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'`
-		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
-	mvs)
-		basic_machine=i370-ibm
-		os=-mvs
-		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
-	ncr3000)
-		basic_machine=i486-ncr
-		os=-sysv4
-		;;
-	netbsd386)
-		basic_machine=i386-unknown
-		os=-netbsd
-		;;
-	netwinder)
-		basic_machine=armv4l-rebel
-		os=-linux
-		;;
-	news | news700 | news800 | news900)
-		basic_machine=m68k-sony
-		os=-newsos
-		;;
-	news1000)
-		basic_machine=m68030-sony
-		os=-newsos
-		;;
-	news-3600 | risc-news)
-		basic_machine=mips-sony
-		os=-newsos
-		;;
-	necv70)
-		basic_machine=v70-nec
-		os=-sysv
-		;;
-	next | m*-next)
-		basic_machine=m68k-next
-		case $os in
-		    -nextstep* )
-			;;
-		    -ns2*)
-		      os=-nextstep2
-			;;
-		    *)
-		      os=-nextstep3
-			;;
-		esac
-		;;
-	nh3000)
-		basic_machine=m68k-harris
-		os=-cxux
-		;;
-	nh[45]000)
-		basic_machine=m88k-harris
-		os=-cxux
-		;;
-	nindy960)
-		basic_machine=i960-intel
-		os=-nindy
-		;;
-	mon960)
-		basic_machine=i960-intel
-		os=-mon960
-		;;
-	nonstopux)
-		basic_machine=mips-compaq
-		os=-nonstopux
-		;;
-	np1)
-		basic_machine=np1-gould
-		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
-	nsr-tandem)
-		basic_machine=nsr-tandem
-		;;
-	nsv-tandem)
-		basic_machine=nsv-tandem
-		;;
-	nsx-tandem)
-		basic_machine=nsx-tandem
-		;;
-	op50n-* | op60c-*)
-		basic_machine=hppa1.1-oki
-		os=-proelf
-		;;
-	openrisc | openrisc-*)
-		basic_machine=or32-unknown
-		;;
-	os400)
-		basic_machine=powerpc-ibm
-		os=-os400
-		;;
-	OSE68000 | ose68000)
-		basic_machine=m68000-ericsson
-		os=-ose
-		;;
-	os68k)
-		basic_machine=m68k-none
-		os=-os68k
-		;;
-	pa-hitachi)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	paragon)
-		basic_machine=i860-intel
-		os=-osf
-		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	pbd)
-		basic_machine=sparc-tti
-		;;
-	pbb)
-		basic_machine=m68k-tti
-		;;
-	pc532 | pc532-*)
-		basic_machine=ns32k-pc532
-		;;
-	pc98)
-		basic_machine=i386-pc
-		;;
-	pc98-*)
-		basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium | p5 | k5 | k6 | nexgen | viac3)
-		basic_machine=i586-pc
-		;;
-	pentiumpro | p6 | 6x86 | athlon | athlon_*)
-		basic_machine=i686-pc
-		;;
-	pentiumii | pentium2 | pentiumiii | pentium3)
-		basic_machine=i686-pc
-		;;
-	pentium4)
-		basic_machine=i786-pc
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium4-*)
-		basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pn)
-		basic_machine=pn-gould
-		;;
-	power)	basic_machine=power-ibm
-		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
-		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppcle | powerpclittle)
-		basic_machine=powerpcle-unknown
-		;;
-	ppcle-* | powerpclittle-*)
-		basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64)	basic_machine=powerpc64-unknown
-		;;
-	ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64le | powerpc64little)
-		basic_machine=powerpc64le-unknown
-		;;
-	ppc64le-* | powerpc64little-*)
-		basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ps2)
-		basic_machine=i386-ibm
-		;;
-	pw32)
-		basic_machine=i586-unknown
-		os=-pw32
-		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
-		;;
-	rdos32)
-		basic_machine=i386-pc
-		os=-rdos
-		;;
-	rom68k)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	rm[46]00)
-		basic_machine=mips-siemens
-		;;
-	rtpc | rtpc-*)
-		basic_machine=romp-ibm
-		;;
-	s390 | s390-*)
-		basic_machine=s390-ibm
-		;;
-	s390x | s390x-*)
-		basic_machine=s390x-ibm
-		;;
-	sa29200)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	sb1)
-		basic_machine=mipsisa64sb1-unknown
-		;;
-	sb1el)
-		basic_machine=mipsisa64sb1el-unknown
-		;;
-	sde)
-		basic_machine=mipsisa32-sde
-		os=-elf
-		;;
-	sei)
-		basic_machine=mips-sei
-		os=-seiux
-		;;
-	sequent)
-		basic_machine=i386-sequent
-		;;
-	sh5el)
-		basic_machine=sh5le-unknown
-		;;
-	simso-wrs)
-		basic_machine=sparclite-wrs
-		os=-vxworks
-		;;
-	sps7)
-		basic_machine=m68k-bull
-		os=-sysv2
-		;;
-	spur)
-		basic_machine=spur-unknown
-		;;
-	st2000)
-		basic_machine=m68k-tandem
-		;;
-	stratus)
-		basic_machine=i860-stratus
-		os=-sysv4
-		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	sun2)
-		basic_machine=m68000-sun
-		;;
-	sun2os3)
-		basic_machine=m68000-sun
-		os=-sunos3
-		;;
-	sun2os4)
-		basic_machine=m68000-sun
-		os=-sunos4
-		;;
-	sun3os3)
-		basic_machine=m68k-sun
-		os=-sunos3
-		;;
-	sun3os4)
-		basic_machine=m68k-sun
-		os=-sunos4
-		;;
-	sun4os3)
-		basic_machine=sparc-sun
-		os=-sunos3
-		;;
-	sun4os4)
-		basic_machine=sparc-sun
-		os=-sunos4
-		;;
-	sun4sol2)
-		basic_machine=sparc-sun
-		os=-solaris2
-		;;
-	sun3 | sun3-*)
-		basic_machine=m68k-sun
-		;;
-	sun4)
-		basic_machine=sparc-sun
-		;;
-	sun386 | sun386i | roadrunner)
-		basic_machine=i386-sun
-		;;
-	sv1)
-		basic_machine=sv1-cray
-		os=-unicos
-		;;
-	symmetry)
-		basic_machine=i386-sequent
-		os=-dynix
-		;;
-	t3e)
-		basic_machine=alphaev5-cray
-		os=-unicos
-		;;
-	t90)
-		basic_machine=t90-cray
-		os=-unicos
-		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
-		;;
-	tx39)
-		basic_machine=mipstx39-unknown
-		;;
-	tx39el)
-		basic_machine=mipstx39el-unknown
-		;;
-	toad1)
-		basic_machine=pdp10-xkl
-		os=-tops20
-		;;
-	tower | tower-32)
-		basic_machine=m68k-ncr
-		;;
-	tpf)
-		basic_machine=s390x-ibm
-		os=-tpf
-		;;
-	udi29k)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	ultra3)
-		basic_machine=a29k-nyu
-		os=-sym1
-		;;
-	v810 | necv810)
-		basic_machine=v810-nec
-		os=-none
-		;;
-	vaxv)
-		basic_machine=vax-dec
-		os=-sysv
-		;;
-	vms)
-		basic_machine=vax-dec
-		os=-vms
-		;;
-	vpp*|vx|vx-*)
-		basic_machine=f301-fujitsu
-		;;
-	vxworks960)
-		basic_machine=i960-wrs
-		os=-vxworks
-		;;
-	vxworks68)
-		basic_machine=m68k-wrs
-		os=-vxworks
-		;;
-	vxworks29k)
-		basic_machine=a29k-wrs
-		os=-vxworks
-		;;
-	w65*)
-		basic_machine=w65-wdc
-		os=-none
-		;;
-	w89k-*)
-		basic_machine=hppa1.1-winbond
-		os=-proelf
-		;;
-	x64)
-		basic_machine=x86_64-pc
-		;;
-	xbox)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	xps | xps100)
-		basic_machine=xps100-honeywell
-		;;
-	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'`
-		;;
-	ymp)
-		basic_machine=ymp-cray
-		os=-unicos
-		;;
-	none)
-		basic_machine=none-none
-		os=-none
-		;;
-
-# Here we handle the default manufacturer of certain CPU types.  It is in
-# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		basic_machine=hppa1.1-winbond
-		;;
-	op50n)
-		basic_machine=hppa1.1-oki
-		;;
-	op60c)
-		basic_machine=hppa1.1-oki
-		;;
-	romp)
-		basic_machine=romp-ibm
-		;;
-	mmix)
-		basic_machine=mmix-knuth
-		;;
-	rs6000)
-		basic_machine=rs6000-ibm
-		;;
-	vax)
-		basic_machine=vax-dec
-		;;
-	pdp11)
-		basic_machine=pdp11-dec
-		;;
-	we32k)
-		basic_machine=we32k-att
-		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
-		basic_machine=sh-unknown
-		;;
-	cydra)
-		basic_machine=cydra-cydrome
-		;;
-	orion)
-		basic_machine=orion-highlevel
-		;;
-	orion105)
-		basic_machine=clipper-highlevel
-		;;
-	mac | mpw | mac-mpw)
-		basic_machine=m68k-apple
-		;;
-	pmac | pmac-mpw)
-		basic_machine=powerpc-apple
-		;;
-	*-unknown)
-		# Make sure to match an already-canonicalized machine name.
-		;;
-	*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-
-# Here we canonicalize certain aliases for manufacturers.
-case $basic_machine in
-	*-digital*)
-		basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'`
-		;;
-	*-commodore*)
-		basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'`
-		;;
-	*)
-		;;
-esac
-
-# Decode manufacturer-specific aliases for certain operating systems.
-
-if [ x"$os" != x"" ]
-then
-case $os in
-	# First match some system type aliases that might get confused
-	# with valid system types.
-	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
-		;;
-	-solaris1 | -solaris1.*)
-		os=`echo $os | sed -e 's|solaris1|sunos4|'`
-		;;
-	-solaris)
-		os=-solaris2
-		;;
-	-unixware*)
-		os=-sysv4.2uw
-		;;
-	-gnu/linux*)
-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
-		;;
-	# es1800 is here to avoid being matched by es* (a different OS)
-	-es1800*)
-		os=-ose
-		;;
-	# Now accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST end in a * to match a version number.
-	# -sysv* is not here because it comes later, after sysvr4.
-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* | -cloudabi* | -sortix* \
-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
-	      | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \
-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
-	      | -morphos* | -superux* | -rtmk* | -windiss* \
-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \
-	      | -midnightbsd*)
-	# Remember, each alternative MUST END IN *, to match a version number.
-		;;
-	-qnx*)
-		case $basic_machine in
-		    x86-* | i*86-*)
-			;;
-		    *)
-			os=-nto$os
-			;;
-		esac
-		;;
-	-nto-qnx*)
-		;;
-	-nto*)
-		os=`echo $os | sed -e 's|nto|nto-qnx|'`
-		;;
-	-sim | -xray | -os68k* | -v88r* \
-	      | -windows* | -osx | -abug | -netware* | -os9* \
-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
-		;;
-	-mac*)
-		os=`echo "$os" | sed -e 's|mac|macos|'`
-		;;
-	-linux-dietlibc)
-		os=-linux-dietlibc
-		;;
-	-linux*)
-		os=`echo $os | sed -e 's|linux|linux-gnu|'`
-		;;
-	-sunos5*)
-		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
-		;;
-	-sunos6*)
-		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
-		;;
-	-opened*)
-		os=-openedition
-		;;
-	-os400*)
-		os=-os400
-		;;
-	-wince*)
-		os=-wince
-		;;
-	-utek*)
-		os=-bsd
-		;;
-	-dynix*)
-		os=-bsd
-		;;
-	-acis*)
-		os=-aos
-		;;
-	-atheos*)
-		os=-atheos
-		;;
-	-syllable*)
-		os=-syllable
-		;;
-	-386bsd)
-		os=-bsd
-		;;
-	-ctix* | -uts*)
-		os=-sysv
-		;;
-	-nova*)
-		os=-rtmk-nova
-		;;
-	-ns2)
-		os=-nextstep2
-		;;
-	-nsk*)
-		os=-nsk
-		;;
-	# Preserve the version number of sinix5.
-	-sinix5.*)
-		os=`echo $os | sed -e 's|sinix|sysv|'`
-		;;
-	-sinix*)
-		os=-sysv4
-		;;
-	-tpf*)
-		os=-tpf
-		;;
-	-triton*)
-		os=-sysv3
-		;;
-	-oss*)
-		os=-sysv3
-		;;
-	-svr4*)
-		os=-sysv4
-		;;
-	-svr3)
-		os=-sysv3
-		;;
-	-sysvr4)
-		os=-sysv4
-		;;
-	# This must come after -sysvr4.
-	-sysv*)
-		;;
-	-ose*)
-		os=-ose
-		;;
-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-		os=-mint
-		;;
-	-zvmoe)
-		os=-zvmoe
-		;;
-	-dicos*)
-		os=-dicos
-		;;
-	-pikeos*)
-		# Until real need of OS specific support for
-		# particular features comes up, bare metal
-		# configurations are quite functional.
-		case $basic_machine in
-		    arm*)
-			os=-eabi
-			;;
-		    *)
-			os=-elf
-			;;
-		esac
-		;;
-	-nacl*)
-		;;
-	-ios)
-		;;
-	-none)
-		;;
-	*)
-		# Get rid of the `-' at the beginning of $os.
-		os=`echo $os | sed 's/[^-]*-//'`
-		echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-else
-
-# Here we handle the default operating systems that come with various machines.
-# The value should be what the vendor currently ships out the door with their
-# machine or put another way, the most popular os provided with the machine.
-
-# Note that if you're going to try to match "-MANUFACTURER" here (say,
-# "-sun"), then you have to tell the case statement up towards the top
-# that MANUFACTURER isn't an operating system.  Otherwise, code above
-# will signal an error saying that MANUFACTURER isn't an operating
-# system, and we'll never get to this point.
-
-case $basic_machine in
-	score-*)
-		os=-elf
-		;;
-	spu-*)
-		os=-elf
-		;;
-	*-acorn)
-		os=-riscix1.2
-		;;
-	arm*-rebel)
-		os=-linux
-		;;
-	arm*-semi)
-		os=-aout
-		;;
-	c4x-* | tic4x-*)
-		os=-coff
-		;;
-	c8051-*)
-		os=-elf
-		;;
-	hexagon-*)
-		os=-elf
-		;;
-	tic54x-*)
-		os=-coff
-		;;
-	tic55x-*)
-		os=-coff
-		;;
-	tic6x-*)
-		os=-coff
-		;;
-	# This must come before the *-dec entry.
-	pdp10-*)
-		os=-tops20
-		;;
-	pdp11-*)
-		os=-none
-		;;
-	*-dec | vax-*)
-		os=-ultrix4.2
-		;;
-	m68*-apollo)
-		os=-domain
-		;;
-	i386-sun)
-		os=-sunos4.0.2
-		;;
-	m68000-sun)
-		os=-sunos3
-		;;
-	m68*-cisco)
-		os=-aout
-		;;
-	mep-*)
-		os=-elf
-		;;
-	mips*-cisco)
-		os=-elf
-		;;
-	mips*-*)
-		os=-elf
-		;;
-	or32-*)
-		os=-coff
-		;;
-	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=-sysv3
-		;;
-	sparc-* | *-sun)
-		os=-sunos4.1.1
-		;;
-	pru-*)
-		os=-elf
-		;;
-	*-be)
-		os=-beos
-		;;
-	*-ibm)
-		os=-aix
-		;;
-	*-knuth)
-		os=-mmixware
-		;;
-	*-wec)
-		os=-proelf
-		;;
-	*-winbond)
-		os=-proelf
-		;;
-	*-oki)
-		os=-proelf
-		;;
-	*-hp)
-		os=-hpux
-		;;
-	*-hitachi)
-		os=-hiux
-		;;
-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=-sysv
-		;;
-	*-cbm)
-		os=-amigaos
-		;;
-	*-dg)
-		os=-dgux
-		;;
-	*-dolphin)
-		os=-sysv3
-		;;
-	m68k-ccur)
-		os=-rtu
-		;;
-	m88k-omron*)
-		os=-luna
-		;;
-	*-next)
-		os=-nextstep
-		;;
-	*-sequent)
-		os=-ptx
-		;;
-	*-crds)
-		os=-unos
-		;;
-	*-ns)
-		os=-genix
-		;;
-	i370-*)
-		os=-mvs
-		;;
-	*-gould)
-		os=-sysv
-		;;
-	*-highlevel)
-		os=-bsd
-		;;
-	*-encore)
-		os=-bsd
-		;;
-	*-sgi)
-		os=-irix
-		;;
-	*-siemens)
-		os=-sysv4
-		;;
-	*-masscomp)
-		os=-rtu
-		;;
-	f30[01]-fujitsu | f700-fujitsu)
-		os=-uxpv
-		;;
-	*-rom68k)
-		os=-coff
-		;;
-	*-*bug)
-		os=-coff
-		;;
-	*-apple)
-		os=-macos
-		;;
-	*-atari*)
-		os=-mint
-		;;
-	*)
-		os=-none
-		;;
-esac
-fi
-
-# Here we handle the case where we know the os, and the CPU type, but not the
-# manufacturer.  We pick the logical manufacturer.
-vendor=unknown
-case $basic_machine in
-	*-unknown)
-		case $os in
-			-riscix*)
-				vendor=acorn
-				;;
-			-sunos*)
-				vendor=sun
-				;;
-			-cnk*|-aix*)
-				vendor=ibm
-				;;
-			-beos*)
-				vendor=be
-				;;
-			-hpux*)
-				vendor=hp
-				;;
-			-mpeix*)
-				vendor=hp
-				;;
-			-hiux*)
-				vendor=hitachi
-				;;
-			-unos*)
-				vendor=crds
-				;;
-			-dgux*)
-				vendor=dg
-				;;
-			-luna*)
-				vendor=omron
-				;;
-			-genix*)
-				vendor=ns
-				;;
-			-mvs* | -opened*)
-				vendor=ibm
-				;;
-			-os400*)
-				vendor=ibm
-				;;
-			-ptx*)
-				vendor=sequent
-				;;
-			-tpf*)
-				vendor=ibm
-				;;
-			-vxsim* | -vxworks* | -windiss*)
-				vendor=wrs
-				;;
-			-aux*)
-				vendor=apple
-				;;
-			-hms*)
-				vendor=hitachi
-				;;
-			-mpw* | -macos*)
-				vendor=apple
-				;;
-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-				vendor=atari
-				;;
-			-vos*)
-				vendor=stratus
-				;;
-		esac
-		basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"`
-		;;
-esac
-
-echo "$basic_machine$os"
-exit
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/target-tuples-0.4.1/config.sub.1 b/vendor/target-tuples-0.4.1/config.sub.1
deleted file mode 100644
index c99f1e79..00000000
--- a/vendor/target-tuples-0.4.1/config.sub.1
+++ /dev/null
@@ -1,17 +0,0 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.16.
-.TH CONFIG.SUB "1" "December 2020" "Connor Horman" "User Commands"
-.SH NAME
-config.sub \- Canonicalizes a target tuple
-.SH SYNOPSIS
-.B config.sub
-[\fI\,OPTION\/\fR]\fI\,|<target>\/\fR
-.SH DESCRIPTION
-Converts a target tuple into canonical form
-Options:
-.HP
-\fB\-\-help\fR: Prints this message, and exits
-.HP
-\fB\-\-version\fR: Prints version information, and exists
-.SH COPYRIGHT
-Copyright \(co 2020 Connor Horman, this program is a free software, dual\-licensed under the terms of the Apache v2 and the MIT license
-This program is provided AS\-IS, without any warranty.
diff --git a/vendor/target-tuples-0.4.1/configure b/vendor/target-tuples-0.4.1/configure
deleted file mode 100755
index 1ec628df..00000000
--- a/vendor/target-tuples-0.4.1/configure
+++ /dev/null
@@ -1,4128 +0,0 @@
-#! /bin/sh
-# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69.
-#
-#
-# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
-#
-#
-# This configure script is free software; the Free Software Foundation
-# gives unlimited permission to copy, distribute and modify it.
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-# Use a proper internal environment variable to ensure we don't fall
-  # into an infinite loop, continuously re-executing ourselves.
-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
-    _as_can_reexec=no; export _as_can_reexec;
-    # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-as_fn_exit 255
-  fi
-  # We don't want this to propagate to other subprocesses.
-          { _as_can_reexec=; unset _as_can_reexec;}
-if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-"
-  as_required="as_fn_return () { (exit \$1); }
-as_fn_success () { as_fn_return 0; }
-as_fn_failure () { as_fn_return 1; }
-as_fn_ret_success () { return 0; }
-as_fn_ret_failure () { return 1; }
-
-exitcode=0
-as_fn_success || { exitcode=1; echo as_fn_success failed.; }
-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
-
-else
-  exitcode=1; echo positional parameters were not saved.
-fi
-test x\$exitcode = x0 || exit 1
-test -x / || exit 1"
-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
-  if (eval "$as_required") 2>/dev/null; then :
-  as_have_required=yes
-else
-  as_have_required=no
-fi
-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
-
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  as_found=:
-  case $as_dir in #(
-	 /*)
-	   for as_base in sh bash ksh sh5; do
-	     # Try only shells that exist, to save several forks.
-	     as_shell=$as_dir/$as_base
-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  CONFIG_SHELL=$as_shell as_have_required=yes
-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  break 2
-fi
-fi
-	   done;;
-       esac
-  as_found=false
-done
-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
-  CONFIG_SHELL=$SHELL as_have_required=yes
-fi; }
-IFS=$as_save_IFS
-
-
-      if test "x$CONFIG_SHELL" != x; then :
-  export CONFIG_SHELL
-             # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-fi
-
-    if test x$as_have_required = xno; then :
-  $as_echo "$0: This script requires a shell more modern than all"
-  $as_echo "$0: the shells that I found on your system."
-  if test x${ZSH_VERSION+set} = xset ; then
-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
-  else
-    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
-$0: including any error possibly output before this
-$0: message. Then install a modern shell, or manually run
-$0: the script under such a shell if you do have one."
-  fi
-  exit 1
-fi
-fi
-fi
-SHELL=${CONFIG_SHELL-/bin/sh}
-export SHELL
-# Unset more variables known to interfere with behavior of common tools.
-CLICOLOR_FORCE= GREP_OPTIONS=
-unset CLICOLOR_FORCE GREP_OPTIONS
-
-## --------------------- ##
-## M4sh Shell Functions. ##
-## --------------------- ##
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-  as_lineno_1=$LINENO as_lineno_1a=$LINENO
-  as_lineno_2=$LINENO as_lineno_2a=$LINENO
-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
-  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
-  sed -n '
-    p
-    /[$]LINENO/=
-  ' <$as_myself |
-    sed '
-      s/[$]LINENO.*/&-/
-      t lineno
-      b
-      :lineno
-      N
-      :loop
-      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
-      t loop
-      s/-\n.*//
-    ' >$as_me.lineno &&
-  chmod +x "$as_me.lineno" ||
-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-
-  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-  # already done that, so ensure we don't try to do so again and fall
-  # in an infinite loop.  This has already happened in practice.
-  _as_can_reexec=no; export _as_can_reexec
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensitive to this).
-  . "./$as_me.lineno"
-  # Exit status is that of the last command.
-  exit
-}
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-test -n "$DJDIR" || exec 7<&0 </dev/null
-exec 6>&1
-
-# Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
-# so uname gets run too.
-ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
-
-#
-# Initializations.
-#
-ac_default_prefix=/usr/local
-ac_clean_files=
-ac_config_libobj_dir=.
-LIBOBJS=
-cross_compiling=no
-subdirs=
-MFLAGS=
-MAKEFLAGS=
-
-# Identity of this package.
-PACKAGE_NAME=
-PACKAGE_TARNAME=
-PACKAGE_VERSION=
-PACKAGE_STRING=
-PACKAGE_BUGREPORT=
-PACKAGE_URL=
-
-ac_subst_vars='LTLIBOBJS
-LIBOBJS
-detected_cfg
-RUSTFLAGS
-RUSTC
-INSTALL_DATA
-INSTALL_SCRIPT
-INSTALL_PROGRAM
-OBJEXT
-EXEEXT
-ac_ct_CC
-CPPFLAGS
-LDFLAGS
-CFLAGS
-CC
-host_os
-host_vendor
-host_cpu
-host
-build_os
-build_vendor
-build_cpu
-build
-target_alias
-host_alias
-build_alias
-LIBS
-ECHO_T
-ECHO_N
-ECHO_C
-DEFS
-mandir
-localedir
-libdir
-psdir
-pdfdir
-dvidir
-htmldir
-infodir
-docdir
-oldincludedir
-includedir
-runstatedir
-localstatedir
-sharedstatedir
-sysconfdir
-datadir
-datarootdir
-libexecdir
-sbindir
-bindir
-program_transform_name
-prefix
-exec_prefix
-PACKAGE_URL
-PACKAGE_BUGREPORT
-PACKAGE_STRING
-PACKAGE_VERSION
-PACKAGE_TARNAME
-PACKAGE_NAME
-PATH_SEPARATOR
-SHELL'
-ac_subst_files=''
-ac_user_opts='
-enable_option_checking
-'
-      ac_precious_vars='build_alias
-host_alias
-target_alias
-CC
-CFLAGS
-LDFLAGS
-LIBS
-CPPFLAGS
-RUSTC
-RUSTFLAGS'
-
-
-# Initialize some variables set by options.
-ac_init_help=
-ac_init_version=false
-ac_unrecognized_opts=
-ac_unrecognized_sep=
-# The variables have the same names as the options, with
-# dashes changed to underlines.
-cache_file=/dev/null
-exec_prefix=NONE
-no_create=
-no_recursion=
-prefix=NONE
-program_prefix=NONE
-program_suffix=NONE
-program_transform_name=s,x,x,
-silent=
-site=
-srcdir=
-verbose=
-x_includes=NONE
-x_libraries=NONE
-
-# Installation directory options.
-# These are left unexpanded so users can "make install exec_prefix=/foo"
-# and all the variables that are supposed to be based on exec_prefix
-# by default will actually change.
-# Use braces instead of parens because sh, perl, etc. also accept them.
-# (The list follows the same order as the GNU Coding Standards.)
-bindir='${exec_prefix}/bin'
-sbindir='${exec_prefix}/sbin'
-libexecdir='${exec_prefix}/libexec'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}'
-sysconfdir='${prefix}/etc'
-sharedstatedir='${prefix}/com'
-localstatedir='${prefix}/var'
-runstatedir='${localstatedir}/run'
-includedir='${prefix}/include'
-oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE}'
-infodir='${datarootdir}/info'
-htmldir='${docdir}'
-dvidir='${docdir}'
-pdfdir='${docdir}'
-psdir='${docdir}'
-libdir='${exec_prefix}/lib'
-localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
-ac_prev=
-ac_dashdash=
-for ac_option
-do
-  # If the previous option needs an argument, assign it.
-  if test -n "$ac_prev"; then
-    eval $ac_prev=\$ac_option
-    ac_prev=
-    continue
-  fi
-
-  case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
-  esac
-
-  # Accept the important Cygnus configure options, so we can diagnose typos.
-
-  case $ac_dashdash$ac_option in
-  --)
-    ac_dashdash=yes ;;
-
-  -bindir | --bindir | --bindi | --bind | --bin | --bi)
-    ac_prev=bindir ;;
-  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
-    bindir=$ac_optarg ;;
-
-  -build | --build | --buil | --bui | --bu)
-    ac_prev=build_alias ;;
-  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
-    build_alias=$ac_optarg ;;
-
-  -cache-file | --cache-file | --cache-fil | --cache-fi \
-  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
-    ac_prev=cache_file ;;
-  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
-  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
-    cache_file=$ac_optarg ;;
-
-  --config-cache | -C)
-    cache_file=config.cache ;;
-
-  -datadir | --datadir | --datadi | --datad)
-    ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=*)
-    datadir=$ac_optarg ;;
-
-  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
-  | --dataroo | --dataro | --datar)
-    ac_prev=datarootdir ;;
-  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
-  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
-    datarootdir=$ac_optarg ;;
-
-  -disable-* | --disable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=no ;;
-
-  -docdir | --docdir | --docdi | --doc | --do)
-    ac_prev=docdir ;;
-  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
-    docdir=$ac_optarg ;;
-
-  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
-    ac_prev=dvidir ;;
-  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
-    dvidir=$ac_optarg ;;
-
-  -enable-* | --enable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=\$ac_optarg ;;
-
-  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
-  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
-  | --exec | --exe | --ex)
-    ac_prev=exec_prefix ;;
-  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
-  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
-  | --exec=* | --exe=* | --ex=*)
-    exec_prefix=$ac_optarg ;;
-
-  -gas | --gas | --ga | --g)
-    # Obsolete; use --with-gas.
-    with_gas=yes ;;
-
-  -help | --help | --hel | --he | -h)
-    ac_init_help=long ;;
-  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
-    ac_init_help=recursive ;;
-  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
-    ac_init_help=short ;;
-
-  -host | --host | --hos | --ho)
-    ac_prev=host_alias ;;
-  -host=* | --host=* | --hos=* | --ho=*)
-    host_alias=$ac_optarg ;;
-
-  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
-    ac_prev=htmldir ;;
-  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
-  | --ht=*)
-    htmldir=$ac_optarg ;;
-
-  -includedir | --includedir | --includedi | --included | --include \
-  | --includ | --inclu | --incl | --inc)
-    ac_prev=includedir ;;
-  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
-  | --includ=* | --inclu=* | --incl=* | --inc=*)
-    includedir=$ac_optarg ;;
-
-  -infodir | --infodir | --infodi | --infod | --info | --inf)
-    ac_prev=infodir ;;
-  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
-    infodir=$ac_optarg ;;
-
-  -libdir | --libdir | --libdi | --libd)
-    ac_prev=libdir ;;
-  -libdir=* | --libdir=* | --libdi=* | --libd=*)
-    libdir=$ac_optarg ;;
-
-  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
-  | --libexe | --libex | --libe)
-    ac_prev=libexecdir ;;
-  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
-  | --libexe=* | --libex=* | --libe=*)
-    libexecdir=$ac_optarg ;;
-
-  -localedir | --localedir | --localedi | --localed | --locale)
-    ac_prev=localedir ;;
-  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
-    localedir=$ac_optarg ;;
-
-  -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst | --locals)
-    ac_prev=localstatedir ;;
-  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
-    localstatedir=$ac_optarg ;;
-
-  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
-    ac_prev=mandir ;;
-  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
-    mandir=$ac_optarg ;;
-
-  -nfp | --nfp | --nf)
-    # Obsolete; use --without-fp.
-    with_fp=no ;;
-
-  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c | -n)
-    no_create=yes ;;
-
-  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
-    no_recursion=yes ;;
-
-  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
-  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
-  | --oldin | --oldi | --old | --ol | --o)
-    ac_prev=oldincludedir ;;
-  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
-  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
-  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
-    oldincludedir=$ac_optarg ;;
-
-  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
-    ac_prev=prefix ;;
-  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
-    prefix=$ac_optarg ;;
-
-  -program-prefix | --program-prefix | --program-prefi | --program-pref \
-  | --program-pre | --program-pr | --program-p)
-    ac_prev=program_prefix ;;
-  -program-prefix=* | --program-prefix=* | --program-prefi=* \
-  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
-    program_prefix=$ac_optarg ;;
-
-  -program-suffix | --program-suffix | --program-suffi | --program-suff \
-  | --program-suf | --program-su | --program-s)
-    ac_prev=program_suffix ;;
-  -program-suffix=* | --program-suffix=* | --program-suffi=* \
-  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
-    program_suffix=$ac_optarg ;;
-
-  -program-transform-name | --program-transform-name \
-  | --program-transform-nam | --program-transform-na \
-  | --program-transform-n | --program-transform- \
-  | --program-transform | --program-transfor \
-  | --program-transfo | --program-transf \
-  | --program-trans | --program-tran \
-  | --progr-tra | --program-tr | --program-t)
-    ac_prev=program_transform_name ;;
-  -program-transform-name=* | --program-transform-name=* \
-  | --program-transform-nam=* | --program-transform-na=* \
-  | --program-transform-n=* | --program-transform-=* \
-  | --program-transform=* | --program-transfor=* \
-  | --program-transfo=* | --program-transf=* \
-  | --program-trans=* | --program-tran=* \
-  | --progr-tra=* | --program-tr=* | --program-t=*)
-    program_transform_name=$ac_optarg ;;
-
-  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
-    ac_prev=pdfdir ;;
-  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
-    pdfdir=$ac_optarg ;;
-
-  -psdir | --psdir | --psdi | --psd | --ps)
-    ac_prev=psdir ;;
-  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
-    psdir=$ac_optarg ;;
-
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil)
-    silent=yes ;;
-
-  -runstatedir | --runstatedir | --runstatedi | --runstated \
-  | --runstate | --runstat | --runsta | --runst | --runs \
-  | --run | --ru | --r)
-    ac_prev=runstatedir ;;
-  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-  | --run=* | --ru=* | --r=*)
-    runstatedir=$ac_optarg ;;
-
-  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-    ac_prev=sbindir ;;
-  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-  | --sbi=* | --sb=*)
-    sbindir=$ac_optarg ;;
-
-  -sharedstatedir | --sharedstatedir | --sharedstatedi \
-  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
-  | --sharedst | --shareds | --shared | --share | --shar \
-  | --sha | --sh)
-    ac_prev=sharedstatedir ;;
-  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
-  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
-  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
-  | --sha=* | --sh=*)
-    sharedstatedir=$ac_optarg ;;
-
-  -site | --site | --sit)
-    ac_prev=site ;;
-  -site=* | --site=* | --sit=*)
-    site=$ac_optarg ;;
-
-  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
-    ac_prev=srcdir ;;
-  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
-    srcdir=$ac_optarg ;;
-
-  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
-  | --syscon | --sysco | --sysc | --sys | --sy)
-    ac_prev=sysconfdir ;;
-  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
-  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
-    sysconfdir=$ac_optarg ;;
-
-  -target | --target | --targe | --targ | --tar | --ta | --t)
-    ac_prev=target_alias ;;
-  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
-    target_alias=$ac_optarg ;;
-
-  -v | -verbose | --verbose | --verbos | --verbo | --verb)
-    verbose=yes ;;
-
-  -version | --version | --versio | --versi | --vers | -V)
-    ac_init_version=: ;;
-
-  -with-* | --with-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=\$ac_optarg ;;
-
-  -without-* | --without-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=no ;;
-
-  --x)
-    # Obsolete; use --with-x.
-    with_x=yes ;;
-
-  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
-  | --x-incl | --x-inc | --x-in | --x-i)
-    ac_prev=x_includes ;;
-  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
-  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
-    x_includes=$ac_optarg ;;
-
-  -x-libraries | --x-libraries | --x-librarie | --x-librari \
-  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
-    ac_prev=x_libraries ;;
-  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
-  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-    x_libraries=$ac_optarg ;;
-
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
-    ;;
-
-  *=*)
-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
-    # Reject names that are not valid shell variable names.
-    case $ac_envvar in #(
-      '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-    esac
-    eval $ac_envvar=\$ac_optarg
-    export $ac_envvar ;;
-
-  *)
-    # FIXME: should be removed in autoconf 3.0.
-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-    ;;
-
-  esac
-done
-
-if test -n "$ac_prev"; then
-  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
-fi
-
-if test -n "$ac_unrecognized_opts"; then
-  case $enable_option_checking in
-    no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-  esac
-fi
-
-# Check all directory arguments for consistency.
-for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
-		datadir sysconfdir sharedstatedir localstatedir includedir \
-		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir runstatedir
-do
-  eval ac_val=\$$ac_var
-  # Remove trailing slashes.
-  case $ac_val in
-    */ )
-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
-      eval $ac_var=\$ac_val;;
-  esac
-  # Be sure to have absolute directory names.
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* )  continue;;
-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
-  esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
-done
-
-# There might be people who depend on the old broken behavior: `$host'
-# used to hold the argument of --host etc.
-# FIXME: To remove some day.
-build=$build_alias
-host=$host_alias
-target=$target_alias
-
-# FIXME: To remove some day.
-if test "x$host_alias" != x; then
-  if test "x$build_alias" = x; then
-    cross_compiling=maybe
-  elif test "x$build_alias" != "x$host_alias"; then
-    cross_compiling=yes
-  fi
-fi
-
-ac_tool_prefix=
-test -n "$host_alias" && ac_tool_prefix=$host_alias-
-
-test "$silent" = yes && exec 6>/dev/null
-
-
-ac_pwd=`pwd` && test -n "$ac_pwd" &&
-ac_ls_di=`ls -di .` &&
-ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
-
-
-# Find the source files, if location was not specified.
-if test -z "$srcdir"; then
-  ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then the parent directory.
-  ac_confdir=`$as_dirname -- "$as_myself" ||
-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_myself" : 'X\(//\)[^/]' \| \
-	 X"$as_myself" : 'X\(//\)$' \| \
-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_myself" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  srcdir=$ac_confdir
-  if test ! -r "$srcdir/$ac_unique_file"; then
-    srcdir=..
-  fi
-else
-  ac_srcdir_defaulted=no
-fi
-if test ! -r "$srcdir/$ac_unique_file"; then
-  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
-fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-ac_abs_confdir=`(
-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
-	pwd)`
-# When building in place, set srcdir=.
-if test "$ac_abs_confdir" = "$ac_pwd"; then
-  srcdir=.
-fi
-# Remove unnecessary trailing slashes from srcdir.
-# Double slashes in file names in object file debugging info
-# mess up M-x gdb in Emacs.
-case $srcdir in
-*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
-esac
-for ac_var in $ac_precious_vars; do
-  eval ac_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_env_${ac_var}_value=\$${ac_var}
-  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_cv_env_${ac_var}_value=\$${ac_var}
-done
-
-#
-# Report the --help message.
-#
-if test "$ac_init_help" = "long"; then
-  # Omit some internal or obsolete options to make the list less imposing.
-  # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<_ACEOF
-\`configure' configures this package to adapt to many kinds of systems.
-
-Usage: $0 [OPTION]... [VAR=VALUE]...
-
-To assign environment variables (e.g., CC, CFLAGS...), specify them as
-VAR=VALUE.  See below for descriptions of some of the useful variables.
-
-Defaults for the options are specified in brackets.
-
-Configuration:
-  -h, --help              display this help and exit
-      --help=short        display options specific to this package
-      --help=recursive    display the short help of all the included packages
-  -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
-      --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
-  -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-
-Installation directories:
-  --prefix=PREFIX         install architecture-independent files in PREFIX
-                          [$ac_default_prefix]
-  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                          [PREFIX]
-
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
-
-For better control, use the options below.
-
-Fine tuning of the installation directories:
-  --bindir=DIR            user executables [EPREFIX/bin]
-  --sbindir=DIR           system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR        program executables [EPREFIX/libexec]
-  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-  --libdir=DIR            object code libraries [EPREFIX/lib]
-  --includedir=DIR        C header files [PREFIX/include]
-  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
-  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
-  --infodir=DIR           info documentation [DATAROOTDIR/info]
-  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
-  --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
-  --htmldir=DIR           html documentation [DOCDIR]
-  --dvidir=DIR            dvi documentation [DOCDIR]
-  --pdfdir=DIR            pdf documentation [DOCDIR]
-  --psdir=DIR             ps documentation [DOCDIR]
-_ACEOF
-
-  cat <<\_ACEOF
-
-System types:
-  --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
-_ACEOF
-fi
-
-if test -n "$ac_init_help"; then
-
-  cat <<\_ACEOF
-
-Some influential environment variables:
-  CC          C compiler command
-  CFLAGS      C compiler flags
-  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
-              nonstandard directory <lib dir>
-  LIBS        libraries to pass to the linker, e.g. -l<library>
-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
-              you have headers in a nonstandard directory <include dir>
-  RUSTC       Rust compiler to use
-  RUSTFLAGS   Flags to pass to the rust compiler
-
-Use these variables to override the choices made by `configure' or to help
-it to find libraries and programs with nonstandard names/locations.
-
-Report bugs to the package provider.
-_ACEOF
-ac_status=$?
-fi
-
-if test "$ac_init_help" = "recursive"; then
-  # If there are subdirs, report their specific --help.
-  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d "$ac_dir" ||
-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
-      continue
-    ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-    cd "$ac_dir" || { ac_status=$?; continue; }
-    # Check for guested configure.
-    if test -f "$ac_srcdir/configure.gnu"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-    elif test -f "$ac_srcdir/configure"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure" --help=recursive
-    else
-      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi || ac_status=$?
-    cd "$ac_pwd" || { ac_status=$?; break; }
-  done
-fi
-
-test -n "$ac_init_help" && exit $ac_status
-if $ac_init_version; then
-  cat <<\_ACEOF
-configure
-generated by GNU Autoconf 2.69
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This configure script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it.
-_ACEOF
-  exit
-fi
-
-## ------------------------ ##
-## Autoconf initialization. ##
-## ------------------------ ##
-
-# ac_fn_c_try_compile LINENO
-# --------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_compile
-cat >config.log <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  $ $0 $@
-
-_ACEOF
-exec 5>>config.log
-{
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
-
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
-
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
-
-_ASUNAME
-
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    $as_echo "PATH: $as_dir"
-  done
-IFS=$as_save_IFS
-
-} >&5
-
-cat >&5 <<_ACEOF
-
-
-## ----------- ##
-## Core tests. ##
-## ----------- ##
-
-_ACEOF
-
-
-# Keep a trace of the command line.
-# Strip out --no-create and --no-recursion so they do not pile up.
-# Strip out --silent because we don't want to record it for future runs.
-# Also quote any args containing shell meta-characters.
-# Make two passes to allow for proper duplicate-argument suppression.
-ac_configure_args=
-ac_configure_args0=
-ac_configure_args1=
-ac_must_keep_next=false
-for ac_pass in 1 2
-do
-  for ac_arg
-  do
-    case $ac_arg in
-    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-    | -silent | --silent | --silen | --sile | --sil)
-      continue ;;
-    *\'*)
-      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    case $ac_pass in
-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-    2)
-      as_fn_append ac_configure_args1 " '$ac_arg'"
-      if test $ac_must_keep_next = true; then
-	ac_must_keep_next=false # Got value, back to normal.
-      else
-	case $ac_arg in
-	  *=* | --config-cache | -C | -disable-* | --disable-* \
-	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
-	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
-	  | -with-* | --with-* | -without-* | --without-* | --x)
-	    case "$ac_configure_args0 " in
-	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
-	    esac
-	    ;;
-	  -* ) ac_must_keep_next=true ;;
-	esac
-      fi
-      as_fn_append ac_configure_args " '$ac_arg'"
-      ;;
-    esac
-  done
-done
-{ ac_configure_args0=; unset ac_configure_args0;}
-{ ac_configure_args1=; unset ac_configure_args1;}
-
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log.  We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
-  # Save into config.log some information that might help in debugging.
-  {
-    echo
-
-    $as_echo "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
-    echo
-    # The following way of writing the cache mishandles newlines in values,
-(
-  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-  (set) 2>&1 |
-    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      sed -n \
-	"s/'\''/'\''\\\\'\'''\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
-      ;; #(
-    *)
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-)
-    echo
-
-    $as_echo "## ----------------- ##
-## Output variables. ##
-## ----------------- ##"
-    echo
-    for ac_var in $ac_subst_vars
-    do
-      eval ac_val=\$$ac_var
-      case $ac_val in
-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-      esac
-      $as_echo "$ac_var='\''$ac_val'\''"
-    done | sort
-    echo
-
-    if test -n "$ac_subst_files"; then
-      $as_echo "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
-      echo
-      for ac_var in $ac_subst_files
-      do
-	eval ac_val=\$$ac_var
-	case $ac_val in
-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-	esac
-	$as_echo "$ac_var='\''$ac_val'\''"
-      done | sort
-      echo
-    fi
-
-    if test -s confdefs.h; then
-      $as_echo "## ----------- ##
-## confdefs.h. ##
-## ----------- ##"
-      echo
-      cat confdefs.h
-      echo
-    fi
-    test "$ac_signal" != 0 &&
-      $as_echo "$as_me: caught signal $ac_signal"
-    $as_echo "$as_me: exit $exit_status"
-  } >&5
-  rm -f core *.core core.conftest.* &&
-    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-    exit $exit_status
-' 0
-for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
-done
-ac_signal=0
-
-# confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -f -r conftest* confdefs.h
-
-$as_echo "/* confdefs.h */" > confdefs.h
-
-# Predefined preprocessor variables.
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_NAME "$PACKAGE_NAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_VERSION "$PACKAGE_VERSION"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_STRING "$PACKAGE_STRING"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_URL "$PACKAGE_URL"
-_ACEOF
-
-
-# Let the site file select an alternate cache file if it wants to.
-# Prefer an explicitly selected file to automatically selected ones.
-ac_site_file1=NONE
-ac_site_file2=NONE
-if test -n "$CONFIG_SITE"; then
-  # We do not want a PATH search for config.site.
-  case $CONFIG_SITE in #((
-    -*)  ac_site_file1=./$CONFIG_SITE;;
-    */*) ac_site_file1=$CONFIG_SITE;;
-    *)   ac_site_file1=./$CONFIG_SITE;;
-  esac
-elif test "x$prefix" != xNONE; then
-  ac_site_file1=$prefix/share/config.site
-  ac_site_file2=$prefix/etc/config.site
-else
-  ac_site_file1=$ac_default_prefix/share/config.site
-  ac_site_file2=$ac_default_prefix/etc/config.site
-fi
-for ac_site_file in "$ac_site_file1" "$ac_site_file2"
-do
-  test "x$ac_site_file" = xNONE && continue
-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-$as_echo "$as_me: loading site script $ac_site_file" >&6;}
-    sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-done
-
-if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special files
-  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-$as_echo "$as_me: loading cache $cache_file" >&6;}
-    case $cache_file in
-      [\\/]* | ?:[\\/]* ) . "$cache_file";;
-      *)                      . "./$cache_file";;
-    esac
-  fi
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-$as_echo "$as_me: creating cache $cache_file" >&6;}
-  >$cache_file
-fi
-
-# Check that the precious variables saved in the cache have kept the same
-# value.
-ac_cache_corrupted=false
-for ac_var in $ac_precious_vars; do
-  eval ac_old_set=\$ac_cv_env_${ac_var}_set
-  eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val=\$ac_cv_env_${ac_var}_value
-  eval ac_new_val=\$ac_env_${ac_var}_value
-  case $ac_old_set,$ac_new_set in
-    set,)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,set)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,);;
-    *)
-      if test "x$ac_old_val" != "x$ac_new_val"; then
-	# differences in whitespace do not lead to failure.
-	ac_old_val_w=`echo x $ac_old_val`
-	ac_new_val_w=`echo x $ac_new_val`
-	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	  ac_cache_corrupted=:
-	else
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-	  eval $ac_var=\$ac_old_val
-	fi
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-      fi;;
-  esac
-  # Pass precious variables to config.status.
-  if test "$ac_new_set" = set; then
-    case $ac_new_val in
-    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-    *) ac_arg=$ac_var=$ac_new_val ;;
-    esac
-    case " $ac_configure_args " in
-      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
-    esac
-  fi
-done
-if $ac_cache_corrupted; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
-fi
-## -------------------- ##
-## Main body of script. ##
-## -------------------- ##
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-
-ac_aux_dir=
-for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
-  if test -f "$ac_dir/install-sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install-sh -c"
-    break
-  elif test -f "$ac_dir/install.sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install.sh -c"
-    break
-  elif test -f "$ac_dir/shtool"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/shtool install -c"
-    break
-  fi
-done
-if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
-fi
-
-# These three variables are undocumented and unsupported,
-# and are intended to be withdrawn in a future Autoconf release.
-# They can cause serious problems if a builder's source tree is in a directory
-# whose full name contains unusual characters.
-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
-
-
-# Make sure we can run config.sub.
-$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
-  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
-$as_echo_n "checking build system type... " >&6; }
-if ${ac_cv_build+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_build_alias=$build_alias
-test "x$ac_build_alias" = x &&
-  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
-test "x$ac_build_alias" = x &&
-  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
-ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
-  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-$as_echo "$ac_cv_build" >&6; }
-case $ac_cv_build in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
-esac
-build=$ac_cv_build
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_build
-shift
-build_cpu=$1
-build_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-build_os=$*
-IFS=$ac_save_IFS
-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
-$as_echo_n "checking host system type... " >&6; }
-if ${ac_cv_host+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test "x$host_alias" = x; then
-  ac_cv_host=$ac_cv_build
-else
-  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-$as_echo "$ac_cv_host" >&6; }
-case $ac_cv_host in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
-esac
-host=$ac_cv_host
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_host
-shift
-host_cpu=$1
-host_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-host_os=$*
-IFS=$ac_save_IFS
-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
-
-
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-
-
-test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
-# Try to create an executable without -o first, disregard a.out.
-# It will help us diagnose broken compilers, and finding out an intuition
-# of exeext.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-$as_echo_n "checking whether the C compiler works... " >&6; }
-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-
-# The possible output files:
-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-
-ac_rmfiles=
-for ac_file in $ac_files
-do
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
-  esac
-done
-rm -f $ac_rmfiles
-
-if { { ac_try="$ac_link_default"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link_default") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-# in a Makefile.  We should not override ac_cv_exeext if it was cached,
-# so that the user can short-circuit this test for compilers unknown to
-# Autoconf.
-for ac_file in $ac_files ''
-do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
-	;;
-    [ab].out )
-	# We found the default executable, but exeext='' is most
-	# certainly right.
-	break;;
-    *.* )
-	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
-	then :; else
-	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	fi
-	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
-	# argument, so we may need to know it at that point already.
-	# Even if this section looks crufty: it has the advantage of
-	# actually working.
-	break;;
-    * )
-	break;;
-  esac
-done
-test "$ac_cv_exeext" = no && ac_cv_exeext=
-
-else
-  ac_file=''
-fi
-if test -z "$ac_file"; then :
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-$as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-$as_echo_n "checking for C compiler default output file name... " >&6; }
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-$as_echo "$ac_file" >&6; }
-ac_exeext=$ac_cv_exeext
-
-rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-$as_echo_n "checking for suffix of executables... " >&6; }
-if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
-for ac_file in conftest.exe conftest conftest.*; do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  break;;
-    * ) break;;
-  esac
-done
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest conftest$ac_cv_exeext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-$as_echo "$ac_cv_exeext" >&6; }
-
-rm -f conftest.$ac_ext
-EXEEXT=$ac_cv_exeext
-ac_exeext=$EXEEXT
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdio.h>
-int
-main ()
-{
-FILE *f = fopen ("conftest.out", "w");
- return ferror (f) || fclose (f) != 0;
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files="$ac_clean_files conftest.out"
-# Check that the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-$as_echo_n "checking whether we are cross compiling... " >&6; }
-if test "$cross_compiling" != yes; then
-  { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-  if { ac_try='./conftest$ac_cv_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
-    fi
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-$as_echo "$cross_compiling" >&6; }
-
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-$as_echo_n "checking for suffix of object files... " >&6; }
-if ${ac_cv_objext+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.o conftest.obj
-if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  for ac_file in conftest.o conftest.obj conftest.*; do
-  test -f "$ac_file" || continue;
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
-       break;;
-  esac
-done
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-$as_echo "$ac_cv_objext" >&6; }
-OBJEXT=$ac_cv_objext
-ac_objext=$OBJEXT
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
-if ${ac_cv_c_compiler_gnu+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_compiler_gnu=yes
-else
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-$as_echo "$ac_cv_c_compiler_gnu" >&6; }
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+set}
-ac_save_CFLAGS=$CFLAGS
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-$as_echo_n "checking whether $CC accepts -g... " >&6; }
-if ${ac_cv_prog_cc_g+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-else
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-else
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-$as_echo "$ac_cv_prog_cc_g" >&6; }
-if test "$ac_test_CFLAGS" = set; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
-if ${ac_cv_prog_cc_c89+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdio.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;
-int
-main ()
-{
-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c89" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c89"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c89" != xno; then :
-
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-# Find a good install program.  We prefer a C program (faster),
-# so one script is as good as another.  But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-$as_echo_n "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if ${ac_cv_path_install+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    # Account for people who put trailing slashes in PATH elements.
-case $as_dir/ in #((
-  ./ | .// | /[cC]/* | \
-  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
-  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
-  /usr/ucb/* ) ;;
-  *)
-    # OSF1 and SCO ODT 3.0 have their own names for install.
-    # Don't use installbsd from OSF since it installs stuff as root
-    # by default.
-    for ac_prog in ginstall scoinst install; do
-      for ac_exec_ext in '' $ac_executable_extensions; do
-	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
-	  if test $ac_prog = install &&
-	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    rm -rf conftest.one conftest.two conftest.dir
-	    echo one > conftest.one
-	    echo two > conftest.two
-	    mkdir conftest.dir
-	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
-	      test -s conftest.one && test -s conftest.two &&
-	      test -s conftest.dir/conftest.one &&
-	      test -s conftest.dir/conftest.two
-	    then
-	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
-	      break 3
-	    fi
-	  fi
-	fi
-      done
-    done
-    ;;
-esac
-
-  done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
-  if test "${ac_cv_path_install+set}" = set; then
-    INSTALL=$ac_cv_path_install
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for INSTALL within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    INSTALL=$ac_install_sh
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-$as_echo "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-
-
-
-
-
-
-
-    if test "$RUSTFLAGS" \= ""
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x
-    then
-        for ac_prog in rustc lcrustc $host-gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    else
-        for ac_prog in rustc lcrustc $host-gccrs gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        as_fn_error $? "Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler" "$LINENO" 5
-    fi
-
-    if test x$host_alias != x
-    then
-        case $RUSTC in
-            *\\/$host-* )                 ;;
-            * )
-                SAVE_RUSTFLAGS="$RUSTFLAGS"
-                { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to cross compile with $RUSTC" >&5
-$as_echo_n "checking how to cross compile with $RUSTC... " >&6; }
-                RUSTFLAGS="$RUSTFLAGS --target $host"
-                echo '' > test.rs
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host" >&5
-$as_echo "--target $host" >&6; }
-                else
-                    rm -f test.rs libtest.rlib
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_alias"
-                    echo '' > test.rs
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                    if test $? -eq 0
-                    then
-                        rm -f test.rs libtest.rlib
-                        { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_alias" >&5
-$as_echo "--target $host_alias" >&6; }
-                    else
-                        rm -f test.rs libtest.rlib
-                        case "$host" in
-                            x86_64-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_target" >&5
-$as_echo "--target $host_target" >&6; }
-                                else
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                    as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                fi
-                            ;;
-
-                            i?86-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_target" >&5
-$as_echo "--target $host_target" >&6; }
-                                else
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                    as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                fi
-                            ;;
-
-                            *)
-                                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                ;;
-                        esac
-                    fi
-                fi
-                ;;
-        esac
-    fi
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Rust compiler works" >&5
-$as_echo_n "checking whether Rust compiler works... " >&6; }
-    echo 'fn main(){}' > test.rs
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-        as_fn_error $? "Cannot compile a simple program with $RUSTC" "$LINENO" 5
-    fi
-
-    if test x$host_alias != x
-    then
-        ./test${EXEEXT}
-        if test $? -ne 0
-        then
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-            as_fn_error $? "Cannot run executables compiled by $RUSTC" "$LINENO" 5
-        fi
-    fi
-
-    rm -rf test.rs test${EXEEXT}
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-
-
-
-
-
-
-ac_config_files="$ac_config_files Makefile"
-
-
-cat >confcache <<\_ACEOF
-# This file is a shell script that caches the results of configure
-# tests run on this system so they can be shared between configure
-# scripts and configure runs, see configure's option --config-cache.
-# It is not useful on other systems.  If it contains results you don't
-# want to keep, you may remove or edit it.
-#
-# config.status only pays attention to the cache file if you give it
-# the --recheck option to rerun configure.
-#
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
-# following values.
-
-_ACEOF
-
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
-  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-
-  (set) 2>&1 |
-    case $as_nl`(ac_space=' '; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \.
-      sed -n \
-	"s/'/'\\\\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;; #(
-    *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-) |
-  sed '
-     /^ac_cv_env_/b end
-     t clear
-     :clear
-     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
-     t end
-     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     :end' >>confcache
-if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-  if test -w "$cache_file"; then
-    if test "x$cache_file" != "x/dev/null"; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-$as_echo "$as_me: updating cache $cache_file" >&6;}
-      if test ! -f "$cache_file" || test -h "$cache_file"; then
-	cat confcache >"$cache_file"
-      else
-        case $cache_file in #(
-        */* | ?:*)
-	  mv -f confcache "$cache_file"$$ &&
-	  mv -f "$cache_file"$$ "$cache_file" ;; #(
-        *)
-	  mv -f confcache "$cache_file" ;;
-	esac
-      fi
-    fi
-  else
-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
-  fi
-fi
-rm -f confcache
-
-test "x$prefix" = xNONE && prefix=$ac_default_prefix
-# Let make expand exec_prefix.
-test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
-
-# Transform confdefs.h into DEFS.
-# Protect against shell expansion while executing Makefile rules.
-# Protect against Makefile macro expansion.
-#
-# If the first sed substitution is executed (which looks for macros that
-# take arguments), then branch to the quote section.  Otherwise,
-# look for a macro that doesn't take arguments.
-ac_script='
-:mline
-/\\$/{
- N
- s,\\\n,,
- b mline
-}
-t clear
-:clear
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-b any
-:quote
-s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
-s/\[/\\&/g
-s/\]/\\&/g
-s/\$/$$/g
-H
-:any
-${
-	g
-	s/^\n//
-	s/\n/ /g
-	p
-}
-'
-DEFS=`sed -n "$ac_script" confdefs.h`
-
-
-ac_libobjs=
-ac_ltlibobjs=
-U=
-for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-  # 1. Remove the extension, and $U if already installed.
-  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
-  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
-  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-  #    will be set to the directory where LIBOBJS objects are built.
-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
-done
-LIBOBJS=$ac_libobjs
-
-LTLIBOBJS=$ac_ltlibobjs
-
-
-
-: "${CONFIG_STATUS=./config.status}"
-ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
-as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-# Run this file to recreate the current configuration.
-# Compiler output produced by configure, useful for debugging
-# configure, is in config.log if it exists.
-
-debug=false
-ac_cs_recheck=false
-ac_cs_silent=false
-
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
-_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# Save the log message, to keep $0 and so on meaningful, and to
-# report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.
-ac_log="
-This file was extended by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  $ $0 $@
-
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
-"
-
-_ACEOF
-
-case $ac_config_files in *"
-"*) set x $ac_config_files; shift; ac_config_files=$*;;
-esac
-
-
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-# Files that config.status was made for.
-config_files="$ac_config_files"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
-from templates according to the current configuration.  Unless the files
-and actions are specified as TAGs, all are instantiated by default.
-
-Usage: $0 [OPTION]... [TAG]...
-
-  -h, --help       print this help, then exit
-  -V, --version    print version number and configuration settings, then exit
-      --config     print configuration, then exit
-  -q, --quiet, --silent
-                   do not print progress messages
-  -d, --debug      don't remove temporary files
-      --recheck    update $as_me by reconfiguring in the same conditions
-      --file=FILE[:TEMPLATE]
-                   instantiate the configuration file FILE
-
-Configuration files:
-$config_files
-
-Report bugs to the package provider."
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
-ac_cs_version="\\
-config.status
-configured by $0, generated by GNU Autoconf 2.69,
-  with options \\"\$ac_cs_config\\"
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This config.status script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it."
-
-ac_pwd='$ac_pwd'
-srcdir='$srcdir'
-INSTALL='$INSTALL'
-test -n "\$AWK" || AWK=awk
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# The default lists apply if the user does not specify any file.
-ac_need_defaults=:
-while test $# != 0
-do
-  case $1 in
-  --*=?*)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
-    ac_shift=:
-    ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
-  *)
-    ac_option=$1
-    ac_optarg=$2
-    ac_shift=shift
-    ;;
-  esac
-
-  case $ac_option in
-  # Handling of the options.
-  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-    ac_cs_recheck=: ;;
-  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
-    $as_echo "$ac_cs_version"; exit ;;
-  --config | --confi | --conf | --con | --co | --c )
-    $as_echo "$ac_cs_config"; exit ;;
-  --debug | --debu | --deb | --de | --d | -d )
-    debug=: ;;
-  --file | --fil | --fi | --f )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
-    esac
-    as_fn_append CONFIG_FILES " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h |  --help | --hel | -h )
-    $as_echo "$ac_cs_usage"; exit ;;
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil | --si | --s)
-    ac_cs_silent=: ;;
-
-  # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
-
-  *) as_fn_append ac_config_targets " $1"
-     ac_need_defaults=false ;;
-
-  esac
-  shift
-done
-
-ac_configure_extra_args=
-
-if $ac_cs_silent; then
-  exec 6>/dev/null
-  ac_configure_extra_args="$ac_configure_extra_args --silent"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-if \$ac_cs_recheck; then
-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-  shift
-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
-  CONFIG_SHELL='$SHELL'
-  export CONFIG_SHELL
-  exec "\$@"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-  $as_echo "$ac_log"
-} >&5
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-
-# Handling of arguments.
-for ac_config_target in $ac_config_targets
-do
-  case $ac_config_target in
-    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
-
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-  esac
-done
-
-
-# If the user did not use the arguments to specify the items to instantiate,
-# then the envvar interface is used.  Set only those that are not.
-# We use the long form for the default assignment because of an extremely
-# bizarre bug on SunOS 4.1.3.
-if $ac_need_defaults; then
-  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
-fi
-
-# Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason against having it here, and in addition,
-# creating and moving files from /tmp can sometimes cause problems.
-# Hook for its removal unless debugging.
-# Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
-$debug ||
-{
-  tmp= ac_tmp=
-  trap 'exit_status=$?
-  : "${ac_tmp:=$tmp}"
-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
-' 0
-  trap 'as_fn_exit 1' 1 2 13 15
-}
-# Create a (secure) tmp directory for tmp files.
-
-{
-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -d "$tmp"
-}  ||
-{
-  tmp=./conf$$-$RANDOM
-  (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
-ac_tmp=$tmp
-
-# Set up the scripts for CONFIG_FILES section.
-# No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
-if test -n "$CONFIG_FILES"; then
-
-
-ac_cr=`echo X | tr X '\015'`
-# On cygwin, bash can eat \r inside `` if the user requested igncr.
-# But we know of no other shell where ac_cr would be empty at this
-# point, so we can use a bashism as a fallback.
-if test "x$ac_cr" = x; then
-  eval ac_cr=\$\'\\r\'
-fi
-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
-else
-  ac_cs_awk_cr=$ac_cr
-fi
-
-echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
-_ACEOF
-
-
-{
-  echo "cat >conf$$subs.awk <<_ACEOF" &&
-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
-  echo "_ACEOF"
-} >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
-ac_delim='%!_!# '
-for ac_last_try in false false false false false :; do
-  . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-
-  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
-  if test $ac_delim_n = $ac_delim_num; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-rm -f conf$$subs.sh
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
-_ACEOF
-sed -n '
-h
-s/^/S["/; s/!.*/"]=/
-p
-g
-s/^[^!]*!//
-:repl
-t repl
-s/'"$ac_delim"'$//
-t delim
-:nl
-h
-s/\(.\{148\}\)..*/\1/
-t more1
-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
-p
-n
-b repl
-:more1
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t nl
-:delim
-h
-s/\(.\{148\}\)..*/\1/
-t more2
-s/["\\]/\\&/g; s/^/"/; s/$/"/
-p
-b
-:more2
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t delim
-' <conf$$subs.awk | sed '
-/^[^""]/{
-  N
-  s/\n//
-}
-' >>$CONFIG_STATUS || ac_write_fail=1
-rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACAWK
-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
-  for (key in S) S_is_set[key] = 1
-  FS = ""
-
-}
-{
-  line = $ 0
-  nfields = split(line, field, "@")
-  substed = 0
-  len = length(field[1])
-  for (i = 2; i < nfields; i++) {
-    key = field[i]
-    keylen = length(key)
-    if (S_is_set[key]) {
-      value = S[key]
-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
-      len += length(value) + length(field[++i])
-      substed = 1
-    } else
-      len += 1 + keylen
-  }
-
-  print line
-}
-
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
-else
-  cat
-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
-_ACEOF
-
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
-h
-s///
-s/^/:/
-s/[	 ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
-s/:*$//
-x
-s/\(=[	 ]*\).*/\1/
-G
-s/\n//
-s/^[^=]*=[	 ]*$//
-}'
-fi
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-fi # test -n "$CONFIG_FILES"
-
-
-eval set X "  :F $CONFIG_FILES      "
-shift
-for ac_tag
-do
-  case $ac_tag in
-  :[FHLC]) ac_mode=$ac_tag; continue;;
-  esac
-  case $ac_mode$ac_tag in
-  :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-  :[FH]-) ac_tag=-:-;;
-  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-  esac
-  ac_save_IFS=$IFS
-  IFS=:
-  set x $ac_tag
-  IFS=$ac_save_IFS
-  shift
-  ac_file=$1
-  shift
-
-  case $ac_mode in
-  :L) ac_source=$1;;
-  :[FH])
-    ac_file_inputs=
-    for ac_f
-    do
-      case $ac_f in
-      -) ac_f="$ac_tmp/stdin";;
-      *) # Look for the file first in the build tree, then in the source tree
-	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
-	 test -f "$ac_f" ||
-	   case $ac_f in
-	   [\\/$]*) false;;
-	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
-	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-      esac
-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-      as_fn_append ac_file_inputs " '$ac_f'"
-    done
-
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
-    # use $as_me), people would be surprised to read:
-    #    /* config.h.  Generated by config.status.  */
-    configure_input='Generated from '`
-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-	`' by configure.'
-    if test x"$ac_file" != x-; then
-      configure_input="$ac_file.  $configure_input"
-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-$as_echo "$as_me: creating $ac_file" >&6;}
-    fi
-    # Neutralize special characters interpreted by sed in replacement strings.
-    case $configure_input in #(
-    *\&* | *\|* | *\\* )
-       ac_sed_conf_input=`$as_echo "$configure_input" |
-       sed 's/[\\\\&|]/\\\\&/g'`;; #(
-    *) ac_sed_conf_input=$configure_input;;
-    esac
-
-    case $ac_tag in
-    *:-:* | *:-) cat >"$ac_tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
-    esac
-    ;;
-  esac
-
-  ac_dir=`$as_dirname -- "$ac_file" ||
-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_file" : 'X\(//\)[^/]' \| \
-	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  as_dir="$ac_dir"; as_fn_mkdir_p
-  ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-
-  case $ac_mode in
-  :F)
-  #
-  # CONFIG_FILE
-  #
-
-  case $INSTALL in
-  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
-  esac
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# If the template does not know about datarootdir, expand it.
-# FIXME: This hack should be removed a few years after 2.60.
-ac_datarootdir_hack=; ac_datarootdir_seen=
-ac_sed_dataroot='
-/datarootdir/ {
-  p
-  q
-}
-/@datadir@/p
-/@docdir@/p
-/@infodir@/p
-/@localedir@/p
-/@mandir@/p'
-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
-*datarootdir*) ac_datarootdir_seen=yes;;
-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  ac_datarootdir_hack='
-  s&@datadir@&$datadir&g
-  s&@docdir@&$docdir&g
-  s&@infodir@&$infodir&g
-  s&@localedir@&$localedir&g
-  s&@mandir@&$mandir&g
-  s&\\\${datarootdir}&$datarootdir&g' ;;
-esac
-_ACEOF
-
-# Neutralize VPATH when `$srcdir' = `.'.
-# Shell code in configure.ac might set extrasub.
-# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_sed_extra="$ac_vpsub
-$extrasub
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-:t
-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s|@configure_input@|$ac_sed_conf_input|;t t
-s&@top_builddir@&$ac_top_builddir_sub&;t t
-s&@top_build_prefix@&$ac_top_build_prefix&;t t
-s&@srcdir@&$ac_srcdir&;t t
-s&@abs_srcdir@&$ac_abs_srcdir&;t t
-s&@top_srcdir@&$ac_top_srcdir&;t t
-s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
-s&@builddir@&$ac_builddir&;t t
-s&@abs_builddir@&$ac_abs_builddir&;t t
-s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
-s&@INSTALL@&$ac_INSTALL&;t t
-$ac_datarootdir_hack
-"
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-
-test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-      "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
-$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
-
-  rm -f "$ac_tmp/stdin"
-  case $ac_file in
-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
-  esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
- ;;
-
-
-
-  esac
-
-done # for ac_tag
-
-
-as_fn_exit 0
-_ACEOF
-ac_clean_files=$ac_clean_files_save
-
-test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
-
-
-# configure is writing to config.log, and then calls config.status.
-# config.status does its own redirection, appending to config.log.
-# Unfortunately, on DOS this fails, as config.log is still kept open
-# by configure, so config.status won't be able to write to it; its
-# output is simply discarded.  So we exec the FD to /dev/null,
-# effectively closing config.log, so it can be properly (re)opened and
-# appended to by config.status.  When coming back to configure, we
-# need to make the FD available again.
-if test "$no_create" != yes; then
-  ac_cs_success=:
-  ac_config_status_args=
-  test "$silent" = yes &&
-    ac_config_status_args="$ac_config_status_args --quiet"
-  exec 5>/dev/null
-  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
-  exec 5>>config.log
-  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
-  # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
-fi
-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-fi
diff --git a/vendor/target-tuples-0.4.1/configure.ac b/vendor/target-tuples-0.4.1/configure.ac
deleted file mode 100644
index c5304ea5..00000000
--- a/vendor/target-tuples-0.4.1/configure.ac
+++ /dev/null
@@ -1,17 +0,0 @@
-AC_INIT
-
-AC_CONFIG_MACRO_DIRS([m4/])
-
-AC_CANONICAL_BUILD
-AC_CANONICAL_HOST
-
-AC_PROG_CC
-
-AC_PROG_INSTALL
-
-LCRUST_PROG_RUSTC
-
-AC_SUBST([detected_cfg])
-AC_CONFIG_FILES([Makefile])
-
-AC_OUTPUT
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/install-sh b/vendor/target-tuples-0.4.1/install-sh
deleted file mode 100755
index ec298b53..00000000
--- a/vendor/target-tuples-0.4.1/install-sh
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2020-11-14.01; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-        shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -p) cpprog="$cpprog -p";;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call 'install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-    dst=$dst_arg
-
-    # If destination is a directory, append the input filename.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
-
-        posix_mkdir=false
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
-	then
-	  if test -z "$dir_arg" || {
-	       # Check for POSIX incompatibilities with -m.
-	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-	       # other-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
-	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
-	fi
-	trap '' 0;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
-      esac
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && continue
-
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask $mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
-
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/vendor/target-tuples-0.4.1/m4/lcrust_prog_rustc.m4 b/vendor/target-tuples-0.4.1/m4/lcrust_prog_rustc.m4
deleted file mode 100644
index edf35367..00000000
--- a/vendor/target-tuples-0.4.1/m4/lcrust_prog_rustc.m4
+++ /dev/null
@@ -1,220 +0,0 @@
-
-AC_DEFUN([LCRUST_PROG_RUSTC],[
-    AC_REQUIRE([AC_PROG_CC])
-    AC_REQUIRE([AC_CANONICAL_HOST])
-    AC_ARG_VAR(RUSTC,[Rust compiler to use])
-    AC_ARG_VAR(RUSTFLAGS,[Flags to pass to the rust compiler])
-
-    if test "$RUSTFLAGS" \= "" 
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x 
-    then
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs])
-    else 
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs gccrs])
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler])
-    fi
-
-    if test x$host_alias != x
-    then
-        case $RUSTC in 
-            *[\\/]$host-* ) dnl gccrs has a host prefix when cross-compiling, so no need to attempt using `--target`
-                ;;
-            * )
-                SAVE_RUSTFLAGS="$RUSTFLAGS"
-                AC_MSG_CHECKING([how to cross compile with $RUSTC])
-                RUSTFLAGS="$RUSTFLAGS --target $host"
-                echo '' > test.rs
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs 2>> config.log > /dev/null
-                
-                if test $? -eq 0
-                then
-                    AC_MSG_RESULT([--target $host])
-                else
-                    rm -f test.rs libtest.rlib
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_alias"
-                    echo '' > test.rs
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                    if test $? -eq 0
-                    then
-                        rm -f test.rs libtest.rlib
-                        AC_MSG_RESULT([--target $host_alias])
-                    else
-                        rm -f test.rs libtest.rlib
-                        case "$host" in 
-                            x86_64-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    AC_MSG_RESULT([--target $host_target])
-                                else
-                                    AC_MSG_RESULT([failed])
-                                    AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                fi
-                            ;;
-
-                            i?86-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    AC_MSG_RESULT([--target $host_target])
-                                else
-                                    AC_MSG_RESULT([failed])
-                                    AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                fi
-                            ;;
-
-                            *)
-                                AC_MSG_RESULT([failed])
-                                AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                ;;
-                        esac
-                    fi
-                fi
-                ;;
-        esac
-    fi
-
-    AC_MSG_CHECKING([whether Rust compiler works])
-    echo 'fn main(){}' > test.rs 
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot compile a simple program with $RUSTC])
-    fi
-
-    if test x$host_alias != x 
-    then
-        ./test${EXEEXT}
-        if test $? -ne 0
-        then
-            AC_MSG_RESULT([no])
-            AC_MSG_ERROR([Cannot run executables compiled by $RUSTC])
-        fi
-    fi
-
-    rm -rf test.rs test${EXEEXT}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(RUSTC)
-    AC_SUBST(RUSTFLAGS)
-])
-
-AC_DEFUN([LCURST_RUSTC_VERSION],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-
-    version_output="`${RUSTC} --version`"
-
-    AC_MSG_CHECKING(the rust version supported by ${RUSTC})
-    
-    read rustc_name rust_version <<< ${version_output}
-
-    AC_MSG_RESULT(${rust_version})
-
-    case $rust_version in
-        *.*.*-beta.* )
-            rust_channel=beta
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${version_output}
-            IFS="-" read rust_patch <<< ${_lcrust_rest}
-            ;;
-        *.*.*-* )
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${version_output}
-            IFS="-" read rust_patch rust_channel <<< ${_lcrust_rest}
-            ;;
-        *.*.* )
-            rust_channel=stable
-            IFS="." read rust_major rust_minor rust_patch <<< ${version_output}
-            ;;
-    esac
-    AC_MSG_CHECKING(whether $RUSTC is lccc)
-    case $name in
-        lcrust* | lccc* ) dnl lccc doesn't distinguish between stable and unstable compiler, 
-            rustc_is_lccc=yes
-            ;;
-        * )
-            rustc_is_lccc=no
-            ;;
-    esac
-    AC_MSG_RESULT([$rustc_is_lccc])
-    
-    AC_SUBST(rustc_name)
-    AC_SUBST(rust_version)
-    AC_SUBST(rust_channel)
-    AC_SUBST(rustc_is_lccc)
-])
-
-AC_DEFUN([LCRUST_PROG_RUSTC_FOR_BUILD],[
-    AC_REQUIRE([AX_PROG_CC_FOR_BUILD])
-    AC_REQUIRE([AC_CANONICAL_BUILD])
-    AC_ARG_VAR(RUSTC_FOR_BUILD,[Rust compiler to use on the build system])
-    AC_ARG_VAR(RUSTFLAGS_FOR_BUILD,[Flags to pass to the rust compiler for the build system])
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build...])
-
-    AC_PATH_PROGS(RUSTC_FOR_BUILD,[rustc lcrustc $build-gccrs gccrs])
-
-    if test "$RUSTC_FOR_BUILD" \= ""
-    then
-        AC_MSG_NOTICE([checking for the compiler to use for $build... not found])
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC_FOR_BUILD to a suitable compiler])
-    fi
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build... $RUSTC_FOR_BUILD])
-
-
-    AC_MSG_CHECKING([whether Rust compiler works])
-    echo 'fn main(){}' > test.rs 
-    $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot compile a simple program with $RUSTC_FOR_BUILD])
-    fi
-    
-    ./test${EXEEXT_FOR_BUILD}
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot run executables compiled by $RUSTC_FOR_BUILD])
-    fi
-
-    rm -rf test.rs test${EXEEXT_FOR_BUILD}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(RUSTC_FOR_BUILD)
-    AC_SUBST(RUSTFLAGS_FOR_BUILD)
-])
-
-AC_DEFUN([LCRUST_TRY_COMPILE],[
-    echo '$1' >> test.rs
-    ${RUSTC} ${RUSTFLAGS} --crate-type rlib --crate-name test --emit link=libtest.rlib test.rs
-
-    if test $? -eq 0 
-    then
-        rm -f test.rs libtest.rlib
-        $2
-    else
-        rm -f test.rs libtest.rlib
-        $3
-    fi
-])
diff --git a/vendor/target-tuples-0.4.1/run-tests.sh b/vendor/target-tuples-0.4.1/run-tests.sh
deleted file mode 100755
index 16d10aff..00000000
--- a/vendor/target-tuples-0.4.1/run-tests.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-for s in $*
-do
-    $s
-done
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/src/config-sub.rs b/vendor/target-tuples-0.4.1/src/config-sub.rs
deleted file mode 100644
index d7f12d19..00000000
--- a/vendor/target-tuples-0.4.1/src/config-sub.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use target_tuples::*;
-
-pub fn main() {
-    let mut args = std::env::args();
-    let bin = args.next().unwrap();
-    if let Some(name) = args.next() {
-        match &*name {
-            "--help" => {
-                println!("Usage: {} [OPTION]|<target>", bin);
-                println!("Converts a target tuple into canonical form");
-                println!("Options:");
-                println!("\t--help: Prints this message, and exits");
-                println!("\t--version: Prints version information, and exists");
-            }
-            "--version" => {
-                println!("config.sub v{}", env!("CARGO_PKG_VERSION"));
-                println!("Copyright (C) 2020 Connor Horman, this program is a free software, dual-licensed under the terms of the Apache v2 and the MIT license");
-                println!("This program is provided AS-IS, without any warranty.");
-            }
-            x => {
-                if let Ok(t) = x.parse::<Target>() {
-                    println!("{}", t);
-                } else {
-                    eprintln!("Unsupported target {}", x);
-                    std::process::exit(1);
-                }
-            }
-        }
-    } else {
-        std::process::exit(1);
-    }
-}
diff --git a/vendor/target-tuples-0.4.1/src/lib.rs b/vendor/target-tuples-0.4.1/src/lib.rs
deleted file mode 100644
index 2761ea79..00000000
--- a/vendor/target-tuples-0.4.1/src/lib.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-#![deny(warnings, unsafe_code)]
-#![cfg_attr(not(any(doc, test)), no_std)]
-
-extern crate alloc;
-
-mod pieces;
-
-pub use pieces::*;
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __to_target {
-    ($first:ident-$($rest:ident)-+) => {
-        ::core::concat!(::core::stringify!($first) $(,"-",::core::stringify!($rest))*)
-    }
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __match_target_pattern {
-    ($arch:ident-$vendor:ident-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $os - $env));
-            *targ == mtarg
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $sys));
-            targ == mtarg
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $os - $env));
-
-            targ.get_vendor() == targ.get_vendor()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-    (*-$vendor:ident-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $sys));
-
-            targ.get_vendor() == targ.get_vendor()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - $os - $env));
-
-            targ.get_arch() == targ.get_arch()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-    ($arch:ident-*-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - $sys));
-
-            targ.get_arch() == targ.get_arch()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - $vendor - unknown - $env));
-
-            targ.get_arch() == targ.get_arch()
-                && targ.get_vendor() == mtarg.get_vendor()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - elf));
-
-            targ.get_arch() == targ.get_arch() && targ.get_vendor() == mtarg.get_vendor()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $os - elf));
-
-            targ.get_vendor() == mtarg.get_vendor()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $os - $env));
-
-            targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-    (*-*-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $sys));
-
-            targ.get_operating_system() == mtarg.get_operating_system()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - unknown - $env));
-
-            targ.get_vendor() == mtarg.get_vendor()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - elf));
-
-            targ.get_vendor() == mtarg.get_vendor()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $os - elf));
-
-            targ.get_vendor() == mtarg.get_vendor()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - unknown - unknown - $env));
-
-            targ.get_arch() == targ.get_arch()
-                && targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - elf));
-
-            targ.get_arch() == targ.get_arch()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - unknown - $os - unknown));
-
-            targ.get_arch() == mtarg.get_arch()
-                && targ.get_operating_system() == mtarg.get_operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - unknown - unknown - $env));
-
-            targ.get_environment() == mtarg.get_environment()
-                && targ.get_object_format() == mtarg.get_object_format()
-        }
-
-        __check
-    }};
-
-    (*-*-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $os - unknown));
-
-            targ.get_operating_system() == mtarg.get_operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-*) => {{
-        fn __check(_: &$crate::Target) -> bool {
-            true
-        }
-        __check
-    }};
-
-    (*) => {{
-        fn __check(_: &$crate::Target) -> bool {
-            true
-        }
-        __check
-    }};
-}
-
-#[macro_export]
-macro_rules! match_targets{
-    {
-        match ($targ:expr) {
-            $($($comp:tt)-* => $exp:expr),* $(,)?
-        }
-    } => {
-        {
-            let __val = $targ;
-            #[allow(unreachable_code)]
-            loop {
-                $(if ($crate::__match_target_pattern!($($comp)-*))(&__val){
-                    break $exp
-                })*
-
-                panic!("Incomplete Exhaustive Target Pattern (add a wildcard match as * => )")
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::Target;
-
-    #[test]
-    pub fn test_match_easy() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_arch_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                *-pc-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_vendor_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-*-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_os_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-*-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_env_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-* => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_sys_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-* => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_first() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-gnu => {},
-                x86_64-*-linux-* => panic!("Incorrect Match"),
-                * => panic!("Incorrect Match"),
-            }
-        }
-    }
-}
diff --git a/vendor/target-tuples-0.4.1/src/pieces.rs b/vendor/target-tuples-0.4.1/src/pieces.rs
deleted file mode 100644
index 15e8bb37..00000000
--- a/vendor/target-tuples-0.4.1/src/pieces.rs
+++ /dev/null
@@ -1,1011 +0,0 @@
-#![allow(
-    clippy::upper_case_acronyms,
-    clippy::manual_non_exhaustive,
-    clippy::match_like_matches_macro
-)] // Kill clippy for MSRV
-use alloc::{borrow::ToOwned, string::String};
-use core::{fmt::Display, str::FromStr};
-
-///
-/// The result of FromStr::from_str, when parsing a field (other than vendor),
-///  with a value that is not known to the library
-#[derive(Debug, Clone, Copy)]
-pub struct UnknownError;
-
-///
-/// The Architecture field of a target tuple
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum Architecture {
-    Unknown,
-    I86,
-    I8086,
-    I086,
-    I186,
-    I286,
-    I386,
-    I486,
-    I586,
-    I686,
-    X86_64,
-    Arm,
-    ArmBe,
-    Aarch64,
-    Aarch64Be,
-    Aarch64_32,
-    Mips,
-    MipsLE,
-    Mips64,
-    Mips64LE,
-    PowerPC32,
-    PowerPC64,
-    PowerPC64le,
-    RiscV32,
-    RiscV64,
-    Sparc,
-    SparcV9,
-    SparcEL,
-    Wasm32,
-    Wasm64,
-    Wc65c816,
-    M6502,
-    M65C02,
-    SPC700,
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl FromStr for Architecture {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "i86" => Self::I86,
-            "i8086" => Self::I8086,
-            "i086" => Self::I086,
-            "i186" => Self::I186,
-            "i286" => Self::I286,
-            "i386" => Self::I386,
-            "i486" => Self::I486,
-            "i586" => Self::I586,
-            "i686" => Self::I686,
-            "amd64" | "x86_64" | "x86_64h" => Self::X86_64,
-            "armeb" => Self::ArmBe,
-            "arm" => Self::Arm,
-            "aarch64" | "arm64" | "arm64e" => Self::Aarch64,
-            "aarch64_be" | "arm64_be" => Self::Aarch64Be,
-            "aarch64_32" | "arm64_32" => Self::Aarch64_32,
-            "powerpc" | "powerpcspe" | "ppc" | "ppc32" => Self::PowerPC32,
-            "powerpc64" | "ppu" | "ppc64" => Self::PowerPC64,
-            "powerpc64le" | "ppc64le" => Self::PowerPC64le,
-            "mips" | "mipseb" | "mipsallegrex" | "mipsisa32r6" | "mipsr6" => Self::Mips,
-            "mipsel" | "mipsallegrexel" | "mipsisa32r6el" | "mipsr6el" => Self::MipsLE,
-            "mips64" | "mips64eb" | "mipsn32" | "mipsisa64r6" | "mips64r6" | "mipsn32r6" => {
-                Self::Mips64
-            }
-            "mips64el" | "mipsn32el" | "mipsisa64r6el" | "mips64r6el" | "mipsn32r6el" => {
-                Self::Mips64LE
-            }
-            "sparc" => Self::Sparc,
-            "sparcel" => Self::SparcEL,
-            "sparcv9" | "sparc64" => Self::SparcV9,
-            "riscv32" => Self::RiscV32,
-            "riscv64" => Self::RiscV64,
-            "wc65c816" | "65816" | "w65c816" | "65c816" | "w65" => Self::Wc65c816,
-            "6502" | "6502x" | "6502X" => Self::M6502,
-            "65c02" | "65C02" => Self::M65C02,
-            "wasm32" => Self::Wasm32,
-            "wasm64" => Self::Wasm64,
-
-            "spc700" | "spc" => Self::SPC700,
-
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for Architecture {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Architecture {
-    /// Parses the Architecture in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], but returns [`Architecture::Unknown`], instead of an error,
-    ///  on an unknown architecture.
-    /// This is useful (in conjunction with an actual target name)
-    pub fn parse(st: &str) -> Self {
-        Self::from_str(st).unwrap_or(Architecture::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the target
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting an Architecture yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Architecture::Unknown => "unknown",
-            Architecture::I86 => "i86",
-            Architecture::I086 => "i086",
-            Architecture::I8086 => "i8086",
-            Architecture::I186 => "i186",
-            Architecture::I286 => "i286",
-            Architecture::I386 => "i386",
-            Architecture::I486 => "i486",
-            Architecture::I586 => "i586",
-            Architecture::I686 => "i686",
-            Architecture::X86_64 => "x86_64",
-            Architecture::Arm => "arm",
-            Architecture::ArmBe => "armeb",
-            Architecture::Aarch64 => "aarch64",
-            Architecture::Aarch64Be => "aarch64_be",
-            Architecture::Aarch64_32 => "aarch64_32",
-            Architecture::Mips => "mips",
-            Architecture::Mips64 => "mips64",
-            Architecture::PowerPC32 => "powerpc",
-            Architecture::PowerPC64 => "powerpc64",
-            Architecture::PowerPC64le => "powerpc64le",
-            Architecture::RiscV32 => "riscv32",
-            Architecture::RiscV64 => "riscv64",
-            Architecture::Sparc => "sparc",
-            Architecture::SparcV9 => "sparcv9",
-            Architecture::SparcEL => "sparcel",
-            Architecture::Wasm32 => "wasm32",
-            Architecture::Wasm64 => "wasm64",
-            Architecture::Wc65c816 => "w65",
-            Architecture::MipsLE => "mipsel",
-            Architecture::Mips64LE => "mips64el",
-            Architecture::M6502 => "6502",
-            Architecture::M65C02 => "6502",
-            Architecture::SPC700 => "spc700",
-            Architecture::__Nonexhaustive => unreachable!(),
-        }
-    }
-
-    pub fn is_x86(&self) -> bool {
-        match self {
-            Architecture::I86
-            | Architecture::I8086
-            | Architecture::I186
-            | Architecture::I286
-            | Architecture::I386
-            | Architecture::I486
-            | Architecture::I586
-            | Architecture::I686 => true,
-            _ => false,
-        }
-    }
-}
-
-///
-/// The Vendor field of a target tuple
-///
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum Vendor {
-    Unknown,
-    Apple,
-    PC,
-    SCEI,
-    Freescale,
-    IBM,
-    ImaginationTechnologies,
-    MipsTechnologies,
-    NVIDIA,
-    CSR,
-    Myriad,
-    AMD,
-    Mesa,
-    SUSE,
-    OpenEmbedded,
-    WDC,
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl FromStr for Vendor {
-    type Err = core::convert::Infallible;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "apple" => Self::Apple,
-            "pc" => Self::PC,
-            // "nes" => Self::NES,
-            // "snes" | "snesdev" => Self::SNES,
-            "scei" => Self::SCEI,
-            "fsl" => Self::Freescale,
-            "img" => Self::ImaginationTechnologies,
-            "ibm" => Self::IBM,
-            "mti" => Self::MipsTechnologies,
-            "nvidia" => Self::NVIDIA,
-            "csr" => Self::CSR,
-            "myriad" => Self::Myriad,
-            "amd" => Self::AMD,
-            "mesa" => Self::Mesa,
-            "suse" => Self::SUSE,
-            "oe" => Self::OpenEmbedded,
-            "wdc" => Self::WDC,
-            _ => Self::Unknown,
-        })
-    }
-}
-
-impl Display for Vendor {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Vendor {
-    /// Parses the Vendor in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`].
-    /// Note that an unknown vendor is not considered an error.
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap()
-    }
-
-    ///
-    /// Returns the canonical name of the vendor
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting a Vendor yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Vendor::Apple => "apple",
-            Vendor::PC => "pc",
-            Vendor::Unknown => "unknown",
-            Vendor::SCEI => "scei",
-            Vendor::Freescale => "fsl",
-            Vendor::IBM => "ibm",
-            Vendor::ImaginationTechnologies => "img",
-            Vendor::MipsTechnologies => "mti",
-            Vendor::NVIDIA => "nvidia",
-            Vendor::CSR => "csr",
-            Vendor::Myriad => "myriad",
-            Vendor::AMD => "amd",
-            Vendor::Mesa => "mesa",
-            Vendor::SUSE => "suse",
-            Vendor::OpenEmbedded => "oe",
-            Vendor::WDC => "wdc",
-            Vendor::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The Operating System Field of a target tuple
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum OS {
-    Unknown,
-
-    Ananas,
-    CloudABI,
-    Darwin,
-    DragonFly,
-    FreeBSD,
-    Fuchsia,
-    IOS,
-    KFreeBSD,
-    Linux,
-    Lv2,
-    MacOSX,
-    NetBSD,
-    OpenBSD,
-    Solaris,
-    Win32,
-    ZOS,
-    Haiku,
-    Minix,
-    RTEMS,
-    NaCl,
-    AIX,
-    CUDA,
-    NVCL,
-    AMDHSA,
-    PS4,
-    ELFIAMCU,
-    TvOS,
-    WatchOS,
-    Mesa3D,
-    Contiki,
-    AMDPAL,
-    HermitCore,
-    Hurd,
-    WASI,
-    Emscripten,
-    PhantomOS,
-    SNES, // Not an OS, but the currently config.sub places it in the os field
-    NES,  // likewise
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl FromStr for OS {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.starts_with("ananas") => Self::Ananas,
-            x if x.starts_with("cloudabi") => Self::CloudABI,
-            x if x.starts_with("darwin") => Self::Darwin,
-            x if x.starts_with("dragonfly") => Self::DragonFly,
-            x if x.starts_with("freebsd") => Self::FreeBSD,
-            x if x.starts_with("fuchsia") => Self::Fuchsia,
-            x if x.starts_with("ios") => Self::IOS,
-            x if x.starts_with("kfreebsd") => Self::KFreeBSD,
-            x if x.starts_with("linux") => Self::Linux,
-            x if x.starts_with("lv2") => Self::Lv2,
-            x if x.starts_with("macos") => Self::MacOSX,
-            x if x.starts_with("netbsd") => Self::NetBSD,
-            x if x.starts_with("openbsd") => Self::OpenBSD,
-            x if x.starts_with("solaris") => Self::Solaris,
-            x if x.starts_with("win32") | x.starts_with("windows") => Self::Win32,
-            x if x.starts_with("zos") => Self::ZOS,
-            x if x.starts_with("haiku") => Self::Haiku,
-            x if x.starts_with("minix") => Self::Minix,
-            x if x.starts_with("rtems") => Self::RTEMS,
-            x if x.starts_with("nacl") => Self::NaCl,
-            x if x.starts_with("aix") => Self::AIX,
-            x if x.starts_with("cuda") => Self::CUDA,
-            x if x.starts_with("nvcl") => Self::NVCL,
-            x if x.starts_with("amdhsa") => Self::AMDHSA,
-            x if x.starts_with("ps4") => Self::PS4,
-            x if x.starts_with("elfiamcu") => Self::ELFIAMCU,
-            x if x.starts_with("tvos") => Self::TvOS,
-            x if x.starts_with("watchos") => Self::WatchOS,
-            x if x.starts_with("mesa3d") => Self::Mesa3D,
-            x if x.starts_with("contiki") => Self::Contiki,
-            x if x.starts_with("amdpal") => Self::AMDPAL,
-            x if x.starts_with("hermit") => Self::HermitCore,
-            x if x.starts_with("hurd") => Self::Hurd,
-            x if x.starts_with("wasi") => Self::WASI,
-            x if x.starts_with("emscripten") => Self::Emscripten,
-            x if x.starts_with("phantom") => Self::PhantomOS,
-            x if x.starts_with("snes") => Self::SNES,
-            x if x.starts_with("nes") => Self::NES,
-
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for OS {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl OS {
-    /// Parses the OS in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], except that [`OS::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the operating system
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting an OS yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            OS::Unknown => "unknown",
-            OS::Ananas => "ananas",
-            OS::CloudABI => "cloudabi",
-            OS::Darwin => "darwin",
-            OS::DragonFly => "dragonfly",
-            OS::FreeBSD => "freebsd",
-            OS::Fuchsia => "fuchsia",
-            OS::IOS => "ios",
-            OS::KFreeBSD => "kfreebsd",
-            OS::Linux => "linux",
-            OS::Lv2 => "lv2",
-            OS::MacOSX => "macos",
-            OS::NetBSD => "netbsd",
-            OS::OpenBSD => "openbsd",
-            OS::Solaris => "solaris",
-            OS::Win32 => "win32",
-            OS::ZOS => "zos",
-            OS::Haiku => "haiku",
-            OS::Minix => "minix",
-            OS::RTEMS => "rtems",
-            OS::NaCl => "nacl",
-            OS::AIX => "aix",
-            OS::CUDA => "cuda",
-            OS::NVCL => "nvcl",
-            OS::AMDHSA => "amdhsa",
-            OS::PS4 => "ps4",
-            OS::ELFIAMCU => "elfiamcu",
-            OS::TvOS => "tvos",
-            OS::WatchOS => "watchos",
-            OS::Mesa3D => "mesa3d",
-            OS::Contiki => "contiki",
-            OS::AMDPAL => "amdpal",
-            OS::HermitCore => "hermit",
-            OS::Hurd => "hurd",
-            OS::WASI => "wasi",
-            OS::Emscripten => "emscripten",
-            OS::PhantomOS => "phantom",
-            OS::SNES => "snes",
-            OS::NES => "nes",
-            OS::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The Environment field of target tuples
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum Environment {
-    Unknown,
-    GNU,
-    GNUABIN32,
-    GNUABI64,
-    GNUEABI,
-    GNUEABIHF,
-    GNUX32,
-    CODE16,
-    EABI,
-    EABIHF,
-    Android,
-    Musl,
-    MuslEABI,
-    MuslEABIHF,
-
-    MSVC,
-    Itanium,
-    Cygnus,
-    CoreCLR,
-    Simulator,
-    MacABI,
-
-    PhantomStandard,
-    PhantomKernel,
-
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl FromStr for Environment {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.starts_with("eabihf") => Self::EABIHF,
-            x if x.starts_with("eabi") => Self::EABI,
-            x if x.starts_with("gnuabin32") => Self::GNUABIN32,
-            x if x.starts_with("gnuabi64") => Self::GNUABI64,
-            x if x.starts_with("gnueabihf") => Self::GNUEABIHF,
-            x if x.starts_with("gnueabi") => Self::GNUEABI,
-            x if x.starts_with("gnux32") => Self::GNUX32,
-            x if x.starts_with("gnu") => Self::GNU,
-            x if x.starts_with("code16") => Self::CODE16,
-            x if x.starts_with("android") => Self::Android,
-            x if x.starts_with("musleabihf") => Self::MuslEABIHF,
-            x if x.starts_with("musleabi") => Self::MuslEABI,
-            x if x.starts_with("musl") => Self::Musl,
-            x if x.starts_with("msvc") => Self::MSVC,
-            x if x.starts_with("itanium") => Self::Itanium,
-            x if x.starts_with("cygnus") => Self::Cygnus,
-            x if x.starts_with("coreclr") => Self::CoreCLR,
-            x if x.starts_with("simulator") => Self::Simulator,
-            x if x.starts_with("macabi") => Self::MacABI,
-            x if x.starts_with("pcore") || x.starts_with("user") => Self::PhantomStandard,
-            x if x.starts_with("pkrnl") || x.starts_with("kernel") => Self::PhantomKernel,
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for Environment {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Environment {
-    /// Parses the Environment name in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], except that [`Environment::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the environment
-    /// The canonical name, when passed into [`Self::parse`] will yield an equivalent value,
-    /// Formatting an Environment yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Environment::Unknown => "unknown",
-            Environment::GNU => "gnu",
-            Environment::GNUABIN32 => "gnuabin32",
-            Environment::GNUABI64 => "gnuabi64",
-            Environment::GNUEABI => "gnueabi",
-            Environment::GNUEABIHF => "gnueabihf",
-            Environment::GNUX32 => "gnux32",
-            Environment::CODE16 => "code16",
-            Environment::EABI => "eabi",
-            Environment::EABIHF => "eabihf",
-            Environment::Android => "android",
-            Environment::Musl => "musl",
-            Environment::MuslEABI => "musleabi",
-            Environment::MuslEABIHF => "musleabihf",
-            Environment::MSVC => "msvc",
-            Environment::Itanium => "itanium",
-            Environment::Cygnus => "cygnus",
-            Environment::CoreCLR => "coreclr",
-            Environment::Simulator => "simulator",
-            Environment::MacABI => "macabi",
-            Environment::PhantomStandard => "user",
-            Environment::PhantomKernel => "kernel",
-            Environment::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The object format used by a target
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum ObjectFormat {
-    Unknown,
-    XCoff,
-    Coff,
-    Elf,
-    Goff,
-    MachO,
-    Wasm,
-
-    Xo65,
-    O65,
-    WlaObj,
-
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-impl FromStr for ObjectFormat {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.ends_with("xcoff") => Self::XCoff,
-            x if x.ends_with("coff") => Self::Coff,
-            x if x.ends_with("elf") => Self::Elf,
-            x if x.ends_with("goff") => Self::Goff,
-            x if x.ends_with("macho") => Self::MachO,
-            x if x.ends_with("wasm") => Self::Wasm,
-            x if x.ends_with("xo65") => Self::Xo65,
-            x if x.ends_with("o65") => Self::O65,
-            x if x.ends_with("wlaobj") => Self::WlaObj,
-            x if x.ends_with("wla") => Self::WlaObj,
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for ObjectFormat {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl ObjectFormat {
-    /// Parses the ObjectFormat name in a "lossy" manner, from the end of the Environment field
-    /// This is equivalent to [`Self::from_str`], except that [`ObjectFormat::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the object format
-    /// The canonical name, when passed into [`Self::parse`] will yield an equivalent value,
-    /// Formatting an ObjectFormat yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            ObjectFormat::Unknown => "unknown",
-            ObjectFormat::XCoff => "xcoff",
-            ObjectFormat::Coff => "coff",
-            ObjectFormat::Elf => "elf",
-            ObjectFormat::Goff => "goff",
-            ObjectFormat::MachO => "macho",
-            ObjectFormat::Wasm => "wasm",
-            ObjectFormat::Xo65 => "xo65",
-            ObjectFormat::O65 => "o65",
-            ObjectFormat::WlaObj => "wlaobj",
-            ObjectFormat::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The representation of a target tuple.
-///
-/// A Target Tuple is of the form arch-vendor-system, where system can be either os-env
-///  or simply either os or env (the latter is used in the case of a freestanding target).
-///
-/// There are two types of target tuple: canonical and exact.
-/// This type can be used to represent both.
-///
-/// The [`core::fmt::Display`] implementation will display the canonical tuple;
-///  the function [`Self::get_name`] extracts the exact form that was parsed.
-/// In any case, if any field, other than vendor, is unknown, or the form is not the one above,
-///  the [`core::str::FromStr`] implementation will yield an UnknownError.
-///
-#[derive(Clone, Debug)]
-pub struct Target {
-    full: String,
-    arch: Architecture,
-    vendor: Option<Vendor>,
-    // Invariant:
-    // At least one of these fields is Some
-    os: Option<OS>,
-    env: Option<Environment>,
-    objfmt: Option<ObjectFormat>,
-}
-
-impl FromStr for Target {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut split = s.split('-');
-        let arch = split.next().ok_or(UnknownError).and_then(|s| s.parse())?;
-        let f2 = split.next().ok_or(UnknownError)?;
-        let f3 = split.next();
-        let f4 = split.next();
-        let vendor;
-        let os;
-        let env;
-        let objfmt;
-        if let (Some(s), None) = (f3, f4) {
-            if let "unknown" = f2 {
-                vendor = Some(Vendor::Unknown);
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    return Err(UnknownError);
-                }
-            } else if let Vendor::Unknown = f2.parse().unwrap() {
-                vendor = None;
-                os = Some(f2.parse()?);
-                env = s.parse().ok();
-                objfmt = s.parse().ok();
-                env.map(|_| ())
-                    .or_else(|| objfmt.map(|_| ()))
-                    .ok_or(UnknownError)?;
-            } else {
-                vendor = Some(f2.parse().unwrap());
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    return Err(UnknownError);
-                }
-            }
-        } else if let Some(s) = f4 {
-            vendor = Some(f2.parse().unwrap());
-            os = Some(f3.unwrap().parse()?);
-            env = s.parse().ok();
-            objfmt = s.parse().ok();
-            env.map(|_| ())
-                .or_else(|| objfmt.map(|_| ()))
-                .ok_or(UnknownError)?;
-        } else if let Ok(o) = f2.parse() {
-            vendor = None;
-            os = Some(o);
-            env = None;
-            objfmt = None;
-        } else if let Ok(e) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = Some(e);
-            objfmt = f2.parse().ok();
-        } else if let Ok(of) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = None;
-            objfmt = Some(of);
-        } else {
-            return Err(UnknownError);
-        }
-
-        Ok(Self {
-            full: s.to_owned(),
-            arch,
-            vendor,
-            os,
-            env,
-            objfmt,
-        })
-    }
-}
-
-impl Display for Target {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.arch.fmt(f)?;
-        f.write_str("-")?;
-        if let Some(vendor) = &self.vendor {
-            vendor.fmt(f)?;
-        } else {
-            self.get_vendor().fmt(f)?;
-        }
-        if let Some(os) = &self.os {
-            f.write_str("-")?;
-            os.fmt(f)?;
-        }
-        let mut last_field_sep = true;
-        if let Some(env) = &self.env {
-            last_field_sep = false;
-            f.write_str("-")?;
-            env.fmt(f)?;
-        }
-        if let Some(objfmt) = &self.objfmt {
-            if last_field_sep {
-                f.write_str("-")?;
-            }
-            objfmt.fmt(f)?;
-        }
-        Ok(())
-    }
-}
-
-impl core::hash::Hash for Target {
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        self.arch.hash(state);
-        self.vendor.hash(state);
-        self.os.hash(state);
-        self.env.hash(state);
-        self.objfmt.hash(state);
-    }
-}
-
-impl PartialEq for Target {
-    fn eq(&self, other: &Self) -> bool {
-        self.arch == other.arch
-            && self.vendor == other.vendor
-            && self.os == other.os
-            && self.env == other.env
-            && self.objfmt == other.objfmt
-    }
-}
-
-impl Eq for Target {}
-
-impl Target {
-    ///
-    /// Gets the exact name of the target tuple.
-    pub fn get_name(&self) -> &str {
-        &*self.full
-    }
-
-    ///
-    /// Returns the architecture name
-    pub fn get_arch_name(&self) -> &str {
-        self.full.split('-').next().unwrap()
-    }
-
-    pub fn get_vendor_name(&self) -> &str {
-        if self.vendor.is_some() {
-            self.full.split('-').nth(2).unwrap()
-        } else {
-            self.get_vendor().canonical_name()
-        }
-    }
-
-    /// Parses a target tuple of the form arch-vendor-system (where system is either os-env, os, or env).
-    /// If a field is not known, it is left as unknown, and the original value will be available
-    ///  through the exact name.
-    ///
-    /// Panics if s is not of the above form
-    pub fn parse(s: &str) -> Self {
-        let mut split = s.split('-');
-        let arch = Architecture::parse(split.next().unwrap());
-        let f2 = split.next().ok_or(UnknownError).unwrap();
-        let f3 = split.next();
-        let f4 = split.next();
-        let os;
-        let env;
-        let objfmt;
-        let vendor;
-        if let (Some(s), None) = (f3, f4) {
-            if let "unknown" = f2 {
-                vendor = Some(Vendor::Unknown);
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    os = Some(OS::Unknown);
-                    env = Some(Environment::Unknown);
-                    objfmt = None;
-                }
-            } else if let Vendor::Unknown = f2.parse().unwrap() {
-                vendor = None;
-                os = Some(f2.parse().unwrap());
-                env = s.parse().ok();
-                objfmt = s.parse().ok();
-                env.map(|_| ()).or_else(|| objfmt.map(|_| ())).unwrap();
-            } else {
-                vendor = Some(f2.parse().unwrap());
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    os = Some(OS::Unknown);
-                    env = Some(Environment::Unknown);
-                    objfmt = None;
-                }
-            }
-        } else if let Some(s) = f4 {
-            vendor = Some(f2.parse().unwrap());
-            os = Some(OS::parse(f3.unwrap()));
-            env = s.parse().ok();
-            objfmt = s.parse().ok();
-            env.map(|_| ()).or_else(|| objfmt.map(|_| ())).unwrap();
-        } else if let Ok(o) = f2.parse() {
-            vendor = None;
-            os = Some(o);
-            env = None;
-            objfmt = None;
-        } else if let Ok(e) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = Some(e);
-            objfmt = f2.parse().ok();
-        } else if let Ok(of) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = None;
-            objfmt = Some(of);
-        } else {
-            vendor = Some(Vendor::Unknown);
-            os = Some(OS::Unknown);
-            env = Some(Environment::Unknown);
-            objfmt = None;
-        }
-
-        Self {
-            full: s.to_owned(),
-            arch,
-            vendor,
-            os,
-            env,
-            objfmt,
-        }
-    }
-
-    ///
-    /// Gets the value of the `os` field
-    pub fn get_operating_system(&self) -> Option<OS> {
-        self.os
-    }
-
-    ///
-    /// Gets the value of the `env` field, or unknown if the environment was omitted
-    pub fn get_environment(&self) -> Option<Environment> {
-        self.env
-    }
-
-    ///
-    /// Constructs a target tuple in canonical form from the specified components.
-    pub fn from_components(
-        arch: Architecture,
-        vendor: Vendor,
-        os: Option<OS>,
-        env: Option<Environment>,
-        objfmt: Option<ObjectFormat>,
-    ) -> Self {
-        let mut ret = Self {
-            full: String::new(),
-            arch,
-            vendor: Some(vendor),
-            os,
-            env,
-            objfmt,
-        };
-        ret.full = alloc::format!("{}", &ret);
-        ret
-    }
-
-    ///
-    /// Gets the object format, either from the end of the `env` field, or the default for the target
-    pub fn get_object_format(&self) -> ObjectFormat {
-        if let Some(of) = self.objfmt {
-            of
-        } else {
-            match (&self.arch, &self.os) {
-                (Architecture::Unknown, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Aarch64, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Aarch64_32, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Arm, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (arch, Some(OS::MacOSX)) if arch.is_x86() => ObjectFormat::MachO,
-                (Architecture::X86_64, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Unknown, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Aarch64, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Aarch64_32, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Arm, Some(OS::Win32)) => ObjectFormat::Coff,
-                (arch, Some(OS::Win32)) if arch.is_x86() => ObjectFormat::Coff,
-                (Architecture::X86_64, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::PowerPC32, Some(OS::AIX)) => ObjectFormat::XCoff,
-                (Architecture::PowerPC64, Some(OS::AIX)) => ObjectFormat::XCoff,
-                (Architecture::SPC700, _) => ObjectFormat::WlaObj,
-                _ => ObjectFormat::Elf,
-            }
-        }
-    }
-
-    ///
-    /// Gets the value of the Architecture field
-    pub fn get_arch(&self) -> Architecture {
-        self.arch
-    }
-
-    ///
-    /// Gets the value of the vendor field.
-    pub fn get_vendor(&self) -> Vendor {
-        if let Some(vendor) = &self.vendor {
-            *vendor
-        } else if self.arch.is_x86() || Architecture::X86_64 == self.arch {
-            match self.os {
-                Some(OS::MacOSX) | Some(OS::IOS) | Some(OS::TvOS) | Some(OS::WatchOS) => {
-                    Vendor::Apple
-                }
-                Some(OS::CUDA) => Vendor::NVIDIA,
-                _ => Vendor::PC,
-            }
-        } else if let Architecture::Wc65c816 = self.arch {
-            Vendor::WDC
-        } else {
-            Vendor::Unknown
-        }
-    }
-}
-
-///
-/// Parses a target tuple from an environment variable.
-#[macro_export]
-macro_rules! from_env {
-    ($var:literal) => {{
-        use core::str::FromStr as _;
-        let _target: $crate::Target = ::core::env!($var).from_string().unwrap();
-        _target
-    }};
-    ($var:literal?) => {{
-        use core::str::FromStr as _;
-        let _target: ::core::option::Option<$crate::Target> =
-            ::core::option_env!($var).map(|s| s.from_string().unwrap());
-        _target
-    }};
-}
diff --git a/vendor/target-tuples-0.4.1/tests/config-sub.data b/vendor/target-tuples-0.4.1/tests/config-sub.data
deleted file mode 100644
index 5f5ace47..00000000
--- a/vendor/target-tuples-0.4.1/tests/config-sub.data
+++ /dev/null
@@ -1,7 +0,0 @@
-x86_64-pc-linux-gnu|x86_64-pc-linux-gnu
-x86_64-linux-musl|x86_64-pc-linux-musl
-x86_64-unknown-linux-gnux32|x86_64-unknown-linux-gnux32
-i386-phantom-kernel|i386-pc-phantom-kernel
-i486-windows-msvc|i486-pc-win32-msvc
-wc65c816-elf|w65-wdc-elf
-65816-snes-elf|w65-wdc-snes-elf
\ No newline at end of file
diff --git a/vendor/target-tuples-0.4.1/tests/sub_tests.rs b/vendor/target-tuples-0.4.1/tests/sub_tests.rs
deleted file mode 100644
index 559439f2..00000000
--- a/vendor/target-tuples-0.4.1/tests/sub_tests.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use std::fs::File;
-
-use std::io::{BufRead, BufReader};
-
-use target_tuples::Target;
-
-#[test]
-fn test_many_config_subs() -> std::io::Result<()> {
-    let f = BufReader::new(File::open(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/config-sub.data"
-    ))?);
-    for s in f.lines() {
-        let s = s?;
-        if s.trim().is_empty() {
-            continue;
-        }
-        let mut s = s.split('|');
-        let (k, v) = (s.next().unwrap(), s.next().unwrap());
-        let targ = Target::parse(k);
-        assert_eq!(targ.to_string(), v);
-    }
-
-    Ok(())
-}
-
-#[test]
-fn test_idempotency() -> std::io::Result<()> {
-    let f = BufReader::new(File::open(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/config-sub.data"
-    ))?);
-    for s in f.lines() {
-        let s = s?;
-        let s = s.trim();
-        if s.is_empty() || s.starts_with('#') {
-            continue;
-        }
-        let mut s = s.split('|');
-        let (_, v) = (s.next().unwrap(), s.next().unwrap());
-        let targ = Target::parse(v);
-        assert_eq!(targ.to_string(), v);
-    }
-
-    Ok(())
-}
diff --git a/vendor/target-tuples/.cargo-checksum.json b/vendor/target-tuples/.cargo-checksum.json
deleted file mode 100644
index 34b0ef5a..00000000
--- a/vendor/target-tuples/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.lock":"17ef6b2f09ea4fe29466e7e13e433c70b8360d2ed4c94cca806901e0d85edd1e","Cargo.toml":"f1cd43f909025a4c8bcc742c10c0c306331a736f9a82d21023e98dd38d614dcc","LICENSE-APACHE":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","LICENSE-MIT":"57613ec8df284b15e3817ea41d737621316d1e3c447522b6f9ba6b2b73481c92","Makefile.in":"d48b3239d5b52e87632bede7f14c4e409df244032ccf9e37612f832ae508513a","README.md":"5f72e3394c3ea2af717c4348a9b46993d09ad32521486a12e089d4d549847236","aclocal.m4":"a26093944b5ad2103cf81f8f3e919206fb397ea21e87fc1c9719ad70bf1d8c3c","config.guess":"19c12bb2ca19e68724c2854ed0512469518df19b0710cc2011a5ca540810979c","config.sub":"f7197ddfb309e86d5fbd7d3b440a5ababfbd4aac1e1f53b492e28e54db58b222","config.sub.1":"6d3def0a3d0485848263ab0ac507156e5358e33e12dbb12506629789268b8fd0","configure":"be3c5f0ba322d96c25fc1894c40043aafacb2f112b55d6a960b1bab6fc780bbc","configure.ac":"c1018510147f598754a880ae12577d2fb654e018cf41054b0164456444924436","install-sh":"3d7488bebd0cfc9b5c440c55d5b44f1c6e2e3d3e19894821bae4a27f9307f1d2","m4/lcrust_prog_rustc.m4":"1edafd2cf2b9bd1d68d980476b44c19a948761d40550932598939a705c1668c1","run-tests.sh":"6301cdd717d770d946503076778ccd7fecb712acaadc6379372cf35740a5b5a9","src/config-sub.rs":"73311c6a3c354aa52364575ea8da7d50ce4e3beef9428a5075d091cf5f1014cc","src/lib.rs":"91feafd68d9e160d6c04f7fa465dc1c70b3394734682dfba905b097bf7ef6945","src/pieces.rs":"f47470ada488f8e5939a5ae6885c8eeda12907f52bcd10709b9e365bf05e893a","tests/config-sub.data":"278f7cfc000f8268fc3b12d2c23aab3ba27a43f4ae0d1819af7d3790af49cf4b","tests/rustc-targets.data":"c6989416129990e8ccc8d9c807a90464a6c8cafdc97da78eab913dbad644ae58","tests/sub_tests.rs":"24ec5ba680086a044882c500776e30fbcfa40219bfac2e3715aca738391a2ee1"},"package":"ca2de718f92f7c38604d26f162a44dfa5f506d8836a63a914c4676fe131dce8f"}
\ No newline at end of file
diff --git a/vendor/target-tuples/Cargo.lock b/vendor/target-tuples/Cargo.lock
deleted file mode 100644
index 221f64ab..00000000
--- a/vendor/target-tuples/Cargo.lock
+++ /dev/null
@@ -1,7 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "target-tuples"
-version = "0.5.3"
diff --git a/vendor/target-tuples/Cargo.toml b/vendor/target-tuples/Cargo.toml
deleted file mode 100644
index bf2fb604..00000000
--- a/vendor/target-tuples/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "target-tuples"
-version = "0.5.3"
-authors = ["Connor Horman <chorman64@gmail.com>"]
-description = "    A library to parse target tuples of the form <arch>-<vendor>-<system>, similar to those used by autoconf.\n"
-readme = "README.md"
-license = "Apache-2.0 AND MIT"
-repository = "https://github.com/chorman0773/rust-target-tuples"
-[package.metadata.install-targets.config-sub]
-installed-path = "config.sub"
-
-[package.metadata.install-targets.config-sub-man]
-installed-path = "<mandir>/man1/config.sub.1"
-target-file = "config.sub.1"
-type = "man"
-
-[[bin]]
-name = "config-sub"
-path = "src/config-sub.rs"
-
-[dependencies]
diff --git a/vendor/target-tuples/LICENSE-APACHE b/vendor/target-tuples/LICENSE-APACHE
deleted file mode 100644
index e69de29b..00000000
diff --git a/vendor/target-tuples/LICENSE-MIT b/vendor/target-tuples/LICENSE-MIT
deleted file mode 100644
index 6d6b881f..00000000
--- a/vendor/target-tuples/LICENSE-MIT
+++ /dev/null
@@ -1,6 +0,0 @@
-Copyright (C) 2020 Connor Horman
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/vendor/target-tuples/Makefile.in b/vendor/target-tuples/Makefile.in
deleted file mode 100644
index e6e7c092..00000000
--- a/vendor/target-tuples/Makefile.in
+++ /dev/null
@@ -1,133 +0,0 @@
-# Root Options
-
-
-
-srcdir = @srcdir@
-builddir = @builddir@
-abs_builddir = @abs_builddir@
-
-RUSTC = @RUSTC@
-RUSTFLAGS := @RUSTFLAGS@
-
-INSTALL := @INSTALL@
-
-RUSTC_IS_LCCC = @rustc_is_lccc@
-
-## Install directories
-
-prefix = @prefix@
-exec_prefix = @exec_prefix@
-bindir = @bindir@
-libdir = @libdir@
-includedir = @includedir@
-sbindir = @sbindir@
-libexecdir = @libexecdir@
-datarootdir = @datarootdir@
-datadir = @datadir@
-mandir = @mandir@
-docdir = @docdir@
-infodir = @infodir@
-localedir = @localedir@
-sysconfdir = @sysconfdir@
-localstatedir = @localstatedir@
-runstatedir = @runstatedir@
-sharedstatedir = @sharedstatedir@
-
-
-# Other Configuration
-
-features = 
-binaries = config-sub
-tests = tests/sub_tests.rs
-# Package specific Configuration
-
-EDITION = 2018
-
-version = 0.4.0
-
-OUTPUT = libtarget-tuples.rlib
-
-CRATE_NAME = target_tuples
-
-DEPENDENCIES = 
-
-# Autogenerated variables
-
-file_to_crate = $(subst -,_,$(1))
-
-binary_outputs = $(foreach bin,$(binaries),$(bin)@EXEEXT@)
-
-CFG = $(foreach feature,$(features),feature="$feature") 
-
-SUBDIRS =
-
-EXTERN_CRATES = $(foreach dep,$(DEPENDENCIES),--extern $(call file_to_crate,$(dep))=$(abs_bindir)/vendor/$(dep)/lib$(dep).rlib)
-
-export CARGO_PKG_VERSION=$(version)
-export CARGO_MANIFEST_DIR=@abs_srcdir@
-
-# Targets
-
-all: stamp
-
-.PHONY: all clean distclean install install-strip
-
-
-Makefile: config.status @srcdir@/Makefile.in
-	@builddir@/config.status Makefile
-
-
-config.status: @srcdir@/configure
-	@builddir@/config.status --recheck
-
-
-stamp: $(binaries) $(OUTPUT)
-	touch stamp
-
-$(OUTPUT): Makefile
-
-
-include $(OUTPUT).d
-
-$(OUTPUT).d: $(srcdir)/src/lib.rs
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-$(OUTPUT): $(srcdir)/src/lib.rs
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(CRATE_NAME) --crate-type rlib --emit dep-info=@builddir@/$(OUTPUT).d --emit link=@abs_builddir@/$(OUTPUT) -o$(OUTPUT) $< $(EXTERN_CRATES)
-
-include $(foreach bin,$(binary_outputs),$(bin).d)
-
-$(foreach out,$(binary_outputs),$(out).d): %@EXEEXT@.d: $(srcdir)/src/%.rs $(OUTPUT)
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@ -o$*@EXEEXT@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-$(binary_outputs): %@EXEEXT@: $(srcdir)/src/%.rs $(OUTPUT)
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$*) --crate-type bin --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-clean: 
-	rm -f $(OUTPUT) $(binary_outputs) test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=%@EXEEXT@) stamp
-
-distclean: clean
-	rm -f config.status config.log $(OUTPUT).d test-$(OUTPUT:%.rlib=%@EXEEXT@).d $(foreach out,$(binary_outputs),$(out).d) Makefile
-
-install: $(binary_outputs)
-	$(INSTALL) -m755 $(binary_outputs) ${bindir}/
-
-install-strip: $(binary_outputs)
-	$(INSTALL) -s -m755 $(binary_outputs) ${bindir}/
-
-include test-$(OUTPUT:%.rlib=%@EXEEXT@).d
-
-tests/:
-	mkdir tests/
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@).d: $(srcdir)/src/lib.rs
-	$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d -otest-$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-test-$(OUTPUT:%.rlib=%@EXEEXT@): $(srcdir)/src/lib.rs
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --cfg test --crate-name $(CRATE_NAME) --test --emit dep-info=@builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@).d --emit link=@abs_builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) -o$(OUTPUT:%.rlib=%@EXEEXT@) $< $(EXTERN_CRATES)
-
-$(tests:%.rs=%@EXEEXT@): %@EXEEXT@: $(srcdir)/%.rs $(OUTPUT) tests/
-	+$(RUSTC) $(RUSTFLAGS) --edition $(EDITION) $(foreach cfg,$(CFG),--cfg $(cfg)) --crate-name $(call file_to_crate,$(*F)) --test --emit dep-info=@builddir@/$@.d --emit link=@abs_builddir@/$@ -o$@ $< $(EXTERN_CRATES) --extern $(CRATE_NAME)=@abs_builddir@/$(OUTPUT)
-
-check: @builddir@/test-$(OUTPUT:%.rlib=%@EXEEXT@) $(tests:%.rs=@builddir@/%@EXEEXT@)
-	$(srcdir)/run-tests.sh $(foreach file,$^,@builddir@/$(file))
\ No newline at end of file
diff --git a/vendor/target-tuples/README.md b/vendor/target-tuples/README.md
deleted file mode 100644
index 4a8bc3df..00000000
--- a/vendor/target-tuples/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# rust target-tuples
-
-Implements parsing of target tuples. Additionally provides a small program that implements config.sub. 
-
-## Copyright
-
-Copyright (C) 2020 Connor Horman
-
-This program is dual-licensed under the terms of the MIT and Apache v2 licenses. 
-See <LICENSE-MIT> and <LICENSE-APACHE> for details. 
-
-Persuant to the Apache v2 License, if you contribute to this software,
- you agree to allow the copyright holder to dual-license those contributions as above.
-
-
-## Building
-
-This library and it's associated programs can be built using cargo. 
-
-Additionally, it can be configured and built by running the configure script present in this repo with a Bourne-compatible shell. The standard options are available for the configure scripts. 
-
-## Semver Policy
-
-The MSRV for rust-target-tuples is rust 1.38. Increases to this value represents a semver major change.
-
-This library does not guarantee the output of any of it's string parsing methods, or the canonical name of any component. Changes to both parsing and canonicalization may happen in a minor release. Additional component values may also be added in a minor release. 
-
-
-
-
diff --git a/vendor/target-tuples/aclocal.m4 b/vendor/target-tuples/aclocal.m4
deleted file mode 100644
index 93288360..00000000
--- a/vendor/target-tuples/aclocal.m4
+++ /dev/null
@@ -1,15 +0,0 @@
-# generated automatically by aclocal 1.16.3 -*- Autoconf -*-
-
-# Copyright (C) 1996-2020 Free Software Foundation, Inc.
-
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
-m4_include([m4/lcrust_prog_rustc.m4])
diff --git a/vendor/target-tuples/config.guess b/vendor/target-tuples/config.guess
deleted file mode 100755
index f50dcdb6..00000000
--- a/vendor/target-tuples/config.guess
+++ /dev/null
@@ -1,1480 +0,0 @@
-#! /bin/sh
-# Attempt to guess a canonical system name.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-24'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-#
-# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
-#
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-#
-# Please send patches to <config-patches@gnu.org>.
-
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION]
-
-Output the configuration name of the system \`$me' is run on.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.guess ($timestamp)
-
-Originally written by Per Bothner.
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-    * )
-       break ;;
-  esac
-done
-
-if test $# != 0; then
-  echo "$me: too many arguments$help" >&2
-  exit 1
-fi
-
-trap 'exit 1' 1 2 15
-
-# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
-# compiler to aid in system detection is discouraged as it requires
-# temporary files to be created and, as you can see below, it is a
-# headache to deal with in a portable fashion.
-
-# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
-# use `HOST_CC' if defined, but it is deprecated.
-
-# Portable tmp directory creation inspired by the Autoconf team.
-
-set_cc_for_build='
-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
-: ${TMPDIR=/tmp} ;
- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
-dummy=$tmp/dummy ;
-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > "$dummy.c" ;
-	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-	     CC_FOR_BUILD="$c"; break ;
-	  fi ;
-	done ;
-	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found ;
-	fi
-	;;
- ,,*)   CC_FOR_BUILD=$CC ;;
- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac ; set_cc_for_build= ;'
-
-# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 1994-08-24)
-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
-	PATH=$PATH:/.attbin ; export PATH
-fi
-
-UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
-UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
-UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
-
-case "$UNAME_SYSTEM" in
-Linux|GNU|GNU/*)
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	LIBC=gnu
-
-	eval "$set_cc_for_build"
-	cat <<-EOF > "$dummy.c"
-	#include <features.h>
-	#if defined(__UCLIBC__)
-	LIBC=uclibc
-	#elif defined(__dietlibc__)
-	LIBC=dietlibc
-	#else
-	LIBC=gnu
-	#endif
-	EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
-
-	# If ldd exists, use it to detect musl libc.
-	if command -v ldd >/dev/null && \
-		ldd --version 2>&1 | grep -q ^musl
-	then
-	    LIBC=musl
-	fi
-	;;
-esac
-
-# Note: order is significant - the case branches are not exclusive.
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
-    *:NetBSD:*:*)
-	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
-	# switched to ELF, *-*-netbsd* would select the old
-	# object file format.  This provides both forward
-	# compatibility and a consistent mechanism for selecting the
-	# object file format.
-	#
-	# Note: NetBSD doesn't particularly care about the vendor
-	# portion of the name.  We always set it to "unknown".
-	sysctl="sysctl -n hw.machine_arch"
-	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    "/sbin/$sysctl" 2>/dev/null || \
-	    "/usr/sbin/$sysctl" 2>/dev/null || \
-	    echo unknown)`
-	case "$UNAME_MACHINE_ARCH" in
-	    armeb) machine=armeb-unknown ;;
-	    arm*) machine=arm-unknown ;;
-	    sh3el) machine=shl-unknown ;;
-	    sh3eb) machine=sh-unknown ;;
-	    sh5el) machine=sh5le-unknown ;;
-	    earmv*)
-		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
-		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
-		machine="${arch}${endian}"-unknown
-		;;
-	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
-	esac
-	# The Operating System including object format, if it has switched
-	# to ELF recently (or will in the future) and ABI.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		os=netbsdelf
-		;;
-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval "$set_cc_for_build"
-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep -q __ELF__
-		then
-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-		    # Return netbsd for either.  FIX?
-		    os=netbsd
-		else
-		    os=netbsdelf
-		fi
-		;;
-	    *)
-		os=netbsd
-		;;
-	esac
-	# Determine ABI tags.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
-		;;
-	esac
-	# The OS release
-	# Debian GNU/NetBSD machines have a different userland, and
-	# thus, need a distinct triplet. However, they do not need
-	# kernel version information, so it can be replaced with a
-	# suitable tag, in the style of linux-gnu.
-	case "$UNAME_VERSION" in
-	    Debian*)
-		release='-gnu'
-		;;
-	    *)
-		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
-		;;
-	esac
-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
-	# contains redundant information, the shorter form:
-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "$machine-${os}${release}${abi}"
-	exit ;;
-    *:Bitrig:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
-	exit ;;
-    *:OpenBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
-	exit ;;
-    *:LibertyBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
-	exit ;;
-    *:MidnightBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
-	exit ;;
-    *:ekkoBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
-	exit ;;
-    *:SolidBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
-	exit ;;
-    macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:MirBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:Sortix:*:*)
-	echo "$UNAME_MACHINE"-unknown-sortix
-	exit ;;
-    *:Redox:*:*)
-	echo "$UNAME_MACHINE"-unknown-redox
-	exit ;;
-    mips:OSF1:*.*)
-        echo mips-dec-osf1
-        exit ;;
-    alpha:OSF1:*:*)
-	case $UNAME_RELEASE in
-	*4.0)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
-		;;
-	*5.*)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
-		;;
-	esac
-	# According to Compaq, /usr/sbin/psrinfo has been available on
-	# OSF/1 and Tru64 systems produced since 1995.  I hope that
-	# covers most systems running today.  This code pipes the CPU
-	# types through head -n 1, so we only detect the type of CPU 0.
-	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case "$ALPHA_CPU_TYPE" in
-	    "EV4 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "EV4.5 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "LCA4 (21066/21068)")
-		UNAME_MACHINE=alpha ;;
-	    "EV5 (21164)")
-		UNAME_MACHINE=alphaev5 ;;
-	    "EV5.6 (21164A)")
-		UNAME_MACHINE=alphaev56 ;;
-	    "EV5.6 (21164PC)")
-		UNAME_MACHINE=alphapca56 ;;
-	    "EV5.7 (21164PC)")
-		UNAME_MACHINE=alphapca57 ;;
-	    "EV6 (21264)")
-		UNAME_MACHINE=alphaev6 ;;
-	    "EV6.7 (21264A)")
-		UNAME_MACHINE=alphaev67 ;;
-	    "EV6.8CB (21264C)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8AL (21264B)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8CX (21264D)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE=alphaev69 ;;
-	    "EV7 (21364)")
-		UNAME_MACHINE=alphaev7 ;;
-	    "EV7.9 (21364A)")
-		UNAME_MACHINE=alphaev79 ;;
-	esac
-	# A Pn.n version is a patched version.
-	# A Vn.n version is a released version.
-	# A Tn.n version is a released field test version.
-	# A Xn.n version is an unreleased experimental baselevel.
-	# 1.2 uses "1.2" for uname -r.
-	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
-    Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
-    *:[Aa]miga[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-amigaos
-	exit ;;
-    *:[Mm]orph[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-morphos
-	exit ;;
-    *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
-    *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
-    *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix"$UNAME_RELEASE"
-	exit ;;
-    arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "`(/bin/universe) 2>/dev/null`" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
-    NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
-    DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
-	case `/usr/bin/uname -p` in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
-    s390x:SunOS:*:*)
-	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux"$UNAME_RELEASE"
-	exit ;;
-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval "$set_cc_for_build"
-	SUN_ARCH=i386
-	# If there is a compiler, see if it is configured for 64-bit objects.
-	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
-	# This test works for both compilers.
-	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		SUN_ARCH=x86_64
-	    fi
-	fi
-	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:6*:*)
-	# According to config.sub, this is the proper way to canonicalize
-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
-	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:*:*)
-	case "`/usr/bin/arch -k`" in
-	    Series*|S4*)
-		UNAME_RELEASE=`uname -v`
-		;;
-	esac
-	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
-	exit ;;
-    sun3*:SunOS:*:*)
-	echo m68k-sun-sunos"$UNAME_RELEASE"
-	exit ;;
-    sun*:*:4.2BSD:*)
-	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case "`/bin/arch`" in
-	    sun3)
-		echo m68k-sun-sunos"$UNAME_RELEASE"
-		;;
-	    sun4)
-		echo sparc-sun-sunos"$UNAME_RELEASE"
-		;;
-	esac
-	exit ;;
-    aushp:SunOS:*:*)
-	echo sparc-auspex-sunos"$UNAME_RELEASE"
-	exit ;;
-    # The situation for MiNT is a little confusing.  The machine name
-    # can be virtually everything (everything which is not
-    # "atarist" or "atariste" at least should have a processor
-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
-    # to the lowercase version "mint" (or "freemint").  Finally
-    # the system name "TOS" denotes a system which is actually not
-    # MiNT.  But MiNT is downward compatible to TOS, so this should
-    # be no problem.
-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint"$UNAME_RELEASE"
-	exit ;;
-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint"$UNAME_RELEASE"
-	exit ;;
-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint"$UNAME_RELEASE"
-	exit ;;
-    m68k:machten:*:*)
-	echo m68k-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    powerpc:machten:*:*)
-	echo powerpc-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
-    RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix"$UNAME_RELEASE"
-	exit ;;
-    mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-	#if defined (host_mips) && defined (MIPSEB)
-	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
-	#endif
-	#endif
-	  exit (-1);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
-	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
-	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
-	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos"$UNAME_RELEASE"
-	exit ;;
-    Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
-    Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
-    m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
-    m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
-    m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
-    AViiON:dgux:*:*)
-	# DG/UX returns AViiON for all architectures
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ]
-	then
-	    if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \
-	       [ "$TARGET_BINARY_INTERFACE"x = x ]
-	    then
-		echo m88k-dg-dgux"$UNAME_RELEASE"
-	    else
-		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
-	    fi
-	else
-	    echo i586-dg-dgux"$UNAME_RELEASE"
-	fi
-	exit ;;
-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
-    M88*:*:R3*:*)
-	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
-    *:IRIX*:*:*)
-	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
-	exit ;;
-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
-    i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
-    ia64:AIX:*:*)
-	if [ -x /usr/bin/oslevel ] ; then
-		IBM_REV=`/usr/bin/oslevel`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:2:3)
-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval "$set_cc_for_build"
-		sed 's/^		//' << EOF > "$dummy.c"
-		#include <sys/systemcfg.h>
-
-		main()
-			{
-			if (!__power_pc())
-				exit(1);
-			puts("powerpc-ibm-aix3.2.5");
-			exit(0);
-			}
-EOF
-		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
-		then
-			echo "$SYSTEM_NAME"
-		else
-			echo rs6000-ibm-aix3.2.5
-		fi
-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
-	else
-		echo rs6000-ibm-aix3.2
-	fi
-	exit ;;
-    *:AIX:*:[4567])
-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
-		IBM_ARCH=rs6000
-	else
-		IBM_ARCH=powerpc
-	fi
-	if [ -x /usr/bin/lslpp ] ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
-			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
-    *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
-    DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
-    9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
-    9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	case "$UNAME_MACHINE" in
-	    9000/31?)            HP_ARCH=m68000 ;;
-	    9000/[34]??)         HP_ARCH=m68k ;;
-	    9000/[678][0-9][0-9])
-		if [ -x /usr/bin/getconf ]; then
-		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
-		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "$sc_cpu_version" in
-		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
-		      532)                      # CPU_PA_RISC2_0
-			case "$sc_kernel_bits" in
-			  32) HP_ARCH=hppa2.0n ;;
-			  64) HP_ARCH=hppa2.0w ;;
-			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
-			esac ;;
-		    esac
-		fi
-		if [ "$HP_ARCH" = "" ]; then
-		    eval "$set_cc_for_build"
-		    sed 's/^		//' << EOF > "$dummy.c"
-
-		#define _HPUX_SOURCE
-		#include <stdlib.h>
-		#include <unistd.h>
-
-		int main ()
-		{
-		#if defined(_SC_KERNEL_BITS)
-		    long bits = sysconf(_SC_KERNEL_BITS);
-		#endif
-		    long cpu  = sysconf (_SC_CPU_VERSION);
-
-		    switch (cpu)
-			{
-			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-			case CPU_PA_RISC2_0:
-		#if defined(_SC_KERNEL_BITS)
-			    switch (bits)
-				{
-				case 64: puts ("hppa2.0w"); break;
-				case 32: puts ("hppa2.0n"); break;
-				default: puts ("hppa2.0"); break;
-				} break;
-		#else  /* !defined(_SC_KERNEL_BITS) */
-			    puts ("hppa2.0"); break;
-		#endif
-			default: puts ("hppa1.0"); break;
-			}
-		    exit (0);
-		}
-EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
-		    test -z "$HP_ARCH" && HP_ARCH=hppa
-		fi ;;
-	esac
-	if [ "$HP_ARCH" = hppa2.0w ]
-	then
-	    eval "$set_cc_for_build"
-
-	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
-	    # generating 64-bit code.  GNU and HP use different nomenclature:
-	    #
-	    # $ CC_FOR_BUILD=cc ./config.guess
-	    # => hppa2.0w-hp-hpux11.23
-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
-	    # => hppa64-hp-hpux11.23
-
-	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep -q __LP64__
-	    then
-		HP_ARCH=hppa2.0w
-	    else
-		HP_ARCH=hppa64
-	    fi
-	fi
-	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
-	exit ;;
-    ia64:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	echo ia64-hp-hpux"$HPUX_REV"
-	exit ;;
-    3050*:HI-UX:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#include <unistd.h>
-	int
-	main ()
-	{
-	  long cpu = sysconf (_SC_CPU_VERSION);
-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
-	     results, however.  */
-	  if (CPU_IS_PA_RISC (cpu))
-	    {
-	      switch (cpu)
-		{
-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
-		  default: puts ("hppa-hitachi-hiuxwe2"); break;
-		}
-	    }
-	  else if (CPU_IS_HP_MC68K (cpu))
-	    puts ("m68k-hitachi-hiuxwe2");
-	  else puts ("unknown-hitachi-hiuxwe2");
-	  exit (0);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
-		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	echo hppa1.1-hp-bsd
-	exit ;;
-    9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	echo hppa1.1-hp-osf
-	exit ;;
-    hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
-    i*86:OSF1:*:*)
-	if [ -x /usr/sbin/sysversion ] ; then
-	    echo "$UNAME_MACHINE"-unknown-osf1mk
-	else
-	    echo "$UNAME_MACHINE"-unknown-osf1
-	fi
-	exit ;;
-    parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
-    CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*[A-Z]90:*:*:*)
-	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-	      -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*TS:*:*:*)
-	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
-	exit ;;
-    sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:BSD/OS:*:*)
-	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:FreeBSD:*:*)
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case "$UNAME_PROCESSOR" in
-	    amd64)
-		UNAME_PROCESSOR=x86_64 ;;
-	    i386)
-		UNAME_PROCESSOR=i586 ;;
-	esac
-	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    i*:CYGWIN*:*)
-	echo "$UNAME_MACHINE"-pc-cygwin
-	exit ;;
-    *:MINGW64*:*)
-	echo "$UNAME_MACHINE"-pc-mingw64
-	exit ;;
-    *:MINGW*:*)
-	echo "$UNAME_MACHINE"-pc-mingw32
-	exit ;;
-    *:MSYS*:*)
-	echo "$UNAME_MACHINE"-pc-msys
-	exit ;;
-    i*:PW*:*)
-	echo "$UNAME_MACHINE"-pc-pw32
-	exit ;;
-    *:Interix*:*)
-	case "$UNAME_MACHINE" in
-	    x86)
-		echo i586-pc-interix"$UNAME_RELEASE"
-		exit ;;
-	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	    IA64)
-		echo ia64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	esac ;;
-    i*:UWIN*:*)
-	echo "$UNAME_MACHINE"-pc-uwin
-	exit ;;
-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-unknown-cygwin
-	exit ;;
-    prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    *:GNU:*:*)
-	# the GNU system
-	echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
-	exit ;;
-    *:GNU/*:*:*)
-	# other systems with GNU libc and userland
-	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC"
-	exit ;;
-    i*86:Minix:*:*)
-	echo "$UNAME_MACHINE"-pc-minix
-	exit ;;
-    aarch64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    aarch64_be:Linux:*:*)
-	UNAME_MACHINE=aarch64_be
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
-	  EV5)   UNAME_MACHINE=alphaev5 ;;
-	  EV56)  UNAME_MACHINE=alphaev56 ;;
-	  PCA56) UNAME_MACHINE=alphapca56 ;;
-	  PCA57) UNAME_MACHINE=alphapca56 ;;
-	  EV6)   UNAME_MACHINE=alphaev6 ;;
-	  EV67)  UNAME_MACHINE=alphaev67 ;;
-	  EV68*) UNAME_MACHINE=alphaev68 ;;
-	esac
-	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arm*:Linux:*:*)
-	eval "$set_cc_for_build"
-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_EABI__
-	then
-	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	else
-	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep -q __ARM_PCS_VFP
-	    then
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
-	    else
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
-	    fi
-	fi
-	exit ;;
-    avr32*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    cris:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    crisv32:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    e2k:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    frv:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    hexagon:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:Linux:*:*)
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	exit ;;
-    ia64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    k1om:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m32r*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m68*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    mips:Linux:*:* | mips64:Linux:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#undef CPU
-	#undef ${UNAME_MACHINE}
-	#undef ${UNAME_MACHINE}el
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=${UNAME_MACHINE}el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=${UNAME_MACHINE}
-	#else
-	CPU=
-	#endif
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
-	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
-	;;
-    mips64el:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-"$LIBC"
-	exit ;;
-    or32:Linux:*:* | or1k*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    padre:Linux:*:*)
-	echo sparc-unknown-linux-"$LIBC"
-	exit ;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-"$LIBC"
-	exit ;;
-    parisc:Linux:*:* | hppa:Linux:*:*)
-	# Look for CPU level
-	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
-	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
-	  *)    echo hppa-unknown-linux-"$LIBC" ;;
-	esac
-	exit ;;
-    ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-"$LIBC"
-	exit ;;
-    ppc:Linux:*:*)
-	echo powerpc-unknown-linux-"$LIBC"
-	exit ;;
-    ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-"$LIBC"
-	exit ;;
-    ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-"$LIBC"
-	exit ;;
-    riscv32:Linux:*:* | riscv64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    s390:Linux:*:* | s390x:Linux:*:*)
-	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
-	exit ;;
-    sh64*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sh*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    tile*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    vax:Linux:*:*)
-	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
-	exit ;;
-    x86_64:Linux:*:*)
-	if objdump -f /bin/sh | grep -q elf32-x86-64; then
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
-	else
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	fi
-	exit ;;
-    xtensa*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:DYNIX/ptx:4*:*)
-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
-	# earlier versions are messed up and put the nodename in both
-	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
-    i*86:UNIX_SV:4.2MP:2.*)
-	# Unixware is an offshoot of SVR4, but it has its own version
-	# number series starting with 2...
-	# I am not positive that other SVR4 systems won't match this,
-	# I just have to hope.  -- rms.
-	# Use sysv4.2uw... so that sysv4* matches it.
-	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
-	exit ;;
-    i*86:OS/2:*:*)
-	# If we were able to find `uname', then EMX Unix compatibility
-	# is probably installed.
-	echo "$UNAME_MACHINE"-pc-os2-emx
-	exit ;;
-    i*86:XTS-300:*:STOP)
-	echo "$UNAME_MACHINE"-unknown-stop
-	exit ;;
-    i*86:atheos:*:*)
-	echo "$UNAME_MACHINE"-unknown-atheos
-	exit ;;
-    i*86:syllable:*:*)
-	echo "$UNAME_MACHINE"-pc-syllable
-	exit ;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    i*86:*DOS:*:*)
-	echo "$UNAME_MACHINE"-pc-msdosdjgpp
-	exit ;;
-    i*86:*:4.*:*)
-	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
-	fi
-	exit ;;
-    i*86:*:5:[678]*)
-	# UnixWare 7.x, OpenUNIX and OpenServer 6.
-	case `/bin/uname -X | grep "^Machine"` in
-	    *486*)	     UNAME_MACHINE=i486 ;;
-	    *Pentium)	     UNAME_MACHINE=i586 ;;
-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
-	esac
-	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
-	exit ;;
-    i*86:*:3.2:*)
-	if test -f /usr/options/cb.name; then
-		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
-	elif /bin/uname -X 2>/dev/null >/dev/null ; then
-		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
-			&& UNAME_MACHINE=i586
-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv32
-	fi
-	exit ;;
-    pc:*:*:*)
-	# Left here for compatibility:
-	# uname -m prints for DJGPP always 'pc', but it prints nothing about
-	# the processor, so we play safe by assuming i586.
-	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configure will decide that
-	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
-    Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
-    paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
-    i860:*:4.*:*) # i860-SVR4
-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
-	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
-	fi
-	exit ;;
-    mini*:CTIX:SYS*5:*)
-	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
-    mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
-    M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
-    M68*:*:R3V[5678]*:*)
-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
-	OS_REL=''
-	test -r /etc/.relid \
-	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4; exit; } ;;
-    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
-	OS_REL='.3'
-	test -r /etc/.relid \
-	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
-    TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv"$UNAME_RELEASE"
-	exit ;;
-    RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    *:SINIX-*:*:*)
-	if uname -p 2>/dev/null >/dev/null ; then
-		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo "$UNAME_MACHINE"-sni-sysv4
-	else
-		echo ns32k-sni-sysv
-	fi
-	exit ;;
-    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
-    *:UNIX_System_V:4*:FTX*)
-	# From Gerald Hewes <hewes@openmarket.com>.
-	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
-    *:*:*:FTX*)
-	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
-    i*86:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo "$UNAME_MACHINE"-stratus-vos
-	exit ;;
-    *:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
-    mc68*:A/UX:*:*)
-	echo m68k-apple-aux"$UNAME_RELEASE"
-	exit ;;
-    news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if [ -d /usr/nec ]; then
-		echo mips-nec-sysv"$UNAME_RELEASE"
-	else
-		echo mips-unknown-sysv"$UNAME_RELEASE"
-	fi
-	exit ;;
-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
-    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
-    x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
-    SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Rhapsody:*:*)
-	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval "$set_cc_for_build"
-	if test "$UNAME_PROCESSOR" = unknown ; then
-	    UNAME_PROCESSOR=powerpc
-	fi
-	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
-	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_64BIT_ARCH >/dev/null
-		then
-		    case $UNAME_PROCESSOR in
-			i386) UNAME_PROCESSOR=x86_64 ;;
-			powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		    esac
-		fi
-		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_PPC >/dev/null
-		then
-		    UNAME_PROCESSOR=powerpc
-		fi
-	    fi
-	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # Avoid executing cc on OS X 10.9, as it ships with a stub
-	    # that puts up a graphical alert prompting to install
-	    # developer tools.  Any system running Mac OS X 10.7 or
-	    # later (Darwin 11 and later) is required to have a 64-bit
-	    # processor. This is not true of the ARM version of Darwin
-	    # that Apple uses in portable devices.
-	    UNAME_PROCESSOR=x86_64
-	fi
-	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
-	exit ;;
-    *:procnto*:*:* | *:QNX:[0123456789]*:*)
-	UNAME_PROCESSOR=`uname -p`
-	if test "$UNAME_PROCESSOR" = x86; then
-		UNAME_PROCESSOR=i386
-		UNAME_MACHINE=pc
-	fi
-	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
-	exit ;;
-    *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
-    NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSV-*:NONSTOP_KERNEL:*:*)
-	echo nsv-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
-    BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
-    DS/*:UNIX_System_V:*:*)
-	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
-	exit ;;
-    *:Plan9:*:*)
-	# "uname -m" is not consistent, so use $cputype instead. 386
-	# is converted to i386 for consistency with other x86
-	# operating systems.
-	if test "$cputype" = 386; then
-	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
-	fi
-	echo "$UNAME_MACHINE"-unknown-plan9
-	exit ;;
-    *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
-    *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
-    *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
-    *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
-    SEI:*:*:SEIUX)
-	echo mips-sei-seiux"$UNAME_RELEASE"
-	exit ;;
-    *:DragonFly:*:*)
-	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    *:*VMS:*:*)
-	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "$UNAME_MACHINE" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
-	esac ;;
-    *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
-    i*86:skyos:*:*)
-	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
-	exit ;;
-    i*86:rdos:*:*)
-	echo "$UNAME_MACHINE"-pc-rdos
-	exit ;;
-    i*86:AROS:*:*)
-	echo "$UNAME_MACHINE"-pc-aros
-	exit ;;
-    x86_64:VMkernel:*:*)
-	echo "$UNAME_MACHINE"-unknown-esx
-	exit ;;
-    amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
-esac
-
-echo "$0: unable to guess system type" >&2
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM" in
-    mips:Linux | mips64:Linux)
-	# If we got here on MIPS GNU/Linux, output extra information.
-	cat >&2 <<EOF
-
-NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
-the system type. Please install a C compiler and try again.
-EOF
-	;;
-esac
-
-cat >&2 <<EOF
-
-This script (version $timestamp), has failed to recognize the
-operating system you are using. If your script is old, overwrite *all*
-copies of config.guess and config.sub with the latest versions from:
-
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-and
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-If $0 has already been updated, send the following data and any
-information you think might be pertinent to config-patches@gnu.org to
-provide the necessary information to handle your system.
-
-config.guess timestamp = $timestamp
-
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
-
-hostinfo               = `(hostinfo) 2>/dev/null`
-/bin/universe          = `(/bin/universe) 2>/dev/null`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
-/bin/arch              = `(/bin/arch) 2>/dev/null`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
-
-UNAME_MACHINE = "$UNAME_MACHINE"
-UNAME_RELEASE = "$UNAME_RELEASE"
-UNAME_SYSTEM  = "$UNAME_SYSTEM"
-UNAME_VERSION = "$UNAME_VERSION"
-EOF
-
-exit 1
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/target-tuples/config.sub b/vendor/target-tuples/config.sub
deleted file mode 100755
index 1d8e98bc..00000000
--- a/vendor/target-tuples/config.sub
+++ /dev/null
@@ -1,1801 +0,0 @@
-#! /bin/sh
-# Configuration validation subroutine script.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-22'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-
-
-# Please send patches to <config-patches@gnu.org>.
-#
-# Configuration subroutine to validate and canonicalize a configuration type.
-# Supply the specified configuration type as an argument.
-# If it is invalid, we print an error message on stderr and exit with code 1.
-# Otherwise, we print the canonical config type on stdout and succeed.
-
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-# This file is supposed to be the same for all GNU packages
-# and recognize all the CPU types, system types and aliases
-# that are meaningful with *any* GNU software.
-# Each package is responsible for reporting which valid configurations
-# it does not support.  The user should be able to distinguish
-# a failure to support a valid configuration from a meaningless
-# configuration.
-
-# The goal of this file is to map all the various variations of a given
-# machine specification into a single specification in the form:
-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or in some cases, the newer four-part form:
-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# It is wrong to echo any other type of specification.
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
-
-Canonicalize a configuration name.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.sub ($timestamp)
-
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help"
-       exit 1 ;;
-
-    *local*)
-       # First pass through any local machine types.
-       echo "$1"
-       exit ;;
-
-    * )
-       break ;;
-  esac
-done
-
-case $# in
- 0) echo "$me: missing argument$help" >&2
-    exit 1;;
- 1) ;;
- *) echo "$me: too many arguments$help" >&2
-    exit 1;;
-esac
-
-# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
-# Here we must recognize all the valid KERNEL-OS combinations.
-maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
-case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | cloudabi*-eabi* | \
-  storm-chaos* | os2-emx* | rtmk-nova*)
-    os=-$maybe_os
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
-    ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
-  *)
-    basic_machine=`echo "$1" | sed 's/-[^-]*$//'`
-    if [ "$basic_machine" != "$1" ]
-    then os=`echo "$1" | sed 's/.*-/-/'`
-    else os=; fi
-    ;;
-esac
-
-### Let's recognize common machines as not being operating systems so
-### that things like config.sub decstation-3100 work.  We also
-### recognize some manufacturers as not being operating systems, so we
-### can provide default operating systems below.
-case $os in
-	-sun*os*)
-		# Prevent following clause from handling this invalid input.
-		;;
-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
-		os=
-		basic_machine=$1
-		;;
-	-bluegene*)
-		os=-cnk
-		;;
-	-sim | -cisco | -oki | -wec | -winbond)
-		os=
-		basic_machine=$1
-		;;
-	-scout)
-		;;
-	-wrs)
-		os=-vxworks
-		basic_machine=$1
-		;;
-	-chorusos*)
-		os=-chorusos
-		basic_machine=$1
-		;;
-	-chorusrdb)
-		os=-chorusrdb
-		basic_machine=$1
-		;;
-	-hiux*)
-		os=-hiuxwe2
-		;;
-	-sco6)
-		os=-sco5v6
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5)
-		os=-sco3.2v5
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco4)
-		os=-sco3.2v4
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2.[4-9]*)
-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2v[4-9]*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco*)
-		os=-sco3.2v2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-udk*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-isc)
-		os=-isc2.2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-clix*)
-		basic_machine=clipper-intergraph
-		;;
-	-isc*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
-		;;
-	-lynx*)
-		os=-lynxos
-		;;
-	-ptx*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'`
-		;;
-	-psos*)
-		os=-psos
-		;;
-	-mint | -mint[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-esac
-
-# Decode aliases for certain CPU-COMPANY combinations.
-case $basic_machine in
-	# Recognize the basic CPU types without company name.
-	# Some are omitted here because they have special meanings below.
-	1750a | 580 \
-	| a29k \
-	| aarch64 | aarch64_be \
-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
-	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| ba \
-	| be32 | be64 \
-	| bfin \
-	| c4x | c8051 | clipper \
-	| d10v | d30v | dlx | dsp16xx \
-	| e2k | epiphany \
-	| fido | fr30 | frv | ft32 \
-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
-	| i370 | i860 | i960 | ia16 | ia64 \
-	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
-	| mips | mipsbe | mipseb | mipsel | mipsle \
-	| mips16 \
-	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
-	| mips64vr | mips64vrel \
-	| mips64vr4100 | mips64vr4100el \
-	| mips64vr4300 | mips64vr4300el \
-	| mips64vr5000 | mips64vr5000el \
-	| mips64vr5900 | mips64vr5900el \
-	| mipsisa32 | mipsisa32el \
-	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
-	| mipsisa64 | mipsisa64el \
-	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
-	| mipsisa64sb1 | mipsisa64sb1el \
-	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
-	| mipstx39 | mipstx39el \
-	| mn10200 | mn10300 \
-	| moxie \
-	| mt \
-	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
-	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
-	| pdp10 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
-	| pru \
-	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
-	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
-	| sh64 | sh64le \
-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
-	| wasm32 \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
-		basic_machine=$basic_machine-unknown
-		;;
-	c54x)
-		basic_machine=tic54x-unknown
-		;;
-	c55x)
-		basic_machine=tic55x-unknown
-		;;
-	c6x)
-		basic_machine=tic6x-unknown
-		;;
-	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
-		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65)
-		;;
-	ms1)
-		basic_machine=mt-unknown
-		;;
-
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
-		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
-		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
-		;;
-
-	# We use `pc' rather than `unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-	  basic_machine=$basic_machine-pc
-	  ;;
-	# Object if more than one company name word.
-	*-*-*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-	# Recognize the basic CPU types with company name.
-	580-* \
-	| a29k-* \
-	| aarch64-* | aarch64_be-* \
-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
-	| avr-* | avr32-* \
-	| ba-* \
-	| be32-* | be64-* \
-	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
-	| d10v-* | d30v-* | dlx-* \
-	| e2k-* | elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
-	| h8300-* | h8500-* \
-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
-	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
-	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
-	| m32c-* | m32r-* | m32rle-* \
-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
-	| mips16-* \
-	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
-	| mips64vr-* | mips64vrel-* \
-	| mips64vr4100-* | mips64vr4100el-* \
-	| mips64vr4300-* | mips64vr4300el-* \
-	| mips64vr5000-* | mips64vr5000el-* \
-	| mips64vr5900-* | mips64vr5900el-* \
-	| mipsisa32-* | mipsisa32el-* \
-	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
-	| mipsisa64-* | mipsisa64el-* \
-	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
-	| mipsisa64sb1-* | mipsisa64sb1el-* \
-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
-	| mipstx39-* | mipstx39el-* \
-	| mmix-* \
-	| mt-* \
-	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
-	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
-	| orion-* \
-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
-	| pru-* \
-	| pyramid-* \
-	| riscv32-* | riscv64-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
-	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
-	| tahoe-* \
-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
-	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
-	| wasm32-* \
-	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
-	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
-		;;
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	386bsd)
-		basic_machine=i386-pc
-		os=-bsd
-		;;
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		basic_machine=m68000-att
-		;;
-	3b*)
-		basic_machine=we32k-att
-		;;
-	a29khif)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	abacus)
-		basic_machine=abacus-unknown
-		;;
-	adobe68k)
-		basic_machine=m68010-adobe
-		os=-scout
-		;;
-	alliant | fx80)
-		basic_machine=fx80-alliant
-		;;
-	altos | altos3068)
-		basic_machine=m68k-altos
-		;;
-	am29k)
-		basic_machine=a29k-none
-		os=-bsd
-		;;
-	amd64)
-		basic_machine=x86_64-pc
-		;;
-	amd64-*)
-		basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	amdahl)
-		basic_machine=580-amdahl
-		os=-sysv
-		;;
-	amiga | amiga-*)
-		basic_machine=m68k-unknown
-		;;
-	amigaos | amigados)
-		basic_machine=m68k-unknown
-		os=-amigaos
-		;;
-	amigaunix | amix)
-		basic_machine=m68k-unknown
-		os=-sysv4
-		;;
-	apollo68)
-		basic_machine=m68k-apollo
-		os=-sysv
-		;;
-	apollo68bsd)
-		basic_machine=m68k-apollo
-		os=-bsd
-		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
-	asmjs)
-		basic_machine=asmjs-unknown
-		;;
-	aux)
-		basic_machine=m68k-apple
-		os=-aux
-		;;
-	balance)
-		basic_machine=ns32k-sequent
-		os=-dynix
-		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c90)
-		basic_machine=c90-cray
-		os=-unicos
-		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
-	convex-c1)
-		basic_machine=c1-convex
-		os=-bsd
-		;;
-	convex-c2)
-		basic_machine=c2-convex
-		os=-bsd
-		;;
-	convex-c32)
-		basic_machine=c32-convex
-		os=-bsd
-		;;
-	convex-c34)
-		basic_machine=c34-convex
-		os=-bsd
-		;;
-	convex-c38)
-		basic_machine=c38-convex
-		os=-bsd
-		;;
-	cray | j90)
-		basic_machine=j90-cray
-		os=-unicos
-		;;
-	craynv)
-		basic_machine=craynv-cray
-		os=-unicosmp
-		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
-		os=-elf
-		;;
-	crds | unos)
-		basic_machine=m68k-crds
-		;;
-	crisv32 | crisv32-* | etraxfs*)
-		basic_machine=crisv32-axis
-		;;
-	cris | cris-* | etrax*)
-		basic_machine=cris-axis
-		;;
-	crx)
-		basic_machine=crx-unknown
-		os=-elf
-		;;
-	da30 | da30-*)
-		basic_machine=m68k-da30
-		;;
-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
-		basic_machine=mips-dec
-		;;
-	decsystem10* | dec10*)
-		basic_machine=pdp10-dec
-		os=-tops10
-		;;
-	decsystem20* | dec20*)
-		basic_machine=pdp10-dec
-		os=-tops20
-		;;
-	delta | 3300 | motorola-3300 | motorola-delta \
-	      | 3300-motorola | delta-motorola)
-		basic_machine=m68k-motorola
-		;;
-	delta88)
-		basic_machine=m88k-motorola
-		os=-sysv3
-		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
-	djgpp)
-		basic_machine=i586-pc
-		os=-msdosdjgpp
-		;;
-	dpx20 | dpx20-*)
-		basic_machine=rs6000-bull
-		os=-bosx
-		;;
-	dpx2*)
-		basic_machine=m68k-bull
-		os=-sysv3
-		;;
-	e500v[12])
-		basic_machine=powerpc-unknown
-		os=$os"spe"
-		;;
-	e500v[12]-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=$os"spe"
-		;;
-	ebmon29k)
-		basic_machine=a29k-amd
-		os=-ebmon
-		;;
-	elxsi)
-		basic_machine=elxsi-elxsi
-		os=-bsd
-		;;
-	encore | umax | mmax)
-		basic_machine=ns32k-encore
-		;;
-	es1800 | OSE68k | ose68k | ose | OSE)
-		basic_machine=m68k-ericsson
-		os=-ose
-		;;
-	fx2800)
-		basic_machine=i860-alliant
-		;;
-	genix)
-		basic_machine=ns32k-ns
-		;;
-	gmicro)
-		basic_machine=tron-gmicro
-		os=-sysv
-		;;
-	go32)
-		basic_machine=i386-pc
-		os=-go32
-		;;
-	h3050r* | hiux*)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	h8300hms)
-		basic_machine=h8300-hitachi
-		os=-hms
-		;;
-	h8300xray)
-		basic_machine=h8300-hitachi
-		os=-xray
-		;;
-	h8500hms)
-		basic_machine=h8500-hitachi
-		os=-hms
-		;;
-	harris)
-		basic_machine=m88k-harris
-		os=-sysv3
-		;;
-	hp300-*)
-		basic_machine=m68k-hp
-		;;
-	hp300bsd)
-		basic_machine=m68k-hp
-		os=-bsd
-		;;
-	hp300hpux)
-		basic_machine=m68k-hp
-		os=-hpux
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		basic_machine=m68000-hp
-		;;
-	hp9k3[2-9][0-9])
-		basic_machine=m68k-hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hppaosf)
-		basic_machine=hppa1.1-hp
-		os=-osf
-		;;
-	hppro)
-		basic_machine=hppa1.1-hp
-		os=-proelf
-		;;
-	i370-ibm* | ibm*)
-		basic_machine=i370-ibm
-		;;
-	i*86v32)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv32
-		;;
-	i*86v4*)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv4
-		;;
-	i*86v)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv
-		;;
-	i*86sol2)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-solaris2
-		;;
-	i386mach)
-		basic_machine=i386-mach
-		os=-mach
-		;;
-	vsta)
-		basic_machine=i386-unknown
-		os=-vsta
-		;;
-	iris | iris4d)
-		basic_machine=mips-sgi
-		case $os in
-		    -irix*)
-			;;
-		    *)
-			os=-irix4
-			;;
-		esac
-		;;
-	isi68 | isi)
-		basic_machine=m68k-isi
-		os=-sysv
-		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	magnum | m3230)
-		basic_machine=mips-mips
-		os=-sysv
-		;;
-	merlin)
-		basic_machine=ns32k-utek
-		os=-sysv
-		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
-	mingw32)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
-	miniframe)
-		basic_machine=m68000-convergent
-		;;
-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-	mips3*-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`
-		;;
-	mips3*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown
-		;;
-	monitor)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	morphos)
-		basic_machine=powerpc-unknown
-		os=-morphos
-		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
-		;;
-	msdos)
-		basic_machine=i386-pc
-		os=-msdos
-		;;
-	ms1-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'`
-		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
-	mvs)
-		basic_machine=i370-ibm
-		os=-mvs
-		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
-	ncr3000)
-		basic_machine=i486-ncr
-		os=-sysv4
-		;;
-	netbsd386)
-		basic_machine=i386-unknown
-		os=-netbsd
-		;;
-	netwinder)
-		basic_machine=armv4l-rebel
-		os=-linux
-		;;
-	news | news700 | news800 | news900)
-		basic_machine=m68k-sony
-		os=-newsos
-		;;
-	news1000)
-		basic_machine=m68030-sony
-		os=-newsos
-		;;
-	news-3600 | risc-news)
-		basic_machine=mips-sony
-		os=-newsos
-		;;
-	necv70)
-		basic_machine=v70-nec
-		os=-sysv
-		;;
-	next | m*-next)
-		basic_machine=m68k-next
-		case $os in
-		    -nextstep* )
-			;;
-		    -ns2*)
-		      os=-nextstep2
-			;;
-		    *)
-		      os=-nextstep3
-			;;
-		esac
-		;;
-	nh3000)
-		basic_machine=m68k-harris
-		os=-cxux
-		;;
-	nh[45]000)
-		basic_machine=m88k-harris
-		os=-cxux
-		;;
-	nindy960)
-		basic_machine=i960-intel
-		os=-nindy
-		;;
-	mon960)
-		basic_machine=i960-intel
-		os=-mon960
-		;;
-	nonstopux)
-		basic_machine=mips-compaq
-		os=-nonstopux
-		;;
-	np1)
-		basic_machine=np1-gould
-		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
-	nsr-tandem)
-		basic_machine=nsr-tandem
-		;;
-	nsv-tandem)
-		basic_machine=nsv-tandem
-		;;
-	nsx-tandem)
-		basic_machine=nsx-tandem
-		;;
-	op50n-* | op60c-*)
-		basic_machine=hppa1.1-oki
-		os=-proelf
-		;;
-	openrisc | openrisc-*)
-		basic_machine=or32-unknown
-		;;
-	os400)
-		basic_machine=powerpc-ibm
-		os=-os400
-		;;
-	OSE68000 | ose68000)
-		basic_machine=m68000-ericsson
-		os=-ose
-		;;
-	os68k)
-		basic_machine=m68k-none
-		os=-os68k
-		;;
-	pa-hitachi)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	paragon)
-		basic_machine=i860-intel
-		os=-osf
-		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	pbd)
-		basic_machine=sparc-tti
-		;;
-	pbb)
-		basic_machine=m68k-tti
-		;;
-	pc532 | pc532-*)
-		basic_machine=ns32k-pc532
-		;;
-	pc98)
-		basic_machine=i386-pc
-		;;
-	pc98-*)
-		basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium | p5 | k5 | k6 | nexgen | viac3)
-		basic_machine=i586-pc
-		;;
-	pentiumpro | p6 | 6x86 | athlon | athlon_*)
-		basic_machine=i686-pc
-		;;
-	pentiumii | pentium2 | pentiumiii | pentium3)
-		basic_machine=i686-pc
-		;;
-	pentium4)
-		basic_machine=i786-pc
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium4-*)
-		basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pn)
-		basic_machine=pn-gould
-		;;
-	power)	basic_machine=power-ibm
-		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
-		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppcle | powerpclittle)
-		basic_machine=powerpcle-unknown
-		;;
-	ppcle-* | powerpclittle-*)
-		basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64)	basic_machine=powerpc64-unknown
-		;;
-	ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64le | powerpc64little)
-		basic_machine=powerpc64le-unknown
-		;;
-	ppc64le-* | powerpc64little-*)
-		basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ps2)
-		basic_machine=i386-ibm
-		;;
-	pw32)
-		basic_machine=i586-unknown
-		os=-pw32
-		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
-		;;
-	rdos32)
-		basic_machine=i386-pc
-		os=-rdos
-		;;
-	rom68k)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	rm[46]00)
-		basic_machine=mips-siemens
-		;;
-	rtpc | rtpc-*)
-		basic_machine=romp-ibm
-		;;
-	s390 | s390-*)
-		basic_machine=s390-ibm
-		;;
-	s390x | s390x-*)
-		basic_machine=s390x-ibm
-		;;
-	sa29200)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	sb1)
-		basic_machine=mipsisa64sb1-unknown
-		;;
-	sb1el)
-		basic_machine=mipsisa64sb1el-unknown
-		;;
-	sde)
-		basic_machine=mipsisa32-sde
-		os=-elf
-		;;
-	sei)
-		basic_machine=mips-sei
-		os=-seiux
-		;;
-	sequent)
-		basic_machine=i386-sequent
-		;;
-	sh5el)
-		basic_machine=sh5le-unknown
-		;;
-	simso-wrs)
-		basic_machine=sparclite-wrs
-		os=-vxworks
-		;;
-	sps7)
-		basic_machine=m68k-bull
-		os=-sysv2
-		;;
-	spur)
-		basic_machine=spur-unknown
-		;;
-	st2000)
-		basic_machine=m68k-tandem
-		;;
-	stratus)
-		basic_machine=i860-stratus
-		os=-sysv4
-		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	sun2)
-		basic_machine=m68000-sun
-		;;
-	sun2os3)
-		basic_machine=m68000-sun
-		os=-sunos3
-		;;
-	sun2os4)
-		basic_machine=m68000-sun
-		os=-sunos4
-		;;
-	sun3os3)
-		basic_machine=m68k-sun
-		os=-sunos3
-		;;
-	sun3os4)
-		basic_machine=m68k-sun
-		os=-sunos4
-		;;
-	sun4os3)
-		basic_machine=sparc-sun
-		os=-sunos3
-		;;
-	sun4os4)
-		basic_machine=sparc-sun
-		os=-sunos4
-		;;
-	sun4sol2)
-		basic_machine=sparc-sun
-		os=-solaris2
-		;;
-	sun3 | sun3-*)
-		basic_machine=m68k-sun
-		;;
-	sun4)
-		basic_machine=sparc-sun
-		;;
-	sun386 | sun386i | roadrunner)
-		basic_machine=i386-sun
-		;;
-	sv1)
-		basic_machine=sv1-cray
-		os=-unicos
-		;;
-	symmetry)
-		basic_machine=i386-sequent
-		os=-dynix
-		;;
-	t3e)
-		basic_machine=alphaev5-cray
-		os=-unicos
-		;;
-	t90)
-		basic_machine=t90-cray
-		os=-unicos
-		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
-		;;
-	tx39)
-		basic_machine=mipstx39-unknown
-		;;
-	tx39el)
-		basic_machine=mipstx39el-unknown
-		;;
-	toad1)
-		basic_machine=pdp10-xkl
-		os=-tops20
-		;;
-	tower | tower-32)
-		basic_machine=m68k-ncr
-		;;
-	tpf)
-		basic_machine=s390x-ibm
-		os=-tpf
-		;;
-	udi29k)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	ultra3)
-		basic_machine=a29k-nyu
-		os=-sym1
-		;;
-	v810 | necv810)
-		basic_machine=v810-nec
-		os=-none
-		;;
-	vaxv)
-		basic_machine=vax-dec
-		os=-sysv
-		;;
-	vms)
-		basic_machine=vax-dec
-		os=-vms
-		;;
-	vpp*|vx|vx-*)
-		basic_machine=f301-fujitsu
-		;;
-	vxworks960)
-		basic_machine=i960-wrs
-		os=-vxworks
-		;;
-	vxworks68)
-		basic_machine=m68k-wrs
-		os=-vxworks
-		;;
-	vxworks29k)
-		basic_machine=a29k-wrs
-		os=-vxworks
-		;;
-	w65*)
-		basic_machine=w65-wdc
-		os=-none
-		;;
-	w89k-*)
-		basic_machine=hppa1.1-winbond
-		os=-proelf
-		;;
-	x64)
-		basic_machine=x86_64-pc
-		;;
-	xbox)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	xps | xps100)
-		basic_machine=xps100-honeywell
-		;;
-	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'`
-		;;
-	ymp)
-		basic_machine=ymp-cray
-		os=-unicos
-		;;
-	none)
-		basic_machine=none-none
-		os=-none
-		;;
-
-# Here we handle the default manufacturer of certain CPU types.  It is in
-# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		basic_machine=hppa1.1-winbond
-		;;
-	op50n)
-		basic_machine=hppa1.1-oki
-		;;
-	op60c)
-		basic_machine=hppa1.1-oki
-		;;
-	romp)
-		basic_machine=romp-ibm
-		;;
-	mmix)
-		basic_machine=mmix-knuth
-		;;
-	rs6000)
-		basic_machine=rs6000-ibm
-		;;
-	vax)
-		basic_machine=vax-dec
-		;;
-	pdp11)
-		basic_machine=pdp11-dec
-		;;
-	we32k)
-		basic_machine=we32k-att
-		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
-		basic_machine=sh-unknown
-		;;
-	cydra)
-		basic_machine=cydra-cydrome
-		;;
-	orion)
-		basic_machine=orion-highlevel
-		;;
-	orion105)
-		basic_machine=clipper-highlevel
-		;;
-	mac | mpw | mac-mpw)
-		basic_machine=m68k-apple
-		;;
-	pmac | pmac-mpw)
-		basic_machine=powerpc-apple
-		;;
-	*-unknown)
-		# Make sure to match an already-canonicalized machine name.
-		;;
-	*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-
-# Here we canonicalize certain aliases for manufacturers.
-case $basic_machine in
-	*-digital*)
-		basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'`
-		;;
-	*-commodore*)
-		basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'`
-		;;
-	*)
-		;;
-esac
-
-# Decode manufacturer-specific aliases for certain operating systems.
-
-if [ x"$os" != x"" ]
-then
-case $os in
-	# First match some system type aliases that might get confused
-	# with valid system types.
-	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
-		;;
-	-solaris1 | -solaris1.*)
-		os=`echo $os | sed -e 's|solaris1|sunos4|'`
-		;;
-	-solaris)
-		os=-solaris2
-		;;
-	-unixware*)
-		os=-sysv4.2uw
-		;;
-	-gnu/linux*)
-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
-		;;
-	# es1800 is here to avoid being matched by es* (a different OS)
-	-es1800*)
-		os=-ose
-		;;
-	# Now accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST end in a * to match a version number.
-	# -sysv* is not here because it comes later, after sysvr4.
-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* | -cloudabi* | -sortix* \
-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
-	      | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \
-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
-	      | -morphos* | -superux* | -rtmk* | -windiss* \
-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \
-	      | -midnightbsd*)
-	# Remember, each alternative MUST END IN *, to match a version number.
-		;;
-	-qnx*)
-		case $basic_machine in
-		    x86-* | i*86-*)
-			;;
-		    *)
-			os=-nto$os
-			;;
-		esac
-		;;
-	-nto-qnx*)
-		;;
-	-nto*)
-		os=`echo $os | sed -e 's|nto|nto-qnx|'`
-		;;
-	-sim | -xray | -os68k* | -v88r* \
-	      | -windows* | -osx | -abug | -netware* | -os9* \
-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
-		;;
-	-mac*)
-		os=`echo "$os" | sed -e 's|mac|macos|'`
-		;;
-	-linux-dietlibc)
-		os=-linux-dietlibc
-		;;
-	-linux*)
-		os=`echo $os | sed -e 's|linux|linux-gnu|'`
-		;;
-	-sunos5*)
-		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
-		;;
-	-sunos6*)
-		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
-		;;
-	-opened*)
-		os=-openedition
-		;;
-	-os400*)
-		os=-os400
-		;;
-	-wince*)
-		os=-wince
-		;;
-	-utek*)
-		os=-bsd
-		;;
-	-dynix*)
-		os=-bsd
-		;;
-	-acis*)
-		os=-aos
-		;;
-	-atheos*)
-		os=-atheos
-		;;
-	-syllable*)
-		os=-syllable
-		;;
-	-386bsd)
-		os=-bsd
-		;;
-	-ctix* | -uts*)
-		os=-sysv
-		;;
-	-nova*)
-		os=-rtmk-nova
-		;;
-	-ns2)
-		os=-nextstep2
-		;;
-	-nsk*)
-		os=-nsk
-		;;
-	# Preserve the version number of sinix5.
-	-sinix5.*)
-		os=`echo $os | sed -e 's|sinix|sysv|'`
-		;;
-	-sinix*)
-		os=-sysv4
-		;;
-	-tpf*)
-		os=-tpf
-		;;
-	-triton*)
-		os=-sysv3
-		;;
-	-oss*)
-		os=-sysv3
-		;;
-	-svr4*)
-		os=-sysv4
-		;;
-	-svr3)
-		os=-sysv3
-		;;
-	-sysvr4)
-		os=-sysv4
-		;;
-	# This must come after -sysvr4.
-	-sysv*)
-		;;
-	-ose*)
-		os=-ose
-		;;
-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-		os=-mint
-		;;
-	-zvmoe)
-		os=-zvmoe
-		;;
-	-dicos*)
-		os=-dicos
-		;;
-	-pikeos*)
-		# Until real need of OS specific support for
-		# particular features comes up, bare metal
-		# configurations are quite functional.
-		case $basic_machine in
-		    arm*)
-			os=-eabi
-			;;
-		    *)
-			os=-elf
-			;;
-		esac
-		;;
-	-nacl*)
-		;;
-	-ios)
-		;;
-	-none)
-		;;
-	*)
-		# Get rid of the `-' at the beginning of $os.
-		os=`echo $os | sed 's/[^-]*-//'`
-		echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-else
-
-# Here we handle the default operating systems that come with various machines.
-# The value should be what the vendor currently ships out the door with their
-# machine or put another way, the most popular os provided with the machine.
-
-# Note that if you're going to try to match "-MANUFACTURER" here (say,
-# "-sun"), then you have to tell the case statement up towards the top
-# that MANUFACTURER isn't an operating system.  Otherwise, code above
-# will signal an error saying that MANUFACTURER isn't an operating
-# system, and we'll never get to this point.
-
-case $basic_machine in
-	score-*)
-		os=-elf
-		;;
-	spu-*)
-		os=-elf
-		;;
-	*-acorn)
-		os=-riscix1.2
-		;;
-	arm*-rebel)
-		os=-linux
-		;;
-	arm*-semi)
-		os=-aout
-		;;
-	c4x-* | tic4x-*)
-		os=-coff
-		;;
-	c8051-*)
-		os=-elf
-		;;
-	hexagon-*)
-		os=-elf
-		;;
-	tic54x-*)
-		os=-coff
-		;;
-	tic55x-*)
-		os=-coff
-		;;
-	tic6x-*)
-		os=-coff
-		;;
-	# This must come before the *-dec entry.
-	pdp10-*)
-		os=-tops20
-		;;
-	pdp11-*)
-		os=-none
-		;;
-	*-dec | vax-*)
-		os=-ultrix4.2
-		;;
-	m68*-apollo)
-		os=-domain
-		;;
-	i386-sun)
-		os=-sunos4.0.2
-		;;
-	m68000-sun)
-		os=-sunos3
-		;;
-	m68*-cisco)
-		os=-aout
-		;;
-	mep-*)
-		os=-elf
-		;;
-	mips*-cisco)
-		os=-elf
-		;;
-	mips*-*)
-		os=-elf
-		;;
-	or32-*)
-		os=-coff
-		;;
-	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=-sysv3
-		;;
-	sparc-* | *-sun)
-		os=-sunos4.1.1
-		;;
-	pru-*)
-		os=-elf
-		;;
-	*-be)
-		os=-beos
-		;;
-	*-ibm)
-		os=-aix
-		;;
-	*-knuth)
-		os=-mmixware
-		;;
-	*-wec)
-		os=-proelf
-		;;
-	*-winbond)
-		os=-proelf
-		;;
-	*-oki)
-		os=-proelf
-		;;
-	*-hp)
-		os=-hpux
-		;;
-	*-hitachi)
-		os=-hiux
-		;;
-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=-sysv
-		;;
-	*-cbm)
-		os=-amigaos
-		;;
-	*-dg)
-		os=-dgux
-		;;
-	*-dolphin)
-		os=-sysv3
-		;;
-	m68k-ccur)
-		os=-rtu
-		;;
-	m88k-omron*)
-		os=-luna
-		;;
-	*-next)
-		os=-nextstep
-		;;
-	*-sequent)
-		os=-ptx
-		;;
-	*-crds)
-		os=-unos
-		;;
-	*-ns)
-		os=-genix
-		;;
-	i370-*)
-		os=-mvs
-		;;
-	*-gould)
-		os=-sysv
-		;;
-	*-highlevel)
-		os=-bsd
-		;;
-	*-encore)
-		os=-bsd
-		;;
-	*-sgi)
-		os=-irix
-		;;
-	*-siemens)
-		os=-sysv4
-		;;
-	*-masscomp)
-		os=-rtu
-		;;
-	f30[01]-fujitsu | f700-fujitsu)
-		os=-uxpv
-		;;
-	*-rom68k)
-		os=-coff
-		;;
-	*-*bug)
-		os=-coff
-		;;
-	*-apple)
-		os=-macos
-		;;
-	*-atari*)
-		os=-mint
-		;;
-	*)
-		os=-none
-		;;
-esac
-fi
-
-# Here we handle the case where we know the os, and the CPU type, but not the
-# manufacturer.  We pick the logical manufacturer.
-vendor=unknown
-case $basic_machine in
-	*-unknown)
-		case $os in
-			-riscix*)
-				vendor=acorn
-				;;
-			-sunos*)
-				vendor=sun
-				;;
-			-cnk*|-aix*)
-				vendor=ibm
-				;;
-			-beos*)
-				vendor=be
-				;;
-			-hpux*)
-				vendor=hp
-				;;
-			-mpeix*)
-				vendor=hp
-				;;
-			-hiux*)
-				vendor=hitachi
-				;;
-			-unos*)
-				vendor=crds
-				;;
-			-dgux*)
-				vendor=dg
-				;;
-			-luna*)
-				vendor=omron
-				;;
-			-genix*)
-				vendor=ns
-				;;
-			-mvs* | -opened*)
-				vendor=ibm
-				;;
-			-os400*)
-				vendor=ibm
-				;;
-			-ptx*)
-				vendor=sequent
-				;;
-			-tpf*)
-				vendor=ibm
-				;;
-			-vxsim* | -vxworks* | -windiss*)
-				vendor=wrs
-				;;
-			-aux*)
-				vendor=apple
-				;;
-			-hms*)
-				vendor=hitachi
-				;;
-			-mpw* | -macos*)
-				vendor=apple
-				;;
-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-				vendor=atari
-				;;
-			-vos*)
-				vendor=stratus
-				;;
-		esac
-		basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"`
-		;;
-esac
-
-echo "$basic_machine$os"
-exit
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/vendor/target-tuples/config.sub.1 b/vendor/target-tuples/config.sub.1
deleted file mode 100644
index c99f1e79..00000000
--- a/vendor/target-tuples/config.sub.1
+++ /dev/null
@@ -1,17 +0,0 @@
-.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.16.
-.TH CONFIG.SUB "1" "December 2020" "Connor Horman" "User Commands"
-.SH NAME
-config.sub \- Canonicalizes a target tuple
-.SH SYNOPSIS
-.B config.sub
-[\fI\,OPTION\/\fR]\fI\,|<target>\/\fR
-.SH DESCRIPTION
-Converts a target tuple into canonical form
-Options:
-.HP
-\fB\-\-help\fR: Prints this message, and exits
-.HP
-\fB\-\-version\fR: Prints version information, and exists
-.SH COPYRIGHT
-Copyright \(co 2020 Connor Horman, this program is a free software, dual\-licensed under the terms of the Apache v2 and the MIT license
-This program is provided AS\-IS, without any warranty.
diff --git a/vendor/target-tuples/configure b/vendor/target-tuples/configure
deleted file mode 100755
index 1ec628df..00000000
--- a/vendor/target-tuples/configure
+++ /dev/null
@@ -1,4128 +0,0 @@
-#! /bin/sh
-# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69.
-#
-#
-# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
-#
-#
-# This configure script is free software; the Free Software Foundation
-# gives unlimited permission to copy, distribute and modify it.
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-# Use a proper internal environment variable to ensure we don't fall
-  # into an infinite loop, continuously re-executing ourselves.
-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
-    _as_can_reexec=no; export _as_can_reexec;
-    # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-as_fn_exit 255
-  fi
-  # We don't want this to propagate to other subprocesses.
-          { _as_can_reexec=; unset _as_can_reexec;}
-if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-"
-  as_required="as_fn_return () { (exit \$1); }
-as_fn_success () { as_fn_return 0; }
-as_fn_failure () { as_fn_return 1; }
-as_fn_ret_success () { return 0; }
-as_fn_ret_failure () { return 1; }
-
-exitcode=0
-as_fn_success || { exitcode=1; echo as_fn_success failed.; }
-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
-
-else
-  exitcode=1; echo positional parameters were not saved.
-fi
-test x\$exitcode = x0 || exit 1
-test -x / || exit 1"
-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
-  if (eval "$as_required") 2>/dev/null; then :
-  as_have_required=yes
-else
-  as_have_required=no
-fi
-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
-
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  as_found=:
-  case $as_dir in #(
-	 /*)
-	   for as_base in sh bash ksh sh5; do
-	     # Try only shells that exist, to save several forks.
-	     as_shell=$as_dir/$as_base
-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  CONFIG_SHELL=$as_shell as_have_required=yes
-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
-  break 2
-fi
-fi
-	   done;;
-       esac
-  as_found=false
-done
-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
-  CONFIG_SHELL=$SHELL as_have_required=yes
-fi; }
-IFS=$as_save_IFS
-
-
-      if test "x$CONFIG_SHELL" != x; then :
-  export CONFIG_SHELL
-             # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-fi
-
-    if test x$as_have_required = xno; then :
-  $as_echo "$0: This script requires a shell more modern than all"
-  $as_echo "$0: the shells that I found on your system."
-  if test x${ZSH_VERSION+set} = xset ; then
-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
-  else
-    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
-$0: including any error possibly output before this
-$0: message. Then install a modern shell, or manually run
-$0: the script under such a shell if you do have one."
-  fi
-  exit 1
-fi
-fi
-fi
-SHELL=${CONFIG_SHELL-/bin/sh}
-export SHELL
-# Unset more variables known to interfere with behavior of common tools.
-CLICOLOR_FORCE= GREP_OPTIONS=
-unset CLICOLOR_FORCE GREP_OPTIONS
-
-## --------------------- ##
-## M4sh Shell Functions. ##
-## --------------------- ##
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-  as_lineno_1=$LINENO as_lineno_1a=$LINENO
-  as_lineno_2=$LINENO as_lineno_2a=$LINENO
-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
-  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
-  sed -n '
-    p
-    /[$]LINENO/=
-  ' <$as_myself |
-    sed '
-      s/[$]LINENO.*/&-/
-      t lineno
-      b
-      :lineno
-      N
-      :loop
-      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
-      t loop
-      s/-\n.*//
-    ' >$as_me.lineno &&
-  chmod +x "$as_me.lineno" ||
-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-
-  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-  # already done that, so ensure we don't try to do so again and fall
-  # in an infinite loop.  This has already happened in practice.
-  _as_can_reexec=no; export _as_can_reexec
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensitive to this).
-  . "./$as_me.lineno"
-  # Exit status is that of the last command.
-  exit
-}
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-test -n "$DJDIR" || exec 7<&0 </dev/null
-exec 6>&1
-
-# Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
-# so uname gets run too.
-ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
-
-#
-# Initializations.
-#
-ac_default_prefix=/usr/local
-ac_clean_files=
-ac_config_libobj_dir=.
-LIBOBJS=
-cross_compiling=no
-subdirs=
-MFLAGS=
-MAKEFLAGS=
-
-# Identity of this package.
-PACKAGE_NAME=
-PACKAGE_TARNAME=
-PACKAGE_VERSION=
-PACKAGE_STRING=
-PACKAGE_BUGREPORT=
-PACKAGE_URL=
-
-ac_subst_vars='LTLIBOBJS
-LIBOBJS
-detected_cfg
-RUSTFLAGS
-RUSTC
-INSTALL_DATA
-INSTALL_SCRIPT
-INSTALL_PROGRAM
-OBJEXT
-EXEEXT
-ac_ct_CC
-CPPFLAGS
-LDFLAGS
-CFLAGS
-CC
-host_os
-host_vendor
-host_cpu
-host
-build_os
-build_vendor
-build_cpu
-build
-target_alias
-host_alias
-build_alias
-LIBS
-ECHO_T
-ECHO_N
-ECHO_C
-DEFS
-mandir
-localedir
-libdir
-psdir
-pdfdir
-dvidir
-htmldir
-infodir
-docdir
-oldincludedir
-includedir
-runstatedir
-localstatedir
-sharedstatedir
-sysconfdir
-datadir
-datarootdir
-libexecdir
-sbindir
-bindir
-program_transform_name
-prefix
-exec_prefix
-PACKAGE_URL
-PACKAGE_BUGREPORT
-PACKAGE_STRING
-PACKAGE_VERSION
-PACKAGE_TARNAME
-PACKAGE_NAME
-PATH_SEPARATOR
-SHELL'
-ac_subst_files=''
-ac_user_opts='
-enable_option_checking
-'
-      ac_precious_vars='build_alias
-host_alias
-target_alias
-CC
-CFLAGS
-LDFLAGS
-LIBS
-CPPFLAGS
-RUSTC
-RUSTFLAGS'
-
-
-# Initialize some variables set by options.
-ac_init_help=
-ac_init_version=false
-ac_unrecognized_opts=
-ac_unrecognized_sep=
-# The variables have the same names as the options, with
-# dashes changed to underlines.
-cache_file=/dev/null
-exec_prefix=NONE
-no_create=
-no_recursion=
-prefix=NONE
-program_prefix=NONE
-program_suffix=NONE
-program_transform_name=s,x,x,
-silent=
-site=
-srcdir=
-verbose=
-x_includes=NONE
-x_libraries=NONE
-
-# Installation directory options.
-# These are left unexpanded so users can "make install exec_prefix=/foo"
-# and all the variables that are supposed to be based on exec_prefix
-# by default will actually change.
-# Use braces instead of parens because sh, perl, etc. also accept them.
-# (The list follows the same order as the GNU Coding Standards.)
-bindir='${exec_prefix}/bin'
-sbindir='${exec_prefix}/sbin'
-libexecdir='${exec_prefix}/libexec'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}'
-sysconfdir='${prefix}/etc'
-sharedstatedir='${prefix}/com'
-localstatedir='${prefix}/var'
-runstatedir='${localstatedir}/run'
-includedir='${prefix}/include'
-oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE}'
-infodir='${datarootdir}/info'
-htmldir='${docdir}'
-dvidir='${docdir}'
-pdfdir='${docdir}'
-psdir='${docdir}'
-libdir='${exec_prefix}/lib'
-localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
-ac_prev=
-ac_dashdash=
-for ac_option
-do
-  # If the previous option needs an argument, assign it.
-  if test -n "$ac_prev"; then
-    eval $ac_prev=\$ac_option
-    ac_prev=
-    continue
-  fi
-
-  case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
-  esac
-
-  # Accept the important Cygnus configure options, so we can diagnose typos.
-
-  case $ac_dashdash$ac_option in
-  --)
-    ac_dashdash=yes ;;
-
-  -bindir | --bindir | --bindi | --bind | --bin | --bi)
-    ac_prev=bindir ;;
-  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
-    bindir=$ac_optarg ;;
-
-  -build | --build | --buil | --bui | --bu)
-    ac_prev=build_alias ;;
-  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
-    build_alias=$ac_optarg ;;
-
-  -cache-file | --cache-file | --cache-fil | --cache-fi \
-  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
-    ac_prev=cache_file ;;
-  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
-  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
-    cache_file=$ac_optarg ;;
-
-  --config-cache | -C)
-    cache_file=config.cache ;;
-
-  -datadir | --datadir | --datadi | --datad)
-    ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=*)
-    datadir=$ac_optarg ;;
-
-  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
-  | --dataroo | --dataro | --datar)
-    ac_prev=datarootdir ;;
-  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
-  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
-    datarootdir=$ac_optarg ;;
-
-  -disable-* | --disable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=no ;;
-
-  -docdir | --docdir | --docdi | --doc | --do)
-    ac_prev=docdir ;;
-  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
-    docdir=$ac_optarg ;;
-
-  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
-    ac_prev=dvidir ;;
-  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
-    dvidir=$ac_optarg ;;
-
-  -enable-* | --enable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=\$ac_optarg ;;
-
-  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
-  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
-  | --exec | --exe | --ex)
-    ac_prev=exec_prefix ;;
-  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
-  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
-  | --exec=* | --exe=* | --ex=*)
-    exec_prefix=$ac_optarg ;;
-
-  -gas | --gas | --ga | --g)
-    # Obsolete; use --with-gas.
-    with_gas=yes ;;
-
-  -help | --help | --hel | --he | -h)
-    ac_init_help=long ;;
-  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
-    ac_init_help=recursive ;;
-  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
-    ac_init_help=short ;;
-
-  -host | --host | --hos | --ho)
-    ac_prev=host_alias ;;
-  -host=* | --host=* | --hos=* | --ho=*)
-    host_alias=$ac_optarg ;;
-
-  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
-    ac_prev=htmldir ;;
-  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
-  | --ht=*)
-    htmldir=$ac_optarg ;;
-
-  -includedir | --includedir | --includedi | --included | --include \
-  | --includ | --inclu | --incl | --inc)
-    ac_prev=includedir ;;
-  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
-  | --includ=* | --inclu=* | --incl=* | --inc=*)
-    includedir=$ac_optarg ;;
-
-  -infodir | --infodir | --infodi | --infod | --info | --inf)
-    ac_prev=infodir ;;
-  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
-    infodir=$ac_optarg ;;
-
-  -libdir | --libdir | --libdi | --libd)
-    ac_prev=libdir ;;
-  -libdir=* | --libdir=* | --libdi=* | --libd=*)
-    libdir=$ac_optarg ;;
-
-  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
-  | --libexe | --libex | --libe)
-    ac_prev=libexecdir ;;
-  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
-  | --libexe=* | --libex=* | --libe=*)
-    libexecdir=$ac_optarg ;;
-
-  -localedir | --localedir | --localedi | --localed | --locale)
-    ac_prev=localedir ;;
-  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
-    localedir=$ac_optarg ;;
-
-  -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst | --locals)
-    ac_prev=localstatedir ;;
-  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
-    localstatedir=$ac_optarg ;;
-
-  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
-    ac_prev=mandir ;;
-  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
-    mandir=$ac_optarg ;;
-
-  -nfp | --nfp | --nf)
-    # Obsolete; use --without-fp.
-    with_fp=no ;;
-
-  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c | -n)
-    no_create=yes ;;
-
-  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
-    no_recursion=yes ;;
-
-  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
-  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
-  | --oldin | --oldi | --old | --ol | --o)
-    ac_prev=oldincludedir ;;
-  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
-  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
-  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
-    oldincludedir=$ac_optarg ;;
-
-  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
-    ac_prev=prefix ;;
-  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
-    prefix=$ac_optarg ;;
-
-  -program-prefix | --program-prefix | --program-prefi | --program-pref \
-  | --program-pre | --program-pr | --program-p)
-    ac_prev=program_prefix ;;
-  -program-prefix=* | --program-prefix=* | --program-prefi=* \
-  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
-    program_prefix=$ac_optarg ;;
-
-  -program-suffix | --program-suffix | --program-suffi | --program-suff \
-  | --program-suf | --program-su | --program-s)
-    ac_prev=program_suffix ;;
-  -program-suffix=* | --program-suffix=* | --program-suffi=* \
-  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
-    program_suffix=$ac_optarg ;;
-
-  -program-transform-name | --program-transform-name \
-  | --program-transform-nam | --program-transform-na \
-  | --program-transform-n | --program-transform- \
-  | --program-transform | --program-transfor \
-  | --program-transfo | --program-transf \
-  | --program-trans | --program-tran \
-  | --progr-tra | --program-tr | --program-t)
-    ac_prev=program_transform_name ;;
-  -program-transform-name=* | --program-transform-name=* \
-  | --program-transform-nam=* | --program-transform-na=* \
-  | --program-transform-n=* | --program-transform-=* \
-  | --program-transform=* | --program-transfor=* \
-  | --program-transfo=* | --program-transf=* \
-  | --program-trans=* | --program-tran=* \
-  | --progr-tra=* | --program-tr=* | --program-t=*)
-    program_transform_name=$ac_optarg ;;
-
-  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
-    ac_prev=pdfdir ;;
-  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
-    pdfdir=$ac_optarg ;;
-
-  -psdir | --psdir | --psdi | --psd | --ps)
-    ac_prev=psdir ;;
-  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
-    psdir=$ac_optarg ;;
-
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil)
-    silent=yes ;;
-
-  -runstatedir | --runstatedir | --runstatedi | --runstated \
-  | --runstate | --runstat | --runsta | --runst | --runs \
-  | --run | --ru | --r)
-    ac_prev=runstatedir ;;
-  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-  | --run=* | --ru=* | --r=*)
-    runstatedir=$ac_optarg ;;
-
-  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-    ac_prev=sbindir ;;
-  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-  | --sbi=* | --sb=*)
-    sbindir=$ac_optarg ;;
-
-  -sharedstatedir | --sharedstatedir | --sharedstatedi \
-  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
-  | --sharedst | --shareds | --shared | --share | --shar \
-  | --sha | --sh)
-    ac_prev=sharedstatedir ;;
-  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
-  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
-  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
-  | --sha=* | --sh=*)
-    sharedstatedir=$ac_optarg ;;
-
-  -site | --site | --sit)
-    ac_prev=site ;;
-  -site=* | --site=* | --sit=*)
-    site=$ac_optarg ;;
-
-  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
-    ac_prev=srcdir ;;
-  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
-    srcdir=$ac_optarg ;;
-
-  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
-  | --syscon | --sysco | --sysc | --sys | --sy)
-    ac_prev=sysconfdir ;;
-  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
-  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
-    sysconfdir=$ac_optarg ;;
-
-  -target | --target | --targe | --targ | --tar | --ta | --t)
-    ac_prev=target_alias ;;
-  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
-    target_alias=$ac_optarg ;;
-
-  -v | -verbose | --verbose | --verbos | --verbo | --verb)
-    verbose=yes ;;
-
-  -version | --version | --versio | --versi | --vers | -V)
-    ac_init_version=: ;;
-
-  -with-* | --with-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=\$ac_optarg ;;
-
-  -without-* | --without-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=no ;;
-
-  --x)
-    # Obsolete; use --with-x.
-    with_x=yes ;;
-
-  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
-  | --x-incl | --x-inc | --x-in | --x-i)
-    ac_prev=x_includes ;;
-  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
-  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
-    x_includes=$ac_optarg ;;
-
-  -x-libraries | --x-libraries | --x-librarie | --x-librari \
-  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
-    ac_prev=x_libraries ;;
-  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
-  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-    x_libraries=$ac_optarg ;;
-
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
-    ;;
-
-  *=*)
-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
-    # Reject names that are not valid shell variable names.
-    case $ac_envvar in #(
-      '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-    esac
-    eval $ac_envvar=\$ac_optarg
-    export $ac_envvar ;;
-
-  *)
-    # FIXME: should be removed in autoconf 3.0.
-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-    ;;
-
-  esac
-done
-
-if test -n "$ac_prev"; then
-  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
-fi
-
-if test -n "$ac_unrecognized_opts"; then
-  case $enable_option_checking in
-    no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-  esac
-fi
-
-# Check all directory arguments for consistency.
-for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
-		datadir sysconfdir sharedstatedir localstatedir includedir \
-		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir runstatedir
-do
-  eval ac_val=\$$ac_var
-  # Remove trailing slashes.
-  case $ac_val in
-    */ )
-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
-      eval $ac_var=\$ac_val;;
-  esac
-  # Be sure to have absolute directory names.
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* )  continue;;
-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
-  esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
-done
-
-# There might be people who depend on the old broken behavior: `$host'
-# used to hold the argument of --host etc.
-# FIXME: To remove some day.
-build=$build_alias
-host=$host_alias
-target=$target_alias
-
-# FIXME: To remove some day.
-if test "x$host_alias" != x; then
-  if test "x$build_alias" = x; then
-    cross_compiling=maybe
-  elif test "x$build_alias" != "x$host_alias"; then
-    cross_compiling=yes
-  fi
-fi
-
-ac_tool_prefix=
-test -n "$host_alias" && ac_tool_prefix=$host_alias-
-
-test "$silent" = yes && exec 6>/dev/null
-
-
-ac_pwd=`pwd` && test -n "$ac_pwd" &&
-ac_ls_di=`ls -di .` &&
-ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
-
-
-# Find the source files, if location was not specified.
-if test -z "$srcdir"; then
-  ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then the parent directory.
-  ac_confdir=`$as_dirname -- "$as_myself" ||
-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_myself" : 'X\(//\)[^/]' \| \
-	 X"$as_myself" : 'X\(//\)$' \| \
-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_myself" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  srcdir=$ac_confdir
-  if test ! -r "$srcdir/$ac_unique_file"; then
-    srcdir=..
-  fi
-else
-  ac_srcdir_defaulted=no
-fi
-if test ! -r "$srcdir/$ac_unique_file"; then
-  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
-fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-ac_abs_confdir=`(
-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
-	pwd)`
-# When building in place, set srcdir=.
-if test "$ac_abs_confdir" = "$ac_pwd"; then
-  srcdir=.
-fi
-# Remove unnecessary trailing slashes from srcdir.
-# Double slashes in file names in object file debugging info
-# mess up M-x gdb in Emacs.
-case $srcdir in
-*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
-esac
-for ac_var in $ac_precious_vars; do
-  eval ac_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_env_${ac_var}_value=\$${ac_var}
-  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_cv_env_${ac_var}_value=\$${ac_var}
-done
-
-#
-# Report the --help message.
-#
-if test "$ac_init_help" = "long"; then
-  # Omit some internal or obsolete options to make the list less imposing.
-  # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<_ACEOF
-\`configure' configures this package to adapt to many kinds of systems.
-
-Usage: $0 [OPTION]... [VAR=VALUE]...
-
-To assign environment variables (e.g., CC, CFLAGS...), specify them as
-VAR=VALUE.  See below for descriptions of some of the useful variables.
-
-Defaults for the options are specified in brackets.
-
-Configuration:
-  -h, --help              display this help and exit
-      --help=short        display options specific to this package
-      --help=recursive    display the short help of all the included packages
-  -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
-      --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
-  -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-
-Installation directories:
-  --prefix=PREFIX         install architecture-independent files in PREFIX
-                          [$ac_default_prefix]
-  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                          [PREFIX]
-
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
-
-For better control, use the options below.
-
-Fine tuning of the installation directories:
-  --bindir=DIR            user executables [EPREFIX/bin]
-  --sbindir=DIR           system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR        program executables [EPREFIX/libexec]
-  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-  --libdir=DIR            object code libraries [EPREFIX/lib]
-  --includedir=DIR        C header files [PREFIX/include]
-  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
-  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
-  --infodir=DIR           info documentation [DATAROOTDIR/info]
-  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
-  --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
-  --htmldir=DIR           html documentation [DOCDIR]
-  --dvidir=DIR            dvi documentation [DOCDIR]
-  --pdfdir=DIR            pdf documentation [DOCDIR]
-  --psdir=DIR             ps documentation [DOCDIR]
-_ACEOF
-
-  cat <<\_ACEOF
-
-System types:
-  --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
-_ACEOF
-fi
-
-if test -n "$ac_init_help"; then
-
-  cat <<\_ACEOF
-
-Some influential environment variables:
-  CC          C compiler command
-  CFLAGS      C compiler flags
-  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
-              nonstandard directory <lib dir>
-  LIBS        libraries to pass to the linker, e.g. -l<library>
-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
-              you have headers in a nonstandard directory <include dir>
-  RUSTC       Rust compiler to use
-  RUSTFLAGS   Flags to pass to the rust compiler
-
-Use these variables to override the choices made by `configure' or to help
-it to find libraries and programs with nonstandard names/locations.
-
-Report bugs to the package provider.
-_ACEOF
-ac_status=$?
-fi
-
-if test "$ac_init_help" = "recursive"; then
-  # If there are subdirs, report their specific --help.
-  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d "$ac_dir" ||
-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
-      continue
-    ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-    cd "$ac_dir" || { ac_status=$?; continue; }
-    # Check for guested configure.
-    if test -f "$ac_srcdir/configure.gnu"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-    elif test -f "$ac_srcdir/configure"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure" --help=recursive
-    else
-      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi || ac_status=$?
-    cd "$ac_pwd" || { ac_status=$?; break; }
-  done
-fi
-
-test -n "$ac_init_help" && exit $ac_status
-if $ac_init_version; then
-  cat <<\_ACEOF
-configure
-generated by GNU Autoconf 2.69
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This configure script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it.
-_ACEOF
-  exit
-fi
-
-## ------------------------ ##
-## Autoconf initialization. ##
-## ------------------------ ##
-
-# ac_fn_c_try_compile LINENO
-# --------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_compile
-cat >config.log <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  $ $0 $@
-
-_ACEOF
-exec 5>>config.log
-{
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
-
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
-
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
-
-_ASUNAME
-
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    $as_echo "PATH: $as_dir"
-  done
-IFS=$as_save_IFS
-
-} >&5
-
-cat >&5 <<_ACEOF
-
-
-## ----------- ##
-## Core tests. ##
-## ----------- ##
-
-_ACEOF
-
-
-# Keep a trace of the command line.
-# Strip out --no-create and --no-recursion so they do not pile up.
-# Strip out --silent because we don't want to record it for future runs.
-# Also quote any args containing shell meta-characters.
-# Make two passes to allow for proper duplicate-argument suppression.
-ac_configure_args=
-ac_configure_args0=
-ac_configure_args1=
-ac_must_keep_next=false
-for ac_pass in 1 2
-do
-  for ac_arg
-  do
-    case $ac_arg in
-    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-    | -silent | --silent | --silen | --sile | --sil)
-      continue ;;
-    *\'*)
-      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    case $ac_pass in
-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-    2)
-      as_fn_append ac_configure_args1 " '$ac_arg'"
-      if test $ac_must_keep_next = true; then
-	ac_must_keep_next=false # Got value, back to normal.
-      else
-	case $ac_arg in
-	  *=* | --config-cache | -C | -disable-* | --disable-* \
-	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
-	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
-	  | -with-* | --with-* | -without-* | --without-* | --x)
-	    case "$ac_configure_args0 " in
-	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
-	    esac
-	    ;;
-	  -* ) ac_must_keep_next=true ;;
-	esac
-      fi
-      as_fn_append ac_configure_args " '$ac_arg'"
-      ;;
-    esac
-  done
-done
-{ ac_configure_args0=; unset ac_configure_args0;}
-{ ac_configure_args1=; unset ac_configure_args1;}
-
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log.  We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
-  # Save into config.log some information that might help in debugging.
-  {
-    echo
-
-    $as_echo "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
-    echo
-    # The following way of writing the cache mishandles newlines in values,
-(
-  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-  (set) 2>&1 |
-    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      sed -n \
-	"s/'\''/'\''\\\\'\'''\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
-      ;; #(
-    *)
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-)
-    echo
-
-    $as_echo "## ----------------- ##
-## Output variables. ##
-## ----------------- ##"
-    echo
-    for ac_var in $ac_subst_vars
-    do
-      eval ac_val=\$$ac_var
-      case $ac_val in
-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-      esac
-      $as_echo "$ac_var='\''$ac_val'\''"
-    done | sort
-    echo
-
-    if test -n "$ac_subst_files"; then
-      $as_echo "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
-      echo
-      for ac_var in $ac_subst_files
-      do
-	eval ac_val=\$$ac_var
-	case $ac_val in
-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-	esac
-	$as_echo "$ac_var='\''$ac_val'\''"
-      done | sort
-      echo
-    fi
-
-    if test -s confdefs.h; then
-      $as_echo "## ----------- ##
-## confdefs.h. ##
-## ----------- ##"
-      echo
-      cat confdefs.h
-      echo
-    fi
-    test "$ac_signal" != 0 &&
-      $as_echo "$as_me: caught signal $ac_signal"
-    $as_echo "$as_me: exit $exit_status"
-  } >&5
-  rm -f core *.core core.conftest.* &&
-    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-    exit $exit_status
-' 0
-for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
-done
-ac_signal=0
-
-# confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -f -r conftest* confdefs.h
-
-$as_echo "/* confdefs.h */" > confdefs.h
-
-# Predefined preprocessor variables.
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_NAME "$PACKAGE_NAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_VERSION "$PACKAGE_VERSION"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_STRING "$PACKAGE_STRING"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
-_ACEOF
-
-cat >>confdefs.h <<_ACEOF
-#define PACKAGE_URL "$PACKAGE_URL"
-_ACEOF
-
-
-# Let the site file select an alternate cache file if it wants to.
-# Prefer an explicitly selected file to automatically selected ones.
-ac_site_file1=NONE
-ac_site_file2=NONE
-if test -n "$CONFIG_SITE"; then
-  # We do not want a PATH search for config.site.
-  case $CONFIG_SITE in #((
-    -*)  ac_site_file1=./$CONFIG_SITE;;
-    */*) ac_site_file1=$CONFIG_SITE;;
-    *)   ac_site_file1=./$CONFIG_SITE;;
-  esac
-elif test "x$prefix" != xNONE; then
-  ac_site_file1=$prefix/share/config.site
-  ac_site_file2=$prefix/etc/config.site
-else
-  ac_site_file1=$ac_default_prefix/share/config.site
-  ac_site_file2=$ac_default_prefix/etc/config.site
-fi
-for ac_site_file in "$ac_site_file1" "$ac_site_file2"
-do
-  test "x$ac_site_file" = xNONE && continue
-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-$as_echo "$as_me: loading site script $ac_site_file" >&6;}
-    sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-done
-
-if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special files
-  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-$as_echo "$as_me: loading cache $cache_file" >&6;}
-    case $cache_file in
-      [\\/]* | ?:[\\/]* ) . "$cache_file";;
-      *)                      . "./$cache_file";;
-    esac
-  fi
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-$as_echo "$as_me: creating cache $cache_file" >&6;}
-  >$cache_file
-fi
-
-# Check that the precious variables saved in the cache have kept the same
-# value.
-ac_cache_corrupted=false
-for ac_var in $ac_precious_vars; do
-  eval ac_old_set=\$ac_cv_env_${ac_var}_set
-  eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val=\$ac_cv_env_${ac_var}_value
-  eval ac_new_val=\$ac_env_${ac_var}_value
-  case $ac_old_set,$ac_new_set in
-    set,)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,set)
-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,);;
-    *)
-      if test "x$ac_old_val" != "x$ac_new_val"; then
-	# differences in whitespace do not lead to failure.
-	ac_old_val_w=`echo x $ac_old_val`
-	ac_new_val_w=`echo x $ac_new_val`
-	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	  ac_cache_corrupted=:
-	else
-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-	  eval $ac_var=\$ac_old_val
-	fi
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-      fi;;
-  esac
-  # Pass precious variables to config.status.
-  if test "$ac_new_set" = set; then
-    case $ac_new_val in
-    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-    *) ac_arg=$ac_var=$ac_new_val ;;
-    esac
-    case " $ac_configure_args " in
-      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
-    esac
-  fi
-done
-if $ac_cache_corrupted; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
-fi
-## -------------------- ##
-## Main body of script. ##
-## -------------------- ##
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-
-ac_aux_dir=
-for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
-  if test -f "$ac_dir/install-sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install-sh -c"
-    break
-  elif test -f "$ac_dir/install.sh"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/install.sh -c"
-    break
-  elif test -f "$ac_dir/shtool"; then
-    ac_aux_dir=$ac_dir
-    ac_install_sh="$ac_aux_dir/shtool install -c"
-    break
-  fi
-done
-if test -z "$ac_aux_dir"; then
-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
-fi
-
-# These three variables are undocumented and unsupported,
-# and are intended to be withdrawn in a future Autoconf release.
-# They can cause serious problems if a builder's source tree is in a directory
-# whose full name contains unusual characters.
-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
-
-
-# Make sure we can run config.sub.
-$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
-  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
-$as_echo_n "checking build system type... " >&6; }
-if ${ac_cv_build+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_build_alias=$build_alias
-test "x$ac_build_alias" = x &&
-  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
-test "x$ac_build_alias" = x &&
-  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
-ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
-  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-$as_echo "$ac_cv_build" >&6; }
-case $ac_cv_build in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
-esac
-build=$ac_cv_build
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_build
-shift
-build_cpu=$1
-build_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-build_os=$*
-IFS=$ac_save_IFS
-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
-$as_echo_n "checking host system type... " >&6; }
-if ${ac_cv_host+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test "x$host_alias" = x; then
-  ac_cv_host=$ac_cv_build
-else
-  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-$as_echo "$ac_cv_host" >&6; }
-case $ac_cv_host in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
-esac
-host=$ac_cv_host
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_host
-shift
-host_cpu=$1
-host_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-host_os=$*
-IFS=$ac_save_IFS
-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
-
-
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-$as_echo "$CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_ac_ct_CC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-$as_echo "$ac_ct_CC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-
-
-test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
-# Try to create an executable without -o first, disregard a.out.
-# It will help us diagnose broken compilers, and finding out an intuition
-# of exeext.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-$as_echo_n "checking whether the C compiler works... " >&6; }
-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-
-# The possible output files:
-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-
-ac_rmfiles=
-for ac_file in $ac_files
-do
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
-  esac
-done
-rm -f $ac_rmfiles
-
-if { { ac_try="$ac_link_default"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link_default") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-# in a Makefile.  We should not override ac_cv_exeext if it was cached,
-# so that the user can short-circuit this test for compilers unknown to
-# Autoconf.
-for ac_file in $ac_files ''
-do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
-	;;
-    [ab].out )
-	# We found the default executable, but exeext='' is most
-	# certainly right.
-	break;;
-    *.* )
-	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
-	then :; else
-	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	fi
-	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
-	# argument, so we may need to know it at that point already.
-	# Even if this section looks crufty: it has the advantage of
-	# actually working.
-	break;;
-    * )
-	break;;
-  esac
-done
-test "$ac_cv_exeext" = no && ac_cv_exeext=
-
-else
-  ac_file=''
-fi
-if test -z "$ac_file"; then :
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-$as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-$as_echo_n "checking for C compiler default output file name... " >&6; }
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-$as_echo "$ac_file" >&6; }
-ac_exeext=$ac_cv_exeext
-
-rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-$as_echo_n "checking for suffix of executables... " >&6; }
-if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
-for ac_file in conftest.exe conftest conftest.*; do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  break;;
-    * ) break;;
-  esac
-done
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest conftest$ac_cv_exeext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-$as_echo "$ac_cv_exeext" >&6; }
-
-rm -f conftest.$ac_ext
-EXEEXT=$ac_cv_exeext
-ac_exeext=$EXEEXT
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdio.h>
-int
-main ()
-{
-FILE *f = fopen ("conftest.out", "w");
- return ferror (f) || fclose (f) != 0;
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files="$ac_clean_files conftest.out"
-# Check that the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-$as_echo_n "checking whether we are cross compiling... " >&6; }
-if test "$cross_compiling" != yes; then
-  { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-  if { ac_try='./conftest$ac_cv_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
-    fi
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-$as_echo "$cross_compiling" >&6; }
-
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-ac_clean_files=$ac_clean_files_save
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-$as_echo_n "checking for suffix of object files... " >&6; }
-if ${ac_cv_objext+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.o conftest.obj
-if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then :
-  for ac_file in conftest.o conftest.obj conftest.*; do
-  test -f "$ac_file" || continue;
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
-       break;;
-  esac
-done
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-$as_echo "$ac_cv_objext" >&6; }
-OBJEXT=$ac_cv_objext
-ac_objext=$OBJEXT
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
-if ${ac_cv_c_compiler_gnu+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_compiler_gnu=yes
-else
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-$as_echo "$ac_cv_c_compiler_gnu" >&6; }
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+set}
-ac_save_CFLAGS=$CFLAGS
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-$as_echo_n "checking whether $CC accepts -g... " >&6; }
-if ${ac_cv_prog_cc_g+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-else
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-
-else
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-$as_echo "$ac_cv_prog_cc_g" >&6; }
-if test "$ac_test_CFLAGS" = set; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
-if ${ac_cv_prog_cc_c89+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdarg.h>
-#include <stdio.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;
-int
-main ()
-{
-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
-  ;
-  return 0;
-}
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"; then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-
-fi
-# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_c89" in
-  x)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-$as_echo "none needed" >&6; } ;;
-  xno)
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-$as_echo "unsupported" >&6; } ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_c89"
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-esac
-if test "x$ac_cv_prog_cc_c89" != xno; then :
-
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-# Find a good install program.  We prefer a C program (faster),
-# so one script is as good as another.  But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-$as_echo_n "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if ${ac_cv_path_install+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    # Account for people who put trailing slashes in PATH elements.
-case $as_dir/ in #((
-  ./ | .// | /[cC]/* | \
-  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
-  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
-  /usr/ucb/* ) ;;
-  *)
-    # OSF1 and SCO ODT 3.0 have their own names for install.
-    # Don't use installbsd from OSF since it installs stuff as root
-    # by default.
-    for ac_prog in ginstall scoinst install; do
-      for ac_exec_ext in '' $ac_executable_extensions; do
-	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
-	  if test $ac_prog = install &&
-	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    rm -rf conftest.one conftest.two conftest.dir
-	    echo one > conftest.one
-	    echo two > conftest.two
-	    mkdir conftest.dir
-	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
-	      test -s conftest.one && test -s conftest.two &&
-	      test -s conftest.dir/conftest.one &&
-	      test -s conftest.dir/conftest.two
-	    then
-	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
-	      break 3
-	    fi
-	  fi
-	fi
-      done
-    done
-    ;;
-esac
-
-  done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
-  if test "${ac_cv_path_install+set}" = set; then
-    INSTALL=$ac_cv_path_install
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for INSTALL within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    INSTALL=$ac_install_sh
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-$as_echo "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-
-
-
-
-
-
-
-    if test "$RUSTFLAGS" \= ""
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x
-    then
-        for ac_prog in rustc lcrustc $host-gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    else
-        for ac_prog in rustc lcrustc $host-gccrs gccrs
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_path_RUSTC+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  case $RUSTC in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_RUSTC="$RUSTC" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_RUSTC="$as_dir/$ac_word$ac_exec_ext"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-RUSTC=$ac_cv_path_RUSTC
-if test -n "$RUSTC"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RUSTC" >&5
-$as_echo "$RUSTC" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-  test -n "$RUSTC" && break
-done
-
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        as_fn_error $? "Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler" "$LINENO" 5
-    fi
-
-    if test x$host_alias != x
-    then
-        case $RUSTC in
-            *\\/$host-* )                 ;;
-            * )
-                SAVE_RUSTFLAGS="$RUSTFLAGS"
-                { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to cross compile with $RUSTC" >&5
-$as_echo_n "checking how to cross compile with $RUSTC... " >&6; }
-                RUSTFLAGS="$RUSTFLAGS --target $host"
-                echo '' > test.rs
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs 2>> config.log > /dev/null
-
-                if test $? -eq 0
-                then
-                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host" >&5
-$as_echo "--target $host" >&6; }
-                else
-                    rm -f test.rs libtest.rlib
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_alias"
-                    echo '' > test.rs
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                    if test $? -eq 0
-                    then
-                        rm -f test.rs libtest.rlib
-                        { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_alias" >&5
-$as_echo "--target $host_alias" >&6; }
-                    else
-                        rm -f test.rs libtest.rlib
-                        case "$host" in
-                            x86_64-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_target" >&5
-$as_echo "--target $host_target" >&6; }
-                                else
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                    as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                fi
-                            ;;
-
-                            i?86-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: --target $host_target" >&5
-$as_echo "--target $host_target" >&6; }
-                                else
-                                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                    as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                fi
-                            ;;
-
-                            *)
-                                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-$as_echo "failed" >&6; }
-                                as_fn_error $? "Cannot determine how to cross compile to $host with $RUSTC" "$LINENO" 5
-                                ;;
-                        esac
-                    fi
-                fi
-                ;;
-        esac
-    fi
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Rust compiler works" >&5
-$as_echo_n "checking whether Rust compiler works... " >&6; }
-    echo 'fn main(){}' > test.rs
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-        as_fn_error $? "Cannot compile a simple program with $RUSTC" "$LINENO" 5
-    fi
-
-    if test x$host_alias != x
-    then
-        ./test${EXEEXT}
-        if test $? -ne 0
-        then
-            { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-            as_fn_error $? "Cannot run executables compiled by $RUSTC" "$LINENO" 5
-        fi
-    fi
-
-    rm -rf test.rs test${EXEEXT}
-
-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-
-
-
-
-
-
-ac_config_files="$ac_config_files Makefile"
-
-
-cat >confcache <<\_ACEOF
-# This file is a shell script that caches the results of configure
-# tests run on this system so they can be shared between configure
-# scripts and configure runs, see configure's option --config-cache.
-# It is not useful on other systems.  If it contains results you don't
-# want to keep, you may remove or edit it.
-#
-# config.status only pays attention to the cache file if you give it
-# the --recheck option to rerun configure.
-#
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
-# following values.
-
-_ACEOF
-
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
-  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-
-  (set) 2>&1 |
-    case $as_nl`(ac_space=' '; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \.
-      sed -n \
-	"s/'/'\\\\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;; #(
-    *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-) |
-  sed '
-     /^ac_cv_env_/b end
-     t clear
-     :clear
-     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
-     t end
-     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     :end' >>confcache
-if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-  if test -w "$cache_file"; then
-    if test "x$cache_file" != "x/dev/null"; then
-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-$as_echo "$as_me: updating cache $cache_file" >&6;}
-      if test ! -f "$cache_file" || test -h "$cache_file"; then
-	cat confcache >"$cache_file"
-      else
-        case $cache_file in #(
-        */* | ?:*)
-	  mv -f confcache "$cache_file"$$ &&
-	  mv -f "$cache_file"$$ "$cache_file" ;; #(
-        *)
-	  mv -f confcache "$cache_file" ;;
-	esac
-      fi
-    fi
-  else
-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
-  fi
-fi
-rm -f confcache
-
-test "x$prefix" = xNONE && prefix=$ac_default_prefix
-# Let make expand exec_prefix.
-test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
-
-# Transform confdefs.h into DEFS.
-# Protect against shell expansion while executing Makefile rules.
-# Protect against Makefile macro expansion.
-#
-# If the first sed substitution is executed (which looks for macros that
-# take arguments), then branch to the quote section.  Otherwise,
-# look for a macro that doesn't take arguments.
-ac_script='
-:mline
-/\\$/{
- N
- s,\\\n,,
- b mline
-}
-t clear
-:clear
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
-t quote
-b any
-:quote
-s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
-s/\[/\\&/g
-s/\]/\\&/g
-s/\$/$$/g
-H
-:any
-${
-	g
-	s/^\n//
-	s/\n/ /g
-	p
-}
-'
-DEFS=`sed -n "$ac_script" confdefs.h`
-
-
-ac_libobjs=
-ac_ltlibobjs=
-U=
-for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-  # 1. Remove the extension, and $U if already installed.
-  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
-  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
-  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-  #    will be set to the directory where LIBOBJS objects are built.
-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
-done
-LIBOBJS=$ac_libobjs
-
-LTLIBOBJS=$ac_ltlibobjs
-
-
-
-: "${CONFIG_STATUS=./config.status}"
-ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
-as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-# Run this file to recreate the current configuration.
-# Compiler output produced by configure, useful for debugging
-# configure, is in config.log if it exists.
-
-debug=false
-ac_cs_recheck=false
-ac_cs_silent=false
-
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-as_nl='
-'
-export as_nl
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='print -r --'
-  as_echo_n='print -rn --'
-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
-  as_echo='printf %s\n'
-  as_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
-    as_echo_n='/usr/ucb/echo -n'
-  else
-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
-    as_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$as_nl"*)
-	expr "X$arg" : "X\\(.*\\)$as_nl";
-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
-      esac;
-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
-    '
-    export as_echo_n_body
-    as_echo_n='sh -c $as_echo_n_body as_echo'
-  fi
-  export as_echo_body
-  as_echo='sh -c $as_echo_body as_echo'
-fi
-
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# IFS
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent editors from complaining about space-tab.
-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
-# splitting by setting IFS to empty value.)
-IFS=" ""	$as_nl"
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-# Unset variables that we do not need and which cause bugs (e.g. in
-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
-# suppresses any "Segmentation fault" message there.  '((' could
-# trigger a bug in pdksh 5.2.14.
-for as_var in BASH_ENV ENV MAIL MAILPATH
-do eval test x\${$as_var+set} = xset \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# NLS nuisances.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  $as_echo "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
-_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# Save the log message, to keep $0 and so on meaningful, and to
-# report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.
-ac_log="
-This file was extended by $as_me, which was
-generated by GNU Autoconf 2.69.  Invocation command line was
-
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  $ $0 $@
-
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
-"
-
-_ACEOF
-
-case $ac_config_files in *"
-"*) set x $ac_config_files; shift; ac_config_files=$*;;
-esac
-
-
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-# Files that config.status was made for.
-config_files="$ac_config_files"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
-from templates according to the current configuration.  Unless the files
-and actions are specified as TAGs, all are instantiated by default.
-
-Usage: $0 [OPTION]... [TAG]...
-
-  -h, --help       print this help, then exit
-  -V, --version    print version number and configuration settings, then exit
-      --config     print configuration, then exit
-  -q, --quiet, --silent
-                   do not print progress messages
-  -d, --debug      don't remove temporary files
-      --recheck    update $as_me by reconfiguring in the same conditions
-      --file=FILE[:TEMPLATE]
-                   instantiate the configuration file FILE
-
-Configuration files:
-$config_files
-
-Report bugs to the package provider."
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
-ac_cs_version="\\
-config.status
-configured by $0, generated by GNU Autoconf 2.69,
-  with options \\"\$ac_cs_config\\"
-
-Copyright (C) 2012 Free Software Foundation, Inc.
-This config.status script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it."
-
-ac_pwd='$ac_pwd'
-srcdir='$srcdir'
-INSTALL='$INSTALL'
-test -n "\$AWK" || AWK=awk
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# The default lists apply if the user does not specify any file.
-ac_need_defaults=:
-while test $# != 0
-do
-  case $1 in
-  --*=?*)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
-    ac_shift=:
-    ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
-  *)
-    ac_option=$1
-    ac_optarg=$2
-    ac_shift=shift
-    ;;
-  esac
-
-  case $ac_option in
-  # Handling of the options.
-  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-    ac_cs_recheck=: ;;
-  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
-    $as_echo "$ac_cs_version"; exit ;;
-  --config | --confi | --conf | --con | --co | --c )
-    $as_echo "$ac_cs_config"; exit ;;
-  --debug | --debu | --deb | --de | --d | -d )
-    debug=: ;;
-  --file | --fil | --fi | --f )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
-    esac
-    as_fn_append CONFIG_FILES " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h |  --help | --hel | -h )
-    $as_echo "$ac_cs_usage"; exit ;;
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil | --si | --s)
-    ac_cs_silent=: ;;
-
-  # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
-
-  *) as_fn_append ac_config_targets " $1"
-     ac_need_defaults=false ;;
-
-  esac
-  shift
-done
-
-ac_configure_extra_args=
-
-if $ac_cs_silent; then
-  exec 6>/dev/null
-  ac_configure_extra_args="$ac_configure_extra_args --silent"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-if \$ac_cs_recheck; then
-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-  shift
-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
-  CONFIG_SHELL='$SHELL'
-  export CONFIG_SHELL
-  exec "\$@"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-  $as_echo "$ac_log"
-} >&5
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-
-# Handling of arguments.
-for ac_config_target in $ac_config_targets
-do
-  case $ac_config_target in
-    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
-
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-  esac
-done
-
-
-# If the user did not use the arguments to specify the items to instantiate,
-# then the envvar interface is used.  Set only those that are not.
-# We use the long form for the default assignment because of an extremely
-# bizarre bug on SunOS 4.1.3.
-if $ac_need_defaults; then
-  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
-fi
-
-# Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason against having it here, and in addition,
-# creating and moving files from /tmp can sometimes cause problems.
-# Hook for its removal unless debugging.
-# Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
-$debug ||
-{
-  tmp= ac_tmp=
-  trap 'exit_status=$?
-  : "${ac_tmp:=$tmp}"
-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
-' 0
-  trap 'as_fn_exit 1' 1 2 13 15
-}
-# Create a (secure) tmp directory for tmp files.
-
-{
-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -d "$tmp"
-}  ||
-{
-  tmp=./conf$$-$RANDOM
-  (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
-ac_tmp=$tmp
-
-# Set up the scripts for CONFIG_FILES section.
-# No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
-if test -n "$CONFIG_FILES"; then
-
-
-ac_cr=`echo X | tr X '\015'`
-# On cygwin, bash can eat \r inside `` if the user requested igncr.
-# But we know of no other shell where ac_cr would be empty at this
-# point, so we can use a bashism as a fallback.
-if test "x$ac_cr" = x; then
-  eval ac_cr=\$\'\\r\'
-fi
-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
-else
-  ac_cs_awk_cr=$ac_cr
-fi
-
-echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
-_ACEOF
-
-
-{
-  echo "cat >conf$$subs.awk <<_ACEOF" &&
-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
-  echo "_ACEOF"
-} >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
-ac_delim='%!_!# '
-for ac_last_try in false false false false false :; do
-  . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-
-  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
-  if test $ac_delim_n = $ac_delim_num; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-rm -f conf$$subs.sh
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
-_ACEOF
-sed -n '
-h
-s/^/S["/; s/!.*/"]=/
-p
-g
-s/^[^!]*!//
-:repl
-t repl
-s/'"$ac_delim"'$//
-t delim
-:nl
-h
-s/\(.\{148\}\)..*/\1/
-t more1
-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
-p
-n
-b repl
-:more1
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t nl
-:delim
-h
-s/\(.\{148\}\)..*/\1/
-t more2
-s/["\\]/\\&/g; s/^/"/; s/$/"/
-p
-b
-:more2
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t delim
-' <conf$$subs.awk | sed '
-/^[^""]/{
-  N
-  s/\n//
-}
-' >>$CONFIG_STATUS || ac_write_fail=1
-rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACAWK
-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
-  for (key in S) S_is_set[key] = 1
-  FS = ""
-
-}
-{
-  line = $ 0
-  nfields = split(line, field, "@")
-  substed = 0
-  len = length(field[1])
-  for (i = 2; i < nfields; i++) {
-    key = field[i]
-    keylen = length(key)
-    if (S_is_set[key]) {
-      value = S[key]
-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
-      len += length(value) + length(field[++i])
-      substed = 1
-    } else
-      len += 1 + keylen
-  }
-
-  print line
-}
-
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
-else
-  cat
-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
-_ACEOF
-
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
-h
-s///
-s/^/:/
-s/[	 ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
-s/:*$//
-x
-s/\(=[	 ]*\).*/\1/
-G
-s/\n//
-s/^[^=]*=[	 ]*$//
-}'
-fi
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-fi # test -n "$CONFIG_FILES"
-
-
-eval set X "  :F $CONFIG_FILES      "
-shift
-for ac_tag
-do
-  case $ac_tag in
-  :[FHLC]) ac_mode=$ac_tag; continue;;
-  esac
-  case $ac_mode$ac_tag in
-  :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-  :[FH]-) ac_tag=-:-;;
-  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-  esac
-  ac_save_IFS=$IFS
-  IFS=:
-  set x $ac_tag
-  IFS=$ac_save_IFS
-  shift
-  ac_file=$1
-  shift
-
-  case $ac_mode in
-  :L) ac_source=$1;;
-  :[FH])
-    ac_file_inputs=
-    for ac_f
-    do
-      case $ac_f in
-      -) ac_f="$ac_tmp/stdin";;
-      *) # Look for the file first in the build tree, then in the source tree
-	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
-	 test -f "$ac_f" ||
-	   case $ac_f in
-	   [\\/$]*) false;;
-	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
-	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-      esac
-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-      as_fn_append ac_file_inputs " '$ac_f'"
-    done
-
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
-    # use $as_me), people would be surprised to read:
-    #    /* config.h.  Generated by config.status.  */
-    configure_input='Generated from '`
-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-	`' by configure.'
-    if test x"$ac_file" != x-; then
-      configure_input="$ac_file.  $configure_input"
-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-$as_echo "$as_me: creating $ac_file" >&6;}
-    fi
-    # Neutralize special characters interpreted by sed in replacement strings.
-    case $configure_input in #(
-    *\&* | *\|* | *\\* )
-       ac_sed_conf_input=`$as_echo "$configure_input" |
-       sed 's/[\\\\&|]/\\\\&/g'`;; #(
-    *) ac_sed_conf_input=$configure_input;;
-    esac
-
-    case $ac_tag in
-    *:-:* | *:-) cat >"$ac_tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
-    esac
-    ;;
-  esac
-
-  ac_dir=`$as_dirname -- "$ac_file" ||
-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_file" : 'X\(//\)[^/]' \| \
-	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  as_dir="$ac_dir"; as_fn_mkdir_p
-  ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-
-  case $ac_mode in
-  :F)
-  #
-  # CONFIG_FILE
-  #
-
-  case $INSTALL in
-  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
-  esac
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# If the template does not know about datarootdir, expand it.
-# FIXME: This hack should be removed a few years after 2.60.
-ac_datarootdir_hack=; ac_datarootdir_seen=
-ac_sed_dataroot='
-/datarootdir/ {
-  p
-  q
-}
-/@datadir@/p
-/@docdir@/p
-/@infodir@/p
-/@localedir@/p
-/@mandir@/p'
-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
-*datarootdir*) ac_datarootdir_seen=yes;;
-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  ac_datarootdir_hack='
-  s&@datadir@&$datadir&g
-  s&@docdir@&$docdir&g
-  s&@infodir@&$infodir&g
-  s&@localedir@&$localedir&g
-  s&@mandir@&$mandir&g
-  s&\\\${datarootdir}&$datarootdir&g' ;;
-esac
-_ACEOF
-
-# Neutralize VPATH when `$srcdir' = `.'.
-# Shell code in configure.ac might set extrasub.
-# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_sed_extra="$ac_vpsub
-$extrasub
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-:t
-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s|@configure_input@|$ac_sed_conf_input|;t t
-s&@top_builddir@&$ac_top_builddir_sub&;t t
-s&@top_build_prefix@&$ac_top_build_prefix&;t t
-s&@srcdir@&$ac_srcdir&;t t
-s&@abs_srcdir@&$ac_abs_srcdir&;t t
-s&@top_srcdir@&$ac_top_srcdir&;t t
-s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
-s&@builddir@&$ac_builddir&;t t
-s&@abs_builddir@&$ac_abs_builddir&;t t
-s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
-s&@INSTALL@&$ac_INSTALL&;t t
-$ac_datarootdir_hack
-"
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-
-test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-      "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
-$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
-
-  rm -f "$ac_tmp/stdin"
-  case $ac_file in
-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
-  esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
- ;;
-
-
-
-  esac
-
-done # for ac_tag
-
-
-as_fn_exit 0
-_ACEOF
-ac_clean_files=$ac_clean_files_save
-
-test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
-
-
-# configure is writing to config.log, and then calls config.status.
-# config.status does its own redirection, appending to config.log.
-# Unfortunately, on DOS this fails, as config.log is still kept open
-# by configure, so config.status won't be able to write to it; its
-# output is simply discarded.  So we exec the FD to /dev/null,
-# effectively closing config.log, so it can be properly (re)opened and
-# appended to by config.status.  When coming back to configure, we
-# need to make the FD available again.
-if test "$no_create" != yes; then
-  ac_cs_success=:
-  ac_config_status_args=
-  test "$silent" = yes &&
-    ac_config_status_args="$ac_config_status_args --quiet"
-  exec 5>/dev/null
-  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
-  exec 5>>config.log
-  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
-  # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
-fi
-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-fi
diff --git a/vendor/target-tuples/configure.ac b/vendor/target-tuples/configure.ac
deleted file mode 100644
index c5304ea5..00000000
--- a/vendor/target-tuples/configure.ac
+++ /dev/null
@@ -1,17 +0,0 @@
-AC_INIT
-
-AC_CONFIG_MACRO_DIRS([m4/])
-
-AC_CANONICAL_BUILD
-AC_CANONICAL_HOST
-
-AC_PROG_CC
-
-AC_PROG_INSTALL
-
-LCRUST_PROG_RUSTC
-
-AC_SUBST([detected_cfg])
-AC_CONFIG_FILES([Makefile])
-
-AC_OUTPUT
\ No newline at end of file
diff --git a/vendor/target-tuples/install-sh b/vendor/target-tuples/install-sh
deleted file mode 100755
index ec298b53..00000000
--- a/vendor/target-tuples/install-sh
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2020-11-14.01; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-        shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -p) cpprog="$cpprog -p";;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call 'install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-    dst=$dst_arg
-
-    # If destination is a directory, append the input filename.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
-
-        posix_mkdir=false
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
-	then
-	  if test -z "$dir_arg" || {
-	       # Check for POSIX incompatibilities with -m.
-	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-	       # other-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
-	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
-	fi
-	trap '' 0;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
-      esac
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && continue
-
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask $mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
-
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/vendor/target-tuples/m4/lcrust_prog_rustc.m4 b/vendor/target-tuples/m4/lcrust_prog_rustc.m4
deleted file mode 100644
index edf35367..00000000
--- a/vendor/target-tuples/m4/lcrust_prog_rustc.m4
+++ /dev/null
@@ -1,220 +0,0 @@
-
-AC_DEFUN([LCRUST_PROG_RUSTC],[
-    AC_REQUIRE([AC_PROG_CC])
-    AC_REQUIRE([AC_CANONICAL_HOST])
-    AC_ARG_VAR(RUSTC,[Rust compiler to use])
-    AC_ARG_VAR(RUSTFLAGS,[Flags to pass to the rust compiler])
-
-    if test "$RUSTFLAGS" \= "" 
-    then
-        RUSTFLAGS="-C opt-level=2 -g"
-    fi
-
-    if test x$host_alias != x 
-    then
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs])
-    else 
-        AC_PATH_PROGS(RUSTC,[rustc lcrustc $host-gccrs gccrs])
-    fi
-
-    if test "$RUSTC" \= ""
-    then
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC to a suitable compiler])
-    fi
-
-    if test x$host_alias != x
-    then
-        case $RUSTC in 
-            *[\\/]$host-* ) dnl gccrs has a host prefix when cross-compiling, so no need to attempt using `--target`
-                ;;
-            * )
-                SAVE_RUSTFLAGS="$RUSTFLAGS"
-                AC_MSG_CHECKING([how to cross compile with $RUSTC])
-                RUSTFLAGS="$RUSTFLAGS --target $host"
-                echo '' > test.rs
-                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs 2>> config.log > /dev/null
-                
-                if test $? -eq 0
-                then
-                    AC_MSG_RESULT([--target $host])
-                else
-                    rm -f test.rs libtest.rlib
-                    RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_alias"
-                    echo '' > test.rs
-                    $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                    if test $? -eq 0
-                    then
-                        rm -f test.rs libtest.rlib
-                        AC_MSG_RESULT([--target $host_alias])
-                    else
-                        rm -f test.rs libtest.rlib
-                        case "$host" in 
-                            x86_64-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    AC_MSG_RESULT([--target $host_target])
-                                else
-                                    AC_MSG_RESULT([failed])
-                                    AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                fi
-                            ;;
-
-                            i?86-pc-*-* )
-                                IFS="-" read arch vendor kernel env  <<< "$host"
-                                host_target="$arch-unknown-$kernel-$env"
-                                RUSTFLAGS="$SAVE_RUSTFLAGS --target $host_target"
-                                echo '' > test.rs
-                                $RUSTC $RUSTFLAGS --crate-type rlib --crate-name test test.rs  2>> config.log > /dev/null
-                                if test $? -eq 0
-                                then
-                                    rm -f test.rs libtest.rlib
-                                    AC_MSG_RESULT([--target $host_target])
-                                else
-                                    AC_MSG_RESULT([failed])
-                                    AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                fi
-                            ;;
-
-                            *)
-                                AC_MSG_RESULT([failed])
-                                AC_MSG_ERROR([Cannot determine how to cross compile to $host with $RUSTC])
-                                ;;
-                        esac
-                    fi
-                fi
-                ;;
-        esac
-    fi
-
-    AC_MSG_CHECKING([whether Rust compiler works])
-    echo 'fn main(){}' > test.rs 
-    $RUSTC $RUSTFLAGS --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot compile a simple program with $RUSTC])
-    fi
-
-    if test x$host_alias != x 
-    then
-        ./test${EXEEXT}
-        if test $? -ne 0
-        then
-            AC_MSG_RESULT([no])
-            AC_MSG_ERROR([Cannot run executables compiled by $RUSTC])
-        fi
-    fi
-
-    rm -rf test.rs test${EXEEXT}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(RUSTC)
-    AC_SUBST(RUSTFLAGS)
-])
-
-AC_DEFUN([LCURST_RUSTC_VERSION],[
-    AC_REQUIRE([LCRUST_PROG_RUSTC])
-
-    version_output="`${RUSTC} --version`"
-
-    AC_MSG_CHECKING(the rust version supported by ${RUSTC})
-    
-    read rustc_name rust_version <<< ${version_output}
-
-    AC_MSG_RESULT(${rust_version})
-
-    case $rust_version in
-        *.*.*-beta.* )
-            rust_channel=beta
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${version_output}
-            IFS="-" read rust_patch <<< ${_lcrust_rest}
-            ;;
-        *.*.*-* )
-            IFS="." read rust_major rust_minor _lcrust_rest <<< ${version_output}
-            IFS="-" read rust_patch rust_channel <<< ${_lcrust_rest}
-            ;;
-        *.*.* )
-            rust_channel=stable
-            IFS="." read rust_major rust_minor rust_patch <<< ${version_output}
-            ;;
-    esac
-    AC_MSG_CHECKING(whether $RUSTC is lccc)
-    case $name in
-        lcrust* | lccc* ) dnl lccc doesn't distinguish between stable and unstable compiler, 
-            rustc_is_lccc=yes
-            ;;
-        * )
-            rustc_is_lccc=no
-            ;;
-    esac
-    AC_MSG_RESULT([$rustc_is_lccc])
-    
-    AC_SUBST(rustc_name)
-    AC_SUBST(rust_version)
-    AC_SUBST(rust_channel)
-    AC_SUBST(rustc_is_lccc)
-])
-
-AC_DEFUN([LCRUST_PROG_RUSTC_FOR_BUILD],[
-    AC_REQUIRE([AX_PROG_CC_FOR_BUILD])
-    AC_REQUIRE([AC_CANONICAL_BUILD])
-    AC_ARG_VAR(RUSTC_FOR_BUILD,[Rust compiler to use on the build system])
-    AC_ARG_VAR(RUSTFLAGS_FOR_BUILD,[Flags to pass to the rust compiler for the build system])
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build...])
-
-    AC_PATH_PROGS(RUSTC_FOR_BUILD,[rustc lcrustc $build-gccrs gccrs])
-
-    if test "$RUSTC_FOR_BUILD" \= ""
-    then
-        AC_MSG_NOTICE([checking for the compiler to use for $build... not found])
-        AC_MSG_ERROR([Failed to find a rust compiler. Install rustc in PATH, or set RUSTC_FOR_BUILD to a suitable compiler])
-    fi
-
-    AC_MSG_NOTICE([checking for the compiler to use for $build... $RUSTC_FOR_BUILD])
-
-
-    AC_MSG_CHECKING([whether Rust compiler works])
-    echo 'fn main(){}' > test.rs 
-    $RUSTC_FOR_BUILD $RUSTFLAGS_FOR_BUILD --crate-type bin --crate-name test test.rs 2>> config.log > /dev/null
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot compile a simple program with $RUSTC_FOR_BUILD])
-    fi
-    
-    ./test${EXEEXT_FOR_BUILD}
-    if test $? -ne 0
-    then
-        AC_MSG_RESULT([no])
-        AC_MSG_ERROR([Cannot run executables compiled by $RUSTC_FOR_BUILD])
-    fi
-
-    rm -rf test.rs test${EXEEXT_FOR_BUILD}
-
-    AC_MSG_RESULT([yes])
-
-    AC_SUBST(RUSTC_FOR_BUILD)
-    AC_SUBST(RUSTFLAGS_FOR_BUILD)
-])
-
-AC_DEFUN([LCRUST_TRY_COMPILE],[
-    echo '$1' >> test.rs
-    ${RUSTC} ${RUSTFLAGS} --crate-type rlib --crate-name test --emit link=libtest.rlib test.rs
-
-    if test $? -eq 0 
-    then
-        rm -f test.rs libtest.rlib
-        $2
-    else
-        rm -f test.rs libtest.rlib
-        $3
-    fi
-])
diff --git a/vendor/target-tuples/run-tests.sh b/vendor/target-tuples/run-tests.sh
deleted file mode 100755
index 16d10aff..00000000
--- a/vendor/target-tuples/run-tests.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-for s in $*
-do
-    $s
-done
\ No newline at end of file
diff --git a/vendor/target-tuples/src/config-sub.rs b/vendor/target-tuples/src/config-sub.rs
deleted file mode 100644
index d7f12d19..00000000
--- a/vendor/target-tuples/src/config-sub.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use target_tuples::*;
-
-pub fn main() {
-    let mut args = std::env::args();
-    let bin = args.next().unwrap();
-    if let Some(name) = args.next() {
-        match &*name {
-            "--help" => {
-                println!("Usage: {} [OPTION]|<target>", bin);
-                println!("Converts a target tuple into canonical form");
-                println!("Options:");
-                println!("\t--help: Prints this message, and exits");
-                println!("\t--version: Prints version information, and exists");
-            }
-            "--version" => {
-                println!("config.sub v{}", env!("CARGO_PKG_VERSION"));
-                println!("Copyright (C) 2020 Connor Horman, this program is a free software, dual-licensed under the terms of the Apache v2 and the MIT license");
-                println!("This program is provided AS-IS, without any warranty.");
-            }
-            x => {
-                if let Ok(t) = x.parse::<Target>() {
-                    println!("{}", t);
-                } else {
-                    eprintln!("Unsupported target {}", x);
-                    std::process::exit(1);
-                }
-            }
-        }
-    } else {
-        std::process::exit(1);
-    }
-}
diff --git a/vendor/target-tuples/src/lib.rs b/vendor/target-tuples/src/lib.rs
deleted file mode 100644
index 330a6cd5..00000000
--- a/vendor/target-tuples/src/lib.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-#![deny(warnings, unsafe_code)]
-#![cfg_attr(not(any(doc, test)), no_std)]
-
-extern crate alloc;
-
-mod pieces;
-
-pub use pieces::*;
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __to_target {
-    ($first:ident-$($rest:ident)-+) => {
-        ::core::concat!(::core::stringify!($first) $(,"-",::core::stringify!($rest))*)
-    }
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __match_target_pattern {
-    ($arch:ident-$vendor:ident-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $os - $env));
-            *targ == mtarg
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $sys));
-            targ == mtarg
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $os - $env));
-
-            targ.vendor() == targ.vendor()
-                && targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-    (*-$vendor:ident-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $sys));
-
-            targ.vendor() == targ.vendor()
-                && targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - $os - $env));
-
-            targ.arch() == targ.arch()
-                && targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-    ($arch:ident-*-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - $sys));
-
-            targ.arch() == targ.arch()
-                && targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - $vendor - unknown - $env));
-
-            targ.arch() == targ.arch()
-                && targ.vendor() == mtarg.vendor()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - elf));
-
-            targ.arch() == targ.arch() && targ.vendor() == mtarg.vendor()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-$vendor:ident-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - $vendor - $os - elf));
-
-            targ.vendor() == mtarg.vendor() && targ.operating_system() == mtarg.operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-$os:ident-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $os - $env));
-
-            targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-    (*-*-$sys:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $sys));
-
-            targ.operating_system() == mtarg.operating_system()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - unknown - $env));
-
-            targ.vendor() == mtarg.vendor()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - elf));
-
-            targ.vendor() == mtarg.vendor()
-        }
-
-        __check
-    }};
-
-    (*-$vendor:ident-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!(x86_64 - $vendor - $os - elf));
-
-            targ.vendor() == mtarg.vendor() && targ.operating_system() == mtarg.operating_system()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - unknown - unknown - $env));
-
-            targ.arch() == targ.arch()
-                && targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg = $crate::Target::parse($crate::__to_target!($arch - unknown - elf));
-
-            targ.arch() == targ.arch()
-        }
-
-        __check
-    }};
-
-    ($arch:ident-*-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!($arch - unknown - $os - unknown));
-
-            targ.arch() == mtarg.arch() && targ.operating_system() == mtarg.operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-*-$env:ident) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - unknown - unknown - $env));
-
-            targ.environment() == mtarg.environment()
-                && targ.object_format() == mtarg.object_format()
-        }
-
-        __check
-    }};
-
-    (*-*-$os:ident-*) => {{
-        fn __check(targ: &$crate::Target) -> bool {
-            let mtarg =
-                $crate::Target::parse($crate::__to_target!(x86_64 - unknown - $os - unknown));
-
-            targ.operating_system() == mtarg.operating_system()
-        }
-
-        __check
-    }};
-
-    (*-*-*) => {{
-        fn __check(_: &$crate::Target) -> bool {
-            true
-        }
-        __check
-    }};
-
-    (*) => {{
-        fn __check(_: &$crate::Target) -> bool {
-            true
-        }
-        __check
-    }};
-}
-
-#[macro_export]
-macro_rules! match_targets{
-    {
-        match ($targ:expr) {
-            $($($comp:tt)-* => $exp:expr),* $(,)?
-        }
-    } => {
-        {
-            let __val: &$crate::Target = &$targ;
-            #[allow(unreachable_code)]
-            loop {
-                $(if ($crate::__match_target_pattern!($($comp)-*))(&__val){
-                    break $exp
-                })*
-
-                unreachable!("Incomplete Exhaustive Target Pattern (add a wildcard match as * => )")
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::Target;
-
-    #[test]
-    pub fn test_match_easy() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn test_match_ref() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (&target) {
-                x86_64-pc-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_arch_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                *-pc-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_vendor_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-*-linux-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_os_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-*-gnu => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_env_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-* => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_sys_wildcard() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-* => {},
-                * => panic!("Invalid Target")
-            }
-        }
-    }
-
-    #[test]
-    pub fn target_match_first() {
-        let target = Target::parse("x86_64-pc-linux-gnu");
-        match_targets! {
-            match (target) {
-                x86_64-pc-linux-gnu => {},
-                x86_64-*-linux-* => panic!("Incorrect Match"),
-                * => panic!("Incorrect Match"),
-            }
-        }
-    }
-}
diff --git a/vendor/target-tuples/src/pieces.rs b/vendor/target-tuples/src/pieces.rs
deleted file mode 100644
index 6856c439..00000000
--- a/vendor/target-tuples/src/pieces.rs
+++ /dev/null
@@ -1,1044 +0,0 @@
-#![allow(
-    clippy::upper_case_acronyms,
-    clippy::manual_non_exhaustive,
-    clippy::match_like_matches_macro
-)] // Kill clippy for MSRV
-use alloc::{borrow::ToOwned, string::String};
-use core::fmt::Formatter;
-use core::{fmt::Display, str::FromStr};
-
-///
-/// The result of FromStr::from_str, when parsing a field (other than vendor),
-///  with a value that is not known to the library
-#[derive(Debug, Clone, Copy)]
-pub struct UnknownError;
-
-impl Display for UnknownError {
-    fn fmt(&self, fmt: &mut Formatter) -> core::fmt::Result {
-        fmt.write_str("Unknown or invalid target or component")
-    }
-}
-
-///
-/// The Architecture field of a target tuple
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u32)]
-pub enum Architecture {
-    Unknown = 0,
-    I86 = 1,
-    I8086 = 2,
-    I086 = 3,
-    I186 = 4,
-    I286 = 5,
-    I386 = 6,
-    I486 = 7,
-    I586 = 8,
-    I686 = 9,
-    X86_64 = 10,
-    Arm = 11,
-    ArmBe = 12,
-    Aarch64 = 13,
-    Aarch64Be = 14,
-    Aarch64_32 = 15,
-    Mips = 16,
-    MipsLE = 17,
-    Mips64 = 18,
-    Mips64LE = 19,
-    PowerPC32 = 20,
-    PowerPC64 = 21,
-    PowerPC64le = 22,
-    RiscV32 = 23,
-    RiscV64 = 24,
-    Sparc = 25,
-    SparcV9 = 26,
-    SparcEL = 27,
-    Wasm32 = 28,
-    Wasm64 = 29,
-    Wc65c816 = 30,
-    M6502 = 31,
-    M65C02 = 32,
-    SPC700 = 33,
-
-    /// Used for ABI Purposes with lccc
-    Null = (-1i32) as u32,
-    #[doc(hidden)]
-    __Nonexhaustive = (-2i32) as u32,
-}
-
-impl FromStr for Architecture {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "i86" => Self::I86,
-            "i8086" => Self::I8086,
-            "i086" => Self::I086,
-            "i186" => Self::I186,
-            "i286" => Self::I286,
-            "i386" => Self::I386,
-            "i486" => Self::I486,
-            "i586" => Self::I586,
-            "i686" => Self::I686,
-            "amd64" | "x86_64" | "x86_64h" => Self::X86_64,
-            "armeb" => Self::ArmBe,
-            "arm" => Self::Arm,
-            "aarch64" | "arm64" | "arm64e" => Self::Aarch64,
-            "aarch64_be" | "arm64_be" => Self::Aarch64Be,
-            "aarch64_32" | "arm64_32" => Self::Aarch64_32,
-            "powerpc" | "powerpcspe" | "ppc" | "ppc32" => Self::PowerPC32,
-            "powerpc64" | "ppu" | "ppc64" => Self::PowerPC64,
-            "powerpc64le" | "ppc64le" => Self::PowerPC64le,
-            "mips" | "mipseb" | "mipsallegrex" | "mipsisa32r6" | "mipsr6" => Self::Mips,
-            "mipsel" | "mipsallegrexel" | "mipsisa32r6el" | "mipsr6el" => Self::MipsLE,
-            "mips64" | "mips64eb" | "mipsn32" | "mipsisa64r6" | "mips64r6" | "mipsn32r6" => {
-                Self::Mips64
-            }
-            "mips64el" | "mipsn32el" | "mipsisa64r6el" | "mips64r6el" | "mipsn32r6el" => {
-                Self::Mips64LE
-            }
-            "sparc" => Self::Sparc,
-            "sparcel" => Self::SparcEL,
-            "sparcv9" | "sparc64" => Self::SparcV9,
-            "riscv32" => Self::RiscV32,
-            "riscv64" => Self::RiscV64,
-            "wc65c816" | "65816" | "w65c816" | "65c816" | "w65" => Self::Wc65c816,
-            "6502" | "6502x" | "6502X" => Self::M6502,
-            "65c02" | "65C02" => Self::M65C02,
-            "wasm32" => Self::Wasm32,
-            "wasm64" => Self::Wasm64,
-
-            "spc700" | "spc" => Self::SPC700,
-
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for Architecture {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Architecture {
-    /// Parses the Architecture in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], but returns [`Architecture::Unknown`], instead of an error,
-    ///  on an unknown architecture.
-    /// This is useful (in conjunction with an actual target name)
-    pub fn parse(st: &str) -> Self {
-        Self::from_str(st).unwrap_or(Architecture::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the target
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting an Architecture yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Architecture::Unknown => "unknown",
-            Architecture::I86 => "i86",
-            Architecture::I086 => "i086",
-            Architecture::I8086 => "i8086",
-            Architecture::I186 => "i186",
-            Architecture::I286 => "i286",
-            Architecture::I386 => "i386",
-            Architecture::I486 => "i486",
-            Architecture::I586 => "i586",
-            Architecture::I686 => "i686",
-            Architecture::X86_64 => "x86_64",
-            Architecture::Arm => "arm",
-            Architecture::ArmBe => "armeb",
-            Architecture::Aarch64 => "aarch64",
-            Architecture::Aarch64Be => "aarch64_be",
-            Architecture::Aarch64_32 => "aarch64_32",
-            Architecture::Mips => "mips",
-            Architecture::Mips64 => "mips64",
-            Architecture::PowerPC32 => "powerpc",
-            Architecture::PowerPC64 => "powerpc64",
-            Architecture::PowerPC64le => "powerpc64le",
-            Architecture::RiscV32 => "riscv32",
-            Architecture::RiscV64 => "riscv64",
-            Architecture::Sparc => "sparc",
-            Architecture::SparcV9 => "sparcv9",
-            Architecture::SparcEL => "sparcel",
-            Architecture::Wasm32 => "wasm32",
-            Architecture::Wasm64 => "wasm64",
-            Architecture::Wc65c816 => "w65",
-            Architecture::MipsLE => "mipsel",
-            Architecture::Mips64LE => "mips64el",
-            Architecture::M6502 => "6502",
-            Architecture::M65C02 => "6502",
-            Architecture::SPC700 => "spc700",
-            Architecture::Null => "null",
-            Architecture::__Nonexhaustive => unreachable!(),
-        }
-    }
-
-    pub fn is_x86(&self) -> bool {
-        match self {
-            Architecture::I86
-            | Architecture::I8086
-            | Architecture::I186
-            | Architecture::I286
-            | Architecture::I386
-            | Architecture::I486
-            | Architecture::I586
-            | Architecture::I686 => true,
-            _ => false,
-        }
-    }
-}
-
-///
-/// The Vendor field of a target tuple
-///
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u32)]
-pub enum Vendor {
-    Unknown = 0,
-    Apple = 1,
-    PC = 2,
-    SCEI = 3,
-    Freescale = 4,
-    IBM = 5,
-    ImaginationTechnologies = 6,
-    MipsTechnologies = 7,
-    NVIDIA = 8,
-    CSR = 9,
-    Myriad = 10,
-    AMD = 11,
-    Mesa = 12,
-    SUSE = 13,
-    OpenEmbedded = 14,
-    WDC = 15,
-
-    /// Used for ABI Purposes with lccc
-    Null = (-1i32) as u32,
-    #[doc(hidden)]
-    __Nonexhaustive = (-2i32) as u32,
-}
-
-impl FromStr for Vendor {
-    type Err = core::convert::Infallible;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "apple" => Self::Apple,
-            "pc" => Self::PC,
-            // "nes" => Self::NES,
-            // "snes" | "snesdev" => Self::SNES,
-            "scei" => Self::SCEI,
-            "fsl" => Self::Freescale,
-            "img" => Self::ImaginationTechnologies,
-            "ibm" => Self::IBM,
-            "mti" => Self::MipsTechnologies,
-            "nvidia" => Self::NVIDIA,
-            "csr" => Self::CSR,
-            "myriad" => Self::Myriad,
-            "amd" => Self::AMD,
-            "mesa" => Self::Mesa,
-            "suse" => Self::SUSE,
-            "oe" => Self::OpenEmbedded,
-            "wdc" => Self::WDC,
-            _ => Self::Unknown,
-        })
-    }
-}
-
-impl Display for Vendor {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Vendor {
-    /// Parses the Vendor in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`].
-    /// Note that an unknown vendor is not considered an error.
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap()
-    }
-
-    ///
-    /// Returns the canonical name of the vendor
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting a Vendor yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Vendor::Apple => "apple",
-            Vendor::PC => "pc",
-            Vendor::Unknown => "unknown",
-            Vendor::SCEI => "scei",
-            Vendor::Freescale => "fsl",
-            Vendor::IBM => "ibm",
-            Vendor::ImaginationTechnologies => "img",
-            Vendor::MipsTechnologies => "mti",
-            Vendor::NVIDIA => "nvidia",
-            Vendor::CSR => "csr",
-            Vendor::Myriad => "myriad",
-            Vendor::AMD => "amd",
-            Vendor::Mesa => "mesa",
-            Vendor::SUSE => "suse",
-            Vendor::OpenEmbedded => "oe",
-            Vendor::WDC => "wdc",
-            Vendor::Null => "null",
-            Vendor::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The Operating System Field of a target tuple
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u32)]
-pub enum OS {
-    Unknown = 0,
-
-    Ananas = 1,
-    CloudABI = 2,
-    Darwin = 3,
-    DragonFly = 4,
-    FreeBSD = 5,
-    Fuchsia = 6,
-    IOS = 7,
-    KFreeBSD = 8,
-    Linux = 9,
-    Lv2 = 10,
-    MacOSX = 11,
-    NetBSD = 12,
-    OpenBSD = 13,
-    Solaris = 14,
-    Win32 = 15,
-    ZOS = 16,
-    Haiku = 17,
-    Minix = 18,
-    RTEMS = 19,
-    NaCl = 20,
-    AIX = 21,
-    CUDA = 22,
-    NVCL = 23,
-    AMDHSA = 24,
-    PS4 = 25,
-    ELFIAMCU = 26,
-    TvOS = 27,
-    WatchOS = 28,
-    Mesa3D = 29,
-    Contiki = 30,
-    AMDPAL = 31,
-    HermitCore = 32,
-    Hurd = 33,
-    WASI = 34,
-    Emscripten = 35,
-    PhantomOS = 36,
-    SNES = 37, // Not an OS, but the currently config.sub places it in the os field
-    NES = 38,  // likewise
-
-    Null = (-1i32) as u32,
-    #[doc(hidden)]
-    __Nonexhaustive = (-2i32) as u32,
-}
-
-impl FromStr for OS {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.starts_with("ananas") => Self::Ananas,
-            x if x.starts_with("cloudabi") => Self::CloudABI,
-            x if x.starts_with("darwin") => Self::Darwin,
-            x if x.starts_with("dragonfly") => Self::DragonFly,
-            x if x.starts_with("freebsd") => Self::FreeBSD,
-            x if x.starts_with("fuchsia") => Self::Fuchsia,
-            x if x.starts_with("ios") => Self::IOS,
-            x if x.starts_with("kfreebsd") => Self::KFreeBSD,
-            x if x.starts_with("linux") => Self::Linux,
-            x if x.starts_with("lv2") => Self::Lv2,
-            x if x.starts_with("macos") => Self::MacOSX,
-            x if x.starts_with("netbsd") => Self::NetBSD,
-            x if x.starts_with("openbsd") => Self::OpenBSD,
-            x if x.starts_with("solaris") => Self::Solaris,
-            x if x.starts_with("win32") | x.starts_with("windows") => Self::Win32,
-            x if x.starts_with("zos") => Self::ZOS,
-            x if x.starts_with("haiku") => Self::Haiku,
-            x if x.starts_with("minix") => Self::Minix,
-            x if x.starts_with("rtems") => Self::RTEMS,
-            x if x.starts_with("nacl") => Self::NaCl,
-            x if x.starts_with("aix") => Self::AIX,
-            x if x.starts_with("cuda") => Self::CUDA,
-            x if x.starts_with("nvcl") => Self::NVCL,
-            x if x.starts_with("amdhsa") => Self::AMDHSA,
-            x if x.starts_with("ps4") => Self::PS4,
-            x if x.starts_with("elfiamcu") => Self::ELFIAMCU,
-            x if x.starts_with("tvos") => Self::TvOS,
-            x if x.starts_with("watchos") => Self::WatchOS,
-            x if x.starts_with("mesa3d") => Self::Mesa3D,
-            x if x.starts_with("contiki") => Self::Contiki,
-            x if x.starts_with("amdpal") => Self::AMDPAL,
-            x if x.starts_with("hermit") => Self::HermitCore,
-            x if x.starts_with("hurd") => Self::Hurd,
-            x if x.starts_with("wasi") => Self::WASI,
-            x if x.starts_with("emscripten") => Self::Emscripten,
-            x if x.starts_with("phantom") => Self::PhantomOS,
-            x if x.starts_with("snes") => Self::SNES,
-            x if x.starts_with("nes") => Self::NES,
-
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for OS {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl OS {
-    /// Parses the OS in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], except that [`OS::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the operating system
-    /// The canonical name, when passed into `[`Self::parse`] will yield an equivalent value,
-    /// Formatting an OS yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            OS::Unknown => "unknown",
-            OS::Ananas => "ananas",
-            OS::CloudABI => "cloudabi",
-            OS::Darwin => "darwin",
-            OS::DragonFly => "dragonfly",
-            OS::FreeBSD => "freebsd",
-            OS::Fuchsia => "fuchsia",
-            OS::IOS => "ios",
-            OS::KFreeBSD => "kfreebsd",
-            OS::Linux => "linux",
-            OS::Lv2 => "lv2",
-            OS::MacOSX => "macos",
-            OS::NetBSD => "netbsd",
-            OS::OpenBSD => "openbsd",
-            OS::Solaris => "solaris",
-            OS::Win32 => "win32",
-            OS::ZOS => "zos",
-            OS::Haiku => "haiku",
-            OS::Minix => "minix",
-            OS::RTEMS => "rtems",
-            OS::NaCl => "nacl",
-            OS::AIX => "aix",
-            OS::CUDA => "cuda",
-            OS::NVCL => "nvcl",
-            OS::AMDHSA => "amdhsa",
-            OS::PS4 => "ps4",
-            OS::ELFIAMCU => "elfiamcu",
-            OS::TvOS => "tvos",
-            OS::WatchOS => "watchos",
-            OS::Mesa3D => "mesa3d",
-            OS::Contiki => "contiki",
-            OS::AMDPAL => "amdpal",
-            OS::HermitCore => "hermit",
-            OS::Hurd => "hurd",
-            OS::WASI => "wasi",
-            OS::Emscripten => "emscripten",
-            OS::PhantomOS => "phantom",
-            OS::SNES => "snes",
-            OS::NES => "nes",
-            OS::Null => "null",
-            OS::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The Environment field of target tuples
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u32)]
-pub enum Environment {
-    Unknown = 0,
-    GNU = 1,
-    GNUABIN32 = 2,
-    GNUABI64 = 3,
-    GNUEABI = 4,
-    GNUEABIHF = 5,
-    GNUX32 = 6,
-    CODE16 = 7,
-    EABI = 8,
-    EABIHF = 9,
-    Android = 10,
-    Musl = 11,
-    MuslEABI = 12,
-    MuslEABIHF = 13,
-
-    MSVC = 15,
-    Itanium = 16,
-    Cygnus = 17,
-    CoreCLR = 18,
-    Simulator = 19,
-    MacABI = 20,
-
-    PhantomStandard = 21,
-    PhantomKernel = 22,
-
-    Null = (-1i32) as u32,
-    #[doc(hidden)]
-    __Nonexhaustive = (-2i32) as u32,
-}
-
-impl FromStr for Environment {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.starts_with("eabihf") => Self::EABIHF,
-            x if x.starts_with("eabi") => Self::EABI,
-            x if x.starts_with("gnuabin32") => Self::GNUABIN32,
-            x if x.starts_with("gnuabi64") => Self::GNUABI64,
-            x if x.starts_with("gnueabihf") => Self::GNUEABIHF,
-            x if x.starts_with("gnueabi") => Self::GNUEABI,
-            x if x.starts_with("gnux32") => Self::GNUX32,
-            x if x.starts_with("gnu") => Self::GNU,
-            x if x.starts_with("code16") => Self::CODE16,
-            x if x.starts_with("android") => Self::Android,
-            x if x.starts_with("musleabihf") => Self::MuslEABIHF,
-            x if x.starts_with("musleabi") => Self::MuslEABI,
-            x if x.starts_with("musl") => Self::Musl,
-            x if x.starts_with("msvc") => Self::MSVC,
-            x if x.starts_with("itanium") => Self::Itanium,
-            x if x.starts_with("cygnus") => Self::Cygnus,
-            x if x.starts_with("coreclr") => Self::CoreCLR,
-            x if x.starts_with("simulator") => Self::Simulator,
-            x if x.starts_with("macabi") => Self::MacABI,
-            x if x.starts_with("pcore") || x.starts_with("user") => Self::PhantomStandard,
-            x if x.starts_with("pkrnl") || x.starts_with("kernel") => Self::PhantomKernel,
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for Environment {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl Environment {
-    /// Parses the Environment name in a "lossy" manner
-    /// This is equivalent to [`Self::from_str`], except that [`Environment::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the environment
-    /// The canonical name, when passed into [`Self::parse`] will yield an equivalent value,
-    /// Formatting an Environment yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            Environment::Unknown => "unknown",
-            Environment::GNU => "gnu",
-            Environment::GNUABIN32 => "gnuabin32",
-            Environment::GNUABI64 => "gnuabi64",
-            Environment::GNUEABI => "gnueabi",
-            Environment::GNUEABIHF => "gnueabihf",
-            Environment::GNUX32 => "gnux32",
-            Environment::CODE16 => "code16",
-            Environment::EABI => "eabi",
-            Environment::EABIHF => "eabihf",
-            Environment::Android => "android",
-            Environment::Musl => "musl",
-            Environment::MuslEABI => "musleabi",
-            Environment::MuslEABIHF => "musleabihf",
-            Environment::MSVC => "msvc",
-            Environment::Itanium => "itanium",
-            Environment::Cygnus => "cygnus",
-            Environment::CoreCLR => "coreclr",
-            Environment::Simulator => "simulator",
-            Environment::MacABI => "macabi",
-            Environment::PhantomStandard => "user",
-            Environment::PhantomKernel => "kernel",
-            Environment::Null => "",
-            Environment::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The object format used by a target
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u32)]
-pub enum ObjectFormat {
-    Unknown = 0,
-    XCoff = 1,
-    Coff = 2,
-    Elf = 3,
-    Goff = 4,
-    MachO = 5,
-    Wasm = 6,
-
-    Xo65 = 7,
-    O65 = 8,
-    WlaObj = 9,
-
-    Null = (-1i32) as u32,
-
-    #[doc(hidden)]
-    __Nonexhaustive = (-2i32) as u32,
-}
-
-impl FromStr for ObjectFormat {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            x if x.ends_with("xcoff") => Self::XCoff,
-            x if x.ends_with("coff") => Self::Coff,
-            x if x.ends_with("elf") => Self::Elf,
-            x if x.ends_with("goff") => Self::Goff,
-            x if x.ends_with("macho") => Self::MachO,
-            x if x.ends_with("wasm") => Self::Wasm,
-            x if x.ends_with("xo65") => Self::Xo65,
-            x if x.ends_with("o65") => Self::O65,
-            x if x.ends_with("wlaobj") => Self::WlaObj,
-            x if x.ends_with("wla") => Self::WlaObj,
-            _ => return Err(UnknownError),
-        })
-    }
-}
-
-impl Display for ObjectFormat {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.canonical_name().fmt(f)
-    }
-}
-
-impl ObjectFormat {
-    /// Parses the ObjectFormat name in a "lossy" manner, from the end of the Environment field
-    /// This is equivalent to [`Self::from_str`], except that [`ObjectFormat::Unknown`] is returned, instead of an error, on an unknown OS Field
-    pub fn parse(s: &str) -> Self {
-        Self::from_str(s).unwrap_or(Self::Unknown)
-    }
-
-    ///
-    /// Returns the canonical name of the object format
-    /// The canonical name, when passed into [`Self::parse`] will yield an equivalent value,
-    /// Formatting an ObjectFormat yields this string
-    pub fn canonical_name(&self) -> &'static str {
-        match self {
-            ObjectFormat::Unknown => "unknown",
-            ObjectFormat::XCoff => "xcoff",
-            ObjectFormat::Coff => "coff",
-            ObjectFormat::Elf => "elf",
-            ObjectFormat::Goff => "goff",
-            ObjectFormat::MachO => "macho",
-            ObjectFormat::Wasm => "wasm",
-            ObjectFormat::Xo65 => "xo65",
-            ObjectFormat::O65 => "o65",
-            ObjectFormat::WlaObj => "wlaobj",
-            ObjectFormat::Null => "",
-            ObjectFormat::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
-
-///
-/// The representation of a target tuple.
-///
-/// A Target Tuple is of the form arch-vendor-system, where system can be either os-env
-///  or simply either os or env (the latter is used in the case of a freestanding target).
-///
-/// There are two types of target tuple: canonical and exact.
-/// This type can be used to represent both.
-///
-/// The [`core::fmt::Display`] implementation will display the canonical tuple;
-///  the function [`Self::get_name`] extracts the exact form that was parsed.
-/// In any case, if any field, other than vendor, is unknown, or the form is not the one above,
-///  the [`core::str::FromStr`] implementation will yield an UnknownError.
-///
-#[derive(Clone, Debug)]
-pub struct Target {
-    full: String,
-    arch: Architecture,
-    vendor: Option<Vendor>,
-    // Invariant:
-    // At least one of these fields is Some
-    os: Option<OS>,
-    env: Option<Environment>,
-    objfmt: Option<ObjectFormat>,
-}
-
-impl FromStr for Target {
-    type Err = UnknownError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut split = s.split('-');
-        let arch = split.next().ok_or(UnknownError).and_then(|s| s.parse())?;
-        let f2 = split.next().ok_or(UnknownError)?;
-        let f3 = split.next();
-        let f4 = split.next();
-        let vendor;
-        let os;
-        let env;
-        let objfmt;
-        if let (Some(s), None) = (f3, f4) {
-            if let "unknown" = f2 {
-                vendor = Some(Vendor::Unknown);
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    return Err(UnknownError);
-                }
-            } else if let Vendor::Unknown = f2.parse().unwrap() {
-                vendor = None;
-                os = Some(f2.parse()?);
-                env = s.parse().ok();
-                objfmt = s.parse().ok();
-                env.map(|_| ())
-                    .or_else(|| objfmt.map(|_| ()))
-                    .ok_or(UnknownError)?;
-            } else {
-                vendor = Some(f2.parse().unwrap());
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    return Err(UnknownError);
-                }
-            }
-        } else if let Some(s) = f4 {
-            vendor = Some(f2.parse().unwrap());
-            os = Some(f3.unwrap().parse()?);
-            env = s.parse().ok();
-            objfmt = s.parse().ok();
-            env.map(|_| ())
-                .or_else(|| objfmt.map(|_| ()))
-                .ok_or(UnknownError)?;
-        } else if let Ok(o) = f2.parse() {
-            vendor = None;
-            os = Some(o);
-            env = None;
-            objfmt = None;
-        } else if let Ok(e) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = Some(e);
-            objfmt = f2.parse().ok();
-        } else if let Ok(of) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = None;
-            objfmt = Some(of);
-        } else {
-            return Err(UnknownError);
-        }
-
-        Ok(Self {
-            full: s.to_owned(),
-            arch,
-            vendor,
-            os,
-            env,
-            objfmt,
-        })
-    }
-}
-
-impl Display for Target {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.arch.fmt(f)?;
-        f.write_str("-")?;
-        if let Some(vendor) = &self.vendor {
-            vendor.fmt(f)?;
-        } else {
-            self.vendor().fmt(f)?;
-        }
-        if let Some(os) = &self.os {
-            f.write_str("-")?;
-            os.fmt(f)?;
-        }
-        let mut last_field_sep = true;
-        if let Some(env) = &self.env {
-            last_field_sep = false;
-            f.write_str("-")?;
-            env.fmt(f)?;
-        }
-        if let Some(objfmt) = &self.objfmt {
-            if last_field_sep {
-                f.write_str("-")?;
-            }
-            objfmt.fmt(f)?;
-        }
-        Ok(())
-    }
-}
-
-impl core::hash::Hash for Target {
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        self.arch.hash(state);
-        self.vendor.hash(state);
-        self.os.hash(state);
-        self.env.hash(state);
-        self.objfmt.hash(state);
-    }
-}
-
-impl PartialEq for Target {
-    fn eq(&self, other: &Self) -> bool {
-        self.arch == other.arch
-            && self.vendor == other.vendor
-            && self.os == other.os
-            && self.env == other.env
-            && self.objfmt == other.objfmt
-    }
-}
-
-impl Eq for Target {}
-
-impl Target {
-    ///
-    /// Gets the exact name of the target tuple.
-    pub fn get_name(&self) -> &str {
-        &*self.full
-    }
-
-    ///
-    /// Returns the architecture name
-    pub fn arch_name(&self) -> &str {
-        self.full.split('-').next().unwrap()
-    }
-
-    pub fn vendor_name(&self) -> &str {
-        if self.vendor.is_some() {
-            self.full.split('-').nth(2).unwrap()
-        } else {
-            self.vendor().canonical_name()
-        }
-    }
-
-    /// Parses a target tuple of the form arch-vendor-system (where system is either os-env, os, or env).
-    /// If a field is not known, it is left as unknown, and the original value will be available
-    ///  through the exact name.
-    ///
-    /// Panics if s is not of the above form
-    pub fn parse(s: &str) -> Self {
-        let mut split = s.split('-');
-        let arch = Architecture::parse(split.next().unwrap());
-        let f2 = split.next().ok_or(UnknownError).unwrap();
-        let f3 = split.next();
-        let f4 = split.next();
-        let os;
-        let env;
-        let objfmt;
-        let vendor;
-        if let (Some(s), None) = (f3, f4) {
-            if let "unknown" = f2 {
-                vendor = Some(Vendor::Unknown);
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    os = Some(OS::Unknown);
-                    env = Some(Environment::Unknown);
-                    objfmt = None;
-                }
-            } else if let Vendor::Unknown = f2.parse().unwrap() {
-                vendor = None;
-                os = Some(f2.parse().unwrap());
-                env = s.parse().ok();
-                objfmt = s.parse().ok();
-                env.map(|_| ()).or_else(|| objfmt.map(|_| ())).unwrap();
-            } else {
-                vendor = Some(f2.parse().unwrap());
-                if let Ok(o) = s.parse() {
-                    os = Some(o);
-                    env = None;
-                    objfmt = None;
-                } else if let Ok(e) = s.parse() {
-                    os = None;
-                    env = Some(e);
-                    objfmt = s.parse().ok();
-                } else if let Ok(of) = s.parse() {
-                    os = None;
-                    env = None;
-                    objfmt = Some(of);
-                } else {
-                    os = Some(OS::Unknown);
-                    env = Some(Environment::Unknown);
-                    objfmt = None;
-                }
-            }
-        } else if let Some(s) = f4 {
-            vendor = Some(f2.parse().unwrap());
-            os = Some(OS::parse(f3.unwrap()));
-            env = s.parse().ok();
-            objfmt = s.parse().ok();
-            env.map(|_| ()).or_else(|| objfmt.map(|_| ())).unwrap();
-        } else if let Ok(o) = f2.parse() {
-            vendor = None;
-            os = Some(o);
-            env = None;
-            objfmt = None;
-        } else if let Ok(e) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = Some(e);
-            objfmt = f2.parse().ok();
-        } else if let Ok(of) = f2.parse() {
-            vendor = None;
-            os = None;
-            env = None;
-            objfmt = Some(of);
-        } else {
-            vendor = Some(Vendor::Unknown);
-            os = Some(OS::Unknown);
-            env = Some(Environment::Unknown);
-            objfmt = None;
-        }
-
-        Self {
-            full: s.to_owned(),
-            arch,
-            vendor,
-            os,
-            env,
-            objfmt,
-        }
-    }
-
-    ///
-    /// Gets the value of the `os` field
-    pub fn operating_system(&self) -> Option<OS> {
-        self.os
-    }
-
-    ///
-    /// Gets the value of the `env` field, or unknown if the environment was omitted
-    pub fn environment(&self) -> Option<Environment> {
-        self.env
-    }
-
-    ///
-    /// Constructs a target tuple in canonical form from the specified components.
-    pub fn from_components(
-        arch: Architecture,
-        vendor: Vendor,
-        os: Option<OS>,
-        env: Option<Environment>,
-        objfmt: Option<ObjectFormat>,
-    ) -> Self {
-        let mut ret = Self {
-            full: String::new(),
-            arch,
-            vendor: Some(vendor),
-            os,
-            env,
-            objfmt,
-        };
-        ret.full = alloc::format!("{}", &ret);
-        ret
-    }
-
-    ///
-    /// Gets the object format, either from the end of the `env` field, or the default for the target
-    pub fn target_object_format(&self) -> ObjectFormat {
-        if let Some(of) = self.objfmt {
-            of
-        } else {
-            match (&self.arch, &self.os) {
-                (Architecture::Unknown, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Aarch64, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Aarch64_32, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Arm, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (arch, Some(OS::MacOSX)) if arch.is_x86() => ObjectFormat::MachO,
-                (Architecture::X86_64, Some(OS::MacOSX)) => ObjectFormat::MachO,
-                (Architecture::Unknown, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Aarch64, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Aarch64_32, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::Arm, Some(OS::Win32)) => ObjectFormat::Coff,
-                (arch, Some(OS::Win32)) if arch.is_x86() => ObjectFormat::Coff,
-                (Architecture::X86_64, Some(OS::Win32)) => ObjectFormat::Coff,
-                (Architecture::PowerPC32, Some(OS::AIX)) => ObjectFormat::XCoff,
-                (Architecture::PowerPC64, Some(OS::AIX)) => ObjectFormat::XCoff,
-                (Architecture::SPC700, _) => ObjectFormat::WlaObj,
-                _ => ObjectFormat::Elf,
-            }
-        }
-    }
-
-    /// Gets the object format component from the end of the env component, or None if none is present
-    pub fn object_format(&self) -> Option<ObjectFormat> {
-        self.objfmt
-    }
-
-    ///
-    /// Gets the value of the Architecture field
-    pub fn arch(&self) -> Architecture {
-        self.arch
-    }
-
-    ///
-    /// Gets the value of the vendor field.
-    pub fn vendor(&self) -> Vendor {
-        if let Some(vendor) = &self.vendor {
-            *vendor
-        } else if self.arch.is_x86() || Architecture::X86_64 == self.arch {
-            match self.os {
-                Some(OS::MacOSX) | Some(OS::IOS) | Some(OS::TvOS) | Some(OS::WatchOS) => {
-                    Vendor::Apple
-                }
-                Some(OS::CUDA) => Vendor::NVIDIA,
-                _ => Vendor::PC,
-            }
-        } else if let Architecture::Wc65c816 = self.arch {
-            Vendor::WDC
-        } else {
-            Vendor::Unknown
-        }
-    }
-}
-
-///
-/// Parses a target tuple from an environment variable.
-#[macro_export]
-macro_rules! from_env {
-    ($var:literal) => {{
-        use core::str::FromStr as _;
-        let _target: $crate::Target = ::core::env!($var).parse().unwrap();
-        _target
-    }};
-    ($var:literal?) => {{
-        use core::str::FromStr as _;
-        let _target: ::core::option::Option<$crate::Target> =
-            ::core::option_env!($var).map(|s| s.parse().unwrap());
-        _target
-    }};
-}
diff --git a/vendor/target-tuples/tests/config-sub.data b/vendor/target-tuples/tests/config-sub.data
deleted file mode 100644
index eee74b03..00000000
--- a/vendor/target-tuples/tests/config-sub.data
+++ /dev/null
@@ -1,7 +0,0 @@
-x86_64-pc-linux-gnu|x86_64-pc-linux-gnu
-x86_64-linux-musl|x86_64-pc-linux-musl
-x86_64-unknown-linux-gnux32|x86_64-unknown-linux-gnux32
-i386-phantom-kernel|i386-pc-phantom-kernel
-i486-windows-msvc|i486-pc-win32-msvc
-wc65c816-elf|w65-wdc-elf
-65816-snes-elf|w65-wdc-snes-elf
diff --git a/vendor/target-tuples/tests/rustc-targets.data b/vendor/target-tuples/tests/rustc-targets.data
deleted file mode 100644
index c4694aa0..00000000
--- a/vendor/target-tuples/tests/rustc-targets.data
+++ /dev/null
@@ -1,169 +0,0 @@
-aarch64-apple-darwin
-aarch64-apple-ios
-aarch64-apple-ios-macabi
-aarch64-apple-ios-sim
-aarch64-apple-tvos
-aarch64-fuchsia
-aarch64-linux-android
-aarch64-pc-windows-msvc
-aarch64-unknown-freebsd
-aarch64-unknown-hermit
-aarch64-unknown-linux-gnu
-aarch64-unknown-linux-gnu_ilp32
-aarch64-unknown-linux-musl
-aarch64-unknown-netbsd
-aarch64-unknown-none
-aarch64-unknown-none-softfloat
-aarch64-unknown-openbsd
-aarch64-unknown-redox
-aarch64-unknown-uefi
-aarch64-uwp-windows-msvc
-aarch64-wrs-vxworks
-aarch64_be-unknown-linux-gnu
-aarch64_be-unknown-linux-gnu_ilp32
-arm-linux-androideabi
-arm-unknown-linux-gnueabi
-arm-unknown-linux-gnueabihf
-arm-unknown-linux-musleabi
-arm-unknown-linux-musleabihf
-armebv7r-none-eabi
-armebv7r-none-eabihf
-armv4t-unknown-linux-gnueabi
-armv5te-unknown-linux-gnueabi
-armv5te-unknown-linux-musleabi
-armv5te-unknown-linux-uclibceabi
-armv6-unknown-freebsd
-armv6-unknown-netbsd-eabihf
-armv7-apple-ios
-armv7-linux-androideabi
-armv7-unknown-freebsd
-armv7-unknown-linux-gnueabi
-armv7-unknown-linux-gnueabihf
-armv7-unknown-linux-musleabi
-armv7-unknown-linux-musleabihf
-armv7-unknown-netbsd-eabihf
-armv7-wrs-vxworks-eabihf
-armv7a-none-eabi
-armv7a-none-eabihf
-armv7r-none-eabi
-armv7r-none-eabihf
-armv7s-apple-ios
-asmjs-unknown-emscripten
-avr-unknown-gnu-atmega328
-bpfeb-unknown-none
-bpfel-unknown-none
-hexagon-unknown-linux-musl
-i386-apple-ios
-i586-pc-windows-msvc
-i586-unknown-linux-gnu
-i586-unknown-linux-musl
-i686-apple-darwin
-i686-linux-android
-i686-pc-windows-gnu
-i686-pc-windows-msvc
-i686-unknown-freebsd
-i686-unknown-haiku
-i686-unknown-linux-gnu
-i686-unknown-linux-musl
-i686-unknown-netbsd
-i686-unknown-openbsd
-i686-unknown-uefi
-i686-uwp-windows-gnu
-i686-uwp-windows-msvc
-i686-wrs-vxworks
-mips-unknown-linux-gnu
-mips-unknown-linux-musl
-mips-unknown-linux-uclibc
-mips64-unknown-linux-gnuabi64
-mips64-unknown-linux-muslabi64
-mips64el-unknown-linux-gnuabi64
-mips64el-unknown-linux-muslabi64
-mipsel-sony-psp
-mipsel-unknown-linux-gnu
-mipsel-unknown-linux-musl
-mipsel-unknown-linux-uclibc
-mipsel-unknown-none
-mipsisa32r6-unknown-linux-gnu
-mipsisa32r6el-unknown-linux-gnu
-mipsisa64r6-unknown-linux-gnuabi64
-mipsisa64r6el-unknown-linux-gnuabi64
-msp430-none-elf
-nvptx64-nvidia-cuda
-powerpc-unknown-freebsd
-powerpc-unknown-linux-gnu
-powerpc-unknown-linux-gnuspe
-powerpc-unknown-linux-musl
-powerpc-unknown-netbsd
-powerpc-unknown-openbsd
-powerpc-wrs-vxworks
-powerpc-wrs-vxworks-spe
-powerpc64-unknown-freebsd
-powerpc64-unknown-linux-gnu
-powerpc64-unknown-linux-musl
-powerpc64-wrs-vxworks
-powerpc64le-unknown-freebsd
-powerpc64le-unknown-linux-gnu
-powerpc64le-unknown-linux-musl
-riscv32gc-unknown-linux-gnu
-riscv32gc-unknown-linux-musl
-riscv32i-unknown-none-elf
-riscv32imac-unknown-none-elf
-riscv32imc-esp-espidf
-riscv32imc-unknown-none-elf
-riscv64gc-unknown-linux-gnu
-riscv64gc-unknown-linux-musl
-riscv64gc-unknown-none-elf
-riscv64imac-unknown-none-elf
-s390x-unknown-linux-gnu
-s390x-unknown-linux-musl
-sparc-unknown-linux-gnu
-sparc64-unknown-linux-gnu
-sparc64-unknown-netbsd
-sparc64-unknown-openbsd
-sparcv9-sun-solaris
-thumbv4t-none-eabi
-thumbv6m-none-eabi
-thumbv7a-pc-windows-msvc
-thumbv7a-uwp-windows-msvc
-thumbv7em-none-eabi
-thumbv7em-none-eabihf
-thumbv7m-none-eabi
-thumbv7neon-linux-androideabi
-thumbv7neon-unknown-linux-gnueabihf
-thumbv7neon-unknown-linux-musleabihf
-thumbv8m.base-none-eabi
-thumbv8m.main-none-eabi
-thumbv8m.main-none-eabihf
-wasm32-unknown-emscripten
-wasm32-unknown-unknown
-wasm32-wasi
-wasm64-unknown-unknown
-x86_64-apple-darwin
-x86_64-apple-ios
-x86_64-apple-ios-macabi
-x86_64-apple-tvos
-x86_64-fortanix-unknown-sgx
-x86_64-fuchsia
-x86_64-linux-android
-x86_64-pc-solaris
-x86_64-pc-windows-gnu
-x86_64-pc-windows-msvc
-x86_64-sun-solaris
-x86_64-unknown-dragonfly
-x86_64-unknown-freebsd
-x86_64-unknown-haiku
-x86_64-unknown-hermit
-x86_64-unknown-illumos
-x86_64-unknown-l4re-uclibc
-x86_64-unknown-linux-gnu
-x86_64-unknown-linux-gnux32
-x86_64-unknown-linux-musl
-x86_64-unknown-netbsd
-x86_64-unknown-none-hermitkernel
-x86_64-unknown-none-linuxkernel
-x86_64-unknown-openbsd
-x86_64-unknown-redox
-x86_64-unknown-uefi
-x86_64-uwp-windows-gnu
-x86_64-uwp-windows-msvc
-x86_64-wrs-vxworks
\ No newline at end of file
diff --git a/vendor/target-tuples/tests/sub_tests.rs b/vendor/target-tuples/tests/sub_tests.rs
deleted file mode 100644
index 2ee024b8..00000000
--- a/vendor/target-tuples/tests/sub_tests.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use std::fs::File;
-
-use std::io::{BufRead, BufReader};
-
-use target_tuples::Target;
-
-#[test]
-fn test_many_config_subs() -> std::io::Result<()> {
-    let f = BufReader::new(File::open(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/config-sub.data"
-    ))?);
-    for s in f.lines() {
-        let s = s?;
-        if s.trim().is_empty() {
-            continue;
-        }
-        let mut s = s.split('|');
-        let (k, v) = (s.next().unwrap(), s.next().unwrap());
-        let targ = Target::parse(k);
-        assert_eq!(targ.to_string(), v);
-    }
-
-    Ok(())
-}
-
-#[test]
-#[ignore]
-fn test_rustc_names() -> std::io::Result<()> {
-    let f = BufReader::new(File::open(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/rustc-targets.data"
-    ))?);
-    for s in f.lines() {
-        let s = s?;
-        if s.trim().is_empty() {
-            continue;
-        }
-        Target::parse(&s);
-    }
-    Ok(())
-}
-
-#[test]
-fn test_idempotency() -> std::io::Result<()> {
-    let f = BufReader::new(File::open(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/tests/config-sub.data"
-    ))?);
-    for s in f.lines() {
-        let s = s?;
-        let s = s.trim();
-        if s.is_empty() || s.starts_with('#') {
-            continue;
-        }
-        let mut s = s.split('|');
-        let (_, v) = (s.next().unwrap(), s.next().unwrap());
-        let targ = Target::parse(v);
-        assert_eq!(targ.to_string(), v);
-    }
-
-    Ok(())
-}
diff --git a/vendor/temp-file/.cargo-checksum.json b/vendor/temp-file/.cargo-checksum.json
deleted file mode 100644
index e38aad9c..00000000
--- a/vendor/temp-file/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"fe915a1bf85b82890f9f11eb7166ce1d3877a793f31d24afd549faeff09de5d7","LICENSE":"89e95b26e460adb453f5f240ea9ddfd1936b2f9d5948e91cce43dd4dc4b7a86d","Readme.md":"f023e5d4328c794092d960cd2919dd51d18deee65d7d98bcd7d4e6197ae2b231","src/lib.rs":"1fef0ff8c8c0c9a22d97fe0fb90f4913c194e2d15bc4513aeb369604e690c164","src/test.rs":"00b845266a0c8e9756e71f397a95fd4f47d4d4d4a95c8f84a1bbc79454e8c39c"},"package":"ee71da36831f42b12ba5fa8bf3fc7a54305f9091f1fcb2409a80ad29aaf06152"}
\ No newline at end of file
diff --git a/vendor/temp-file/Cargo.toml b/vendor/temp-file/Cargo.toml
deleted file mode 100644
index 8883f5b6..00000000
--- a/vendor/temp-file/Cargo.toml
+++ /dev/null
@@ -1,27 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "temp-file"
-version = "0.1.6"
-authors = ["Michael Leonhard <michael@leonhardllc.com>"]
-description = "Simple temporary file with cleanup"
-readme = "Readme.md"
-keywords = ["temp", "file", "tmpfile", "mktemp", "tempnam"]
-categories = ["filesystem", "development-tools::testing"]
-license = "Apache-2.0"
-repository = "https://gitlab.com/leonhard-llc/ops"
-
-[dependencies]
-[dev-dependencies.safe-lock]
-version = "^0.1"
diff --git a/vendor/temp-file/LICENSE b/vendor/temp-file/LICENSE
deleted file mode 100644
index 1583dc9a..00000000
--- a/vendor/temp-file/LICENSE
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright 2021 Leonhard LLC
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use these files except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
\ No newline at end of file
diff --git a/vendor/temp-file/Readme.md b/vendor/temp-file/Readme.md
deleted file mode 100644
index bb5c1cbe..00000000
--- a/vendor/temp-file/Readme.md
+++ /dev/null
@@ -1,98 +0,0 @@
-[![crates.io version](https://img.shields.io/crates/v/temp-file.svg)](https://crates.io/crates/temp-file)
-[![license: Apache 2.0](https://gitlab.com/leonhard-llc/ops/-/raw/main/license-apache-2.0.svg)](https://gitlab.com/leonhard-llc/ops/-/raw/main/temp-file/LICENSE)
-[![unsafe forbidden](https://gitlab.com/leonhard-llc/ops/-/raw/main/unsafe-forbidden.svg)](https://github.com/rust-secure-code/safety-dance/)
-[![pipeline status](https://gitlab.com/leonhard-llc/ops/badges/main/pipeline.svg)](https://gitlab.com/leonhard-llc/ops/-/pipelines)
-
-# temp-file
-
-Provides a `TempFile` struct.
-
-## Features
-- Makes a file in a system temporary directory
-- Deletes the file on drop
-- Optional file name prefix
-- Optional file contents
-- Depends only on `std`
-- `forbid(unsafe_code)`
-- 100% test coverage
-
-## Limitations
-- Not security-hardened. See
-  [Secure Programming for Linux and Unix HOWTO - 7.10. Avoid Race Conditions](https://tldp.org/HOWTO/Secure-Programs-HOWTO/avoid-race.html)
-  and [`mkstemp`](https://linux.die.net/man/3/mkstemp).
-
-## Alternatives
-- [`tempfile`](https://crates.io/crates/tempfile)
-  - Popular and mature
-  - Supports some security-sensitive use cases
-  - Contains `unsafe`, dependencies full of `unsafe`
-  - Heavy dependencies (libc, winapi, rand, etc.)
-- [`test-temp-file`](https://crates.io/crates/test-temp-file)
-  - Depends on crates which contain `unsafe`
-  - Incomplete documentation
-- [`temp_file_name`](https://crates.io/crates/temp_file_name)
-  - Does not delete file
-  - Usage is not straightforward.  Missing example.
-- [`mktemp`](https://crates.io/crates/mktemp)
-  - Sets file mode 0600 on unix
-  - Contains `unsafe`
-  - No readme or online docs
-
-## Related Crates
-- [`temp-dir`](https://crates.io/crates/temp-dir)
-
-## Example
-```rust
-let t = temp_file::with_contents(b"abc");
-// Prints "/tmp/1a9b0".
-println!("{:?}", t.path());
-assert_eq!(
-  "abc",
-  std::fs::read_to_string(t.path()).unwrap(),
-);
-// Prints "/tmp/1a9b1".
-println!("{:?}", temp_file::empty().path());
-```
-
-## Cargo Geiger Safety Report
-```
-
-Metric output format: x/y
-    x = unsafe code used by the build
-    y = total unsafe code found in the crate
-
-Symbols: 
-    🔒  = No `unsafe` usage found, declares #![forbid(unsafe_code)]
-    ❓  = No `unsafe` usage found, missing #![forbid(unsafe_code)]
-    ☢️  = `unsafe` usage found
-
-Functions  Expressions  Impls  Traits  Methods  Dependency
-
-0/0        0/0          0/0    0/0     0/0      🔒  temp-file 0.1.6
-
-0/0        0/0          0/0    0/0     0/0    
-
-```
-## Changelog
-- v0.1.6
-  - Return `std::io::Error` instead of `String`.
-  - Add
-    [`cleanup`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.cleanup).
-- v0.1.5 - Increase test coverage
-- v0.1.4 - Add
-  [`leak`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.leak)
-  and
-  [`panic_on_cleanup_error`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.panic_on_cleanup_error).
-- v0.1.3 - Update docs
-- v0.1.2 - Update example
-- v0.1.1 - Minor code cleanup, update docs
-- v0.1.0 - Initial version
-
-## Happy Contributors 🙂
-Fixing bugs and adding features is easy and fast.
-Send us a pull request and we intend to:
-- Always respond within 24 hours
-- Provide clear & concrete feedback
-- Immediately make a new release for your accepted change
-
-License: Apache-2.0
diff --git a/vendor/temp-file/src/lib.rs b/vendor/temp-file/src/lib.rs
deleted file mode 100644
index 4efdb8d7..00000000
--- a/vendor/temp-file/src/lib.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-//! [![crates.io version](https://img.shields.io/crates/v/temp-file.svg)](https://crates.io/crates/temp-file)
-//! [![license: Apache 2.0](https://gitlab.com/leonhard-llc/ops/-/raw/main/license-apache-2.0.svg)](https://gitlab.com/leonhard-llc/ops/-/raw/main/temp-file/LICENSE)
-//! [![unsafe forbidden](https://gitlab.com/leonhard-llc/ops/-/raw/main/unsafe-forbidden.svg)](https://github.com/rust-secure-code/safety-dance/)
-//! [![pipeline status](https://gitlab.com/leonhard-llc/ops/badges/main/pipeline.svg)](https://gitlab.com/leonhard-llc/ops/-/pipelines)
-//!
-//! # temp-file
-//!
-//! Provides a `TempFile` struct.
-//!
-//! ## Features
-//! - Makes a file in a system temporary directory
-//! - Deletes the file on drop
-//! - Optional file name prefix
-//! - Optional file contents
-//! - Depends only on `std`
-//! - `forbid(unsafe_code)`
-//! - 100% test coverage
-//!
-//! ## Limitations
-//! - Not security-hardened. See
-//!   [Secure Programming for Linux and Unix HOWTO - 7.10. Avoid Race Conditions](https://tldp.org/HOWTO/Secure-Programs-HOWTO/avoid-race.html)
-//!   and [`mkstemp`](https://linux.die.net/man/3/mkstemp).
-//!
-//! ## Alternatives
-//! - [`tempfile`](https://crates.io/crates/tempfile)
-//!   - Popular and mature
-//!   - Supports some security-sensitive use cases
-//!   - Contains `unsafe`, dependencies full of `unsafe`
-//!   - Heavy dependencies (libc, winapi, rand, etc.)
-//! - [`test-temp-file`](https://crates.io/crates/test-temp-file)
-//!   - Depends on crates which contain `unsafe`
-//!   - Incomplete documentation
-//! - [`temp_file_name`](https://crates.io/crates/temp_file_name)
-//!   - Does not delete file
-//!   - Usage is not straightforward.  Missing example.
-//! - [`mktemp`](https://crates.io/crates/mktemp)
-//!   - Sets file mode 0600 on unix
-//!   - Contains `unsafe`
-//!   - No readme or online docs
-//!
-//! ## Related Crates
-//! - [`temp-dir`](https://crates.io/crates/temp-dir)
-//!
-//! ## Example
-//! ```rust
-//! let t = temp_file::with_contents(b"abc");
-//! // Prints "/tmp/1a9b0".
-//! println!("{:?}", t.path());
-//! assert_eq!(
-//!   "abc",
-//!   std::fs::read_to_string(t.path()).unwrap(),
-//! );
-//! // Prints "/tmp/1a9b1".
-//! println!("{:?}", temp_file::empty().path());
-//! ```
-//!
-//! ## Cargo Geiger Safety Report
-//!
-//! ## Changelog
-//! - v0.1.6
-//!   - Return `std::io::Error` instead of `String`.
-//!   - Add
-//!     [`cleanup`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.cleanup).
-//! - v0.1.5 - Increase test coverage
-//! - v0.1.4 - Add
-//!   [`leak`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.leak)
-//!   and
-//!   [`panic_on_cleanup_error`](https://docs.rs/temp-file/latest/temp_file/struct.TempFile.html#method.panic_on_cleanup_error).
-//! - v0.1.3 - Update docs
-//! - v0.1.2 - Update example
-//! - v0.1.1 - Minor code cleanup, update docs
-//! - v0.1.0 - Initial version
-//!
-//! ## Happy Contributors 🙂
-//! Fixing bugs and adding features is easy and fast.
-//! Send us a pull request and we intend to:
-//! - Always respond within 24 hours
-//! - Provide clear & concrete feedback
-//! - Immediately make a new release for your accepted change
-#![forbid(unsafe_code)]
-// TODO(mleonhard) Implement features requested of `tempfile` crate:
-//   https://github.com/Stebalien/tempfile/issues
-use core::sync::atomic::{AtomicU32, Ordering};
-use std::path::{Path, PathBuf};
-
-static COUNTER: AtomicU32 = AtomicU32::new(0);
-
-/// The path of an existing writable file in a system temporary directory.
-///
-/// Deletes the file on drop.  Ignores errors deleting the file.
-///
-/// # Example
-/// ```rust
-/// use temp_file::TempFile;
-/// let t = TempFile::new()
-///   .unwrap()
-///   .with_contents(b"abc")
-///   .unwrap();
-/// // Prints "/tmp/1a9b0".
-/// println!("{:?}", t.path());
-/// assert_eq!(
-///   "abc",
-///   std::fs::read_to_string(t.path()).unwrap(),
-/// );
-/// // Prints "/tmp/1a9b1".
-/// println!("{:?}", TempFile::new().unwrap().path());
-/// ```
-#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Debug)]
-pub struct TempFile {
-    path_buf: Option<PathBuf>,
-    panic_on_delete_err: bool,
-}
-impl TempFile {
-    fn remove_file(path: &Path) -> Result<(), std::io::Error> {
-        match std::fs::remove_file(path) {
-            Ok(()) => Ok(()),
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
-            Err(e) => Err(std::io::Error::new(
-                e.kind(),
-                format!("error removing file {:?}: {}", path, e),
-            )),
-        }
-    }
-
-    /// Create a new empty file in a system temporary directory.
-    ///
-    /// Drop the returned struct to delete the file.
-    ///
-    /// # Errors
-    /// Returns `Err` when it fails to create the file.
-    ///
-    /// # Example
-    /// ```rust
-    /// // Prints "/tmp/1a9b0".
-    /// println!("{:?}", temp_file::TempFile::new().unwrap().path());
-    /// ```
-    pub fn new() -> Result<Self, std::io::Error> {
-        Self::with_prefix("")
-    }
-
-    /// Create a new empty file in a system temporary directory.
-    /// Use `prefix` as the first part of the file's name.
-    ///
-    /// Drop the returned struct to delete the file.
-    ///
-    /// # Errors
-    /// Returns `Err` when it fails to create the file.
-    ///
-    /// # Example
-    /// ```rust
-    /// // Prints "/tmp/ok1a9b0".
-    /// println!("{:?}", temp_file::TempFile::with_prefix("ok").unwrap().path());
-    /// ```
-    pub fn with_prefix(prefix: impl AsRef<str>) -> Result<Self, std::io::Error> {
-        let mut open_opts = std::fs::OpenOptions::new();
-        open_opts.create_new(true);
-        open_opts.write(true);
-        let path_buf = std::env::temp_dir().join(format!(
-            "{}{:x}{:x}",
-            prefix.as_ref(),
-            std::process::id(),
-            COUNTER.fetch_add(1, Ordering::AcqRel),
-        ));
-        open_opts.open(&path_buf).map_err(|e| {
-            std::io::Error::new(
-                e.kind(),
-                format!("error creating file {:?}: {}", &path_buf, e),
-            )
-        })?;
-        Ok(Self {
-            path_buf: Some(path_buf),
-            panic_on_delete_err: false,
-        })
-    }
-
-    /// Write `contents` to the file.
-    ///
-    /// # Errors
-    /// Returns `Err` when it fails to write all of `contents` to the file.
-    #[allow(clippy::missing_panics_doc)]
-    pub fn with_contents(self, contents: &[u8]) -> Result<Self, std::io::Error> {
-        let path = self.path_buf.as_ref().unwrap();
-        std::fs::write(path, contents).map_err(|e| {
-            std::io::Error::new(e.kind(), format!("error writing file {:?}: {}", path, e))
-        })?;
-        Ok(self)
-    }
-
-    /// Remove the file now.  Do nothing later on drop.
-    ///
-    /// # Errors
-    /// Returns an error if the file exists and we fail to remove it.
-    #[allow(clippy::missing_panics_doc)]
-    pub fn cleanup(mut self) -> Result<(), std::io::Error> {
-        Self::remove_file(&self.path_buf.take().unwrap())
-    }
-
-    /// Make the struct panic on Drop if it hits an error while
-    /// removing the file.
-    #[must_use]
-    pub fn panic_on_cleanup_error(mut self) -> Self {
-        Self {
-            path_buf: self.path_buf.take(),
-            panic_on_delete_err: true,
-        }
-    }
-
-    /// Do not delete the file.
-    ///
-    /// This is useful when debugging a test.
-    pub fn leak(mut self) {
-        self.path_buf.take();
-    }
-
-    /// The path to the file.
-    #[must_use]
-    #[allow(clippy::missing_panics_doc)]
-    pub fn path(&self) -> &Path {
-        self.path_buf.as_ref().unwrap()
-    }
-}
-impl Drop for TempFile {
-    fn drop(&mut self) {
-        if let Some(path) = self.path_buf.take() {
-            let result = Self::remove_file(&path);
-            if self.panic_on_delete_err {
-                if let Err(e) = result {
-                    panic!("{}", e);
-                }
-            }
-        }
-    }
-}
-
-/// Create a new empty file in a system temporary directory.
-///
-/// # Panics
-/// Panics if it cannot create the file.
-#[must_use]
-pub fn empty() -> TempFile {
-    TempFile::new().unwrap()
-}
-
-/// Create a new  file in a system temporary directory
-/// and writes `contents` to it.
-///
-/// # Panics
-/// Panics if it fails to create the file or fails to write all of `contents`.
-#[must_use]
-pub fn with_contents(contents: &[u8]) -> TempFile {
-    TempFile::new().unwrap().with_contents(contents).unwrap()
-}
-
-#[cfg(test)]
-mod test;
diff --git a/vendor/temp-file/src/test.rs b/vendor/temp-file/src/test.rs
deleted file mode 100644
index c94423a2..00000000
--- a/vendor/temp-file/src/test.rs
+++ /dev/null
@@ -1,273 +0,0 @@
-use crate::{TempFile, COUNTER};
-use core::sync::atomic::Ordering;
-use safe_lock::SafeLock;
-use std::io::ErrorKind;
-
-// The error tests require all tests to run single-threaded.
-static LOCK: SafeLock = SafeLock::new();
-
-#[test]
-fn empty() {
-    let _guard = LOCK.lock();
-    let temp_file = crate::empty();
-    let metadata = std::fs::metadata(temp_file.path()).unwrap();
-    assert!(metadata.is_file());
-    assert_eq!(0, metadata.len());
-    std::fs::write(temp_file.path(), b"abc").unwrap();
-    assert_eq!("abc", std::fs::read_to_string(temp_file.path()).unwrap());
-    let temp_file2 = crate::empty();
-    assert_ne!(temp_file.path(), temp_file2.path());
-}
-
-#[test]
-fn empty_error() {
-    let _guard = LOCK.lock();
-    let previous_counter_value = COUNTER.load(Ordering::SeqCst);
-    let _temp_file = crate::empty();
-    COUNTER.store(previous_counter_value, Ordering::SeqCst);
-    let any = std::panic::catch_unwind(|| crate::empty()).unwrap_err();
-    let msg = any.downcast_ref::<String>().unwrap();
-    assert!(
-        msg.contains("error creating file"),
-        "unexpected error {:?}",
-        msg
-    );
-    assert!(msg.contains("AlreadyExists"), "unexpected error {:?}", msg);
-}
-
-#[test]
-fn with_contents() {
-    let _guard = LOCK.lock();
-    let temp_file = crate::with_contents(b"abc");
-    let metadata = std::fs::metadata(temp_file.path()).unwrap();
-    assert!(metadata.is_file());
-    assert_eq!(3, metadata.len());
-    assert_eq!("abc", std::fs::read_to_string(temp_file.path()).unwrap());
-    std::fs::write(temp_file.path(), b"def").unwrap();
-    assert_eq!("def", std::fs::read_to_string(temp_file.path()).unwrap());
-}
-
-#[test]
-fn temp_file_new() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    println!("{:?}", temp_file.path());
-    println!("{:?}", TempFile::new().unwrap().path());
-    let metadata = std::fs::metadata(temp_file.path()).unwrap();
-    assert!(metadata.is_file());
-    assert_eq!(0, metadata.len());
-    std::fs::write(temp_file.path(), b"abc").unwrap();
-    assert_eq!("abc", std::fs::read_to_string(temp_file.path()).unwrap());
-    let temp_file2 = TempFile::new().unwrap();
-    assert_ne!(temp_file.path(), temp_file2.path());
-}
-
-#[test]
-fn temp_file_new_error() {
-    let _guard = LOCK.lock();
-    let previous_counter_value = COUNTER.load(Ordering::SeqCst);
-    let temp_file = TempFile::new().unwrap();
-    COUNTER.store(previous_counter_value, Ordering::SeqCst);
-    let e = TempFile::new().unwrap_err();
-    assert_eq!(std::io::ErrorKind::AlreadyExists, e.kind());
-    assert!(
-        e.to_string()
-            .starts_with(&format!("error creating file {:?}", temp_file.path())),
-        "unexpected error {:?}",
-        e
-    );
-}
-
-#[test]
-fn temp_file_with_prefix() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::with_prefix("prefix1").unwrap();
-    let name = temp_file.path().file_name().unwrap();
-    assert!(
-        name.to_str().unwrap().starts_with("prefix1"),
-        "{:?}",
-        temp_file
-    );
-    let metadata = std::fs::metadata(temp_file.path()).unwrap();
-    assert!(metadata.is_file());
-    assert_eq!(0, metadata.len());
-    std::fs::write(temp_file.path(), b"abc").unwrap();
-    assert_eq!("abc", std::fs::read_to_string(temp_file.path()).unwrap());
-    let temp_file2 = TempFile::new().unwrap();
-    assert_ne!(temp_file.path(), temp_file2.path());
-}
-
-#[test]
-fn temp_file_with_prefix_error() {
-    let _guard = LOCK.lock();
-    let previous_counter_value = COUNTER.load(Ordering::SeqCst);
-    let temp_file = TempFile::with_prefix("prefix1").unwrap();
-    COUNTER.store(previous_counter_value, Ordering::SeqCst);
-    let e = TempFile::with_prefix("prefix1").unwrap_err();
-    assert_eq!(std::io::ErrorKind::AlreadyExists, e.kind());
-    assert!(
-        e.to_string()
-            .starts_with(&format!("error creating file {:?}", temp_file.path())),
-        "unexpected error {:?}",
-        e
-    );
-}
-
-#[test]
-fn temp_file_with_contents() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap().with_contents(b"abc").unwrap();
-    let metadata = std::fs::metadata(temp_file.path()).unwrap();
-    assert!(metadata.is_file());
-    assert_eq!(3, metadata.len());
-    assert_eq!("abc", std::fs::read_to_string(temp_file.path()).unwrap());
-    std::fs::write(temp_file.path(), b"def").unwrap();
-    assert_eq!("def", std::fs::read_to_string(temp_file.path()).unwrap());
-}
-
-#[test]
-fn temp_file_with_contents_error() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    std::fs::remove_file(temp_file.path()).unwrap();
-    let temp_file_path = temp_file.path().to_path_buf();
-    std::fs::create_dir(&temp_file_path).unwrap();
-    let result = temp_file.with_contents(b"abc");
-    std::fs::remove_dir(&temp_file_path).unwrap();
-    let e = result.unwrap_err();
-    assert!(
-        e.to_string()
-            .starts_with(&format!("error writing file {:?}", temp_file_path)),
-        "unexpected error {:?}",
-        e
-    );
-}
-
-#[test]
-fn cleanup() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    let path = temp_file.path().to_path_buf();
-    temp_file.cleanup().unwrap();
-    assert_eq!(
-        ErrorKind::NotFound,
-        std::fs::metadata(&path).unwrap_err().kind()
-    );
-}
-
-#[test]
-fn leak_then_cleanup() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    let path = temp_file.path().to_path_buf();
-    temp_file.cleanup().unwrap();
-    assert_eq!(
-        ErrorKind::NotFound,
-        std::fs::metadata(&path).unwrap_err().kind()
-    );
-}
-
-#[test]
-fn cleanup_already_deleted() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    let path = temp_file.path().to_path_buf();
-    std::fs::remove_file(&path).unwrap();
-    temp_file.cleanup().unwrap();
-    assert_eq!(
-        ErrorKind::NotFound,
-        std::fs::metadata(&path).unwrap_err().kind()
-    );
-}
-
-#[test]
-fn cleanup_error() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    std::fs::remove_file(temp_file.path()).unwrap();
-    let path = temp_file.path().to_path_buf();
-    std::fs::create_dir(&path).unwrap();
-    let result = temp_file.cleanup();
-    std::fs::remove_dir(&path).unwrap();
-    let e = result.unwrap_err();
-    assert!(
-        e.to_string()
-            .starts_with(&format!("error removing file {:?}", path)),
-        "unexpected error {:?}",
-        e
-    );
-}
-
-#[test]
-fn test_drop() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    let path = temp_file.path().to_path_buf();
-    TempFile::new().unwrap();
-    drop(temp_file);
-    assert_eq!(
-        ErrorKind::NotFound,
-        std::fs::metadata(&path).unwrap_err().kind()
-    );
-}
-
-#[test]
-fn drop_already_deleted() {
-    let _guard = LOCK.lock();
-    let temp_file = TempFile::new().unwrap();
-    std::fs::remove_file(temp_file.path()).unwrap();
-}
-
-#[cfg(unix)]
-#[test]
-fn drop_error_ignored() {
-    // On Gitlab's shared CI runners, the cleanup always succeeds and the
-    // test fails.  So we skip this test when it's running on Gitlab CI.
-    if std::env::current_dir().unwrap().starts_with("/builds/") {
-        println!("Running on Gitlab CI.  Skipping test.");
-        return;
-    }
-    let _guard = LOCK.lock();
-    let f = crate::empty();
-    let path = f.path().to_path_buf();
-    std::fs::remove_file(&path).unwrap();
-    std::fs::create_dir(&path).unwrap();
-    drop(f);
-    std::fs::metadata(&path).unwrap();
-    std::fs::remove_dir(&path).unwrap();
-}
-
-#[cfg(unix)]
-#[test]
-fn drop_error_panic() {
-    // On Gitlab's shared CI runners, the cleanup always succeeds and the
-    // test fails.  So we skip this test when it's running on Gitlab CI.
-    if std::env::current_dir().unwrap().starts_with("/builds/") {
-        println!("Running on Gitlab CI.  Skipping test.");
-        return;
-    }
-    let _guard = LOCK.lock();
-    let f = crate::empty().panic_on_cleanup_error();
-    let path = f.path().to_path_buf();
-    std::fs::remove_file(&path).unwrap();
-    std::fs::create_dir(&path).unwrap();
-    let result = std::panic::catch_unwind(move || drop(f));
-    std::fs::metadata(&path).unwrap();
-    std::fs::remove_dir(&path).unwrap();
-    let msg = result.unwrap_err().downcast::<String>().unwrap();
-    assert!(
-        msg.contains("error removing file ",),
-        "unexpected panic message {:?}",
-        msg
-    );
-}
-
-#[test]
-fn leak() {
-    let _guard = LOCK.lock();
-    let f = crate::empty();
-    let path = f.path().to_path_buf();
-    f.leak();
-    std::fs::metadata(&path).unwrap();
-    std::fs::remove_file(&path).unwrap();
-}
diff --git a/vendor/toml/.cargo-checksum.json b/vendor/toml/.cargo-checksum.json
deleted file mode 100644
index a838696d..00000000
--- a/vendor/toml/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.lock":"31e67a5c5c6cb6691d3ac3b1e03ea1179117904824b1afae3440b455f6084e4a","Cargo.toml":"56fc89795010978955961d2c5ada22be5259c2ba27510cfea5958d6658846acf","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"9f9fabc5623932ee1ac3d4c7d00c01ce78d43e1b916844249b1991df28a58be0","examples/decode.rs":"196b30175566306e70bd4e9d62622772783b53253156d312c90095a3eaf2c817","examples/enum_external.rs":"ee4e5a989fcc9a5fb29f39ecb8a46715253321e54e5604e7c956b43465696a70","examples/toml2json.rs":"b0256e8393f91633abaa5b5c1ce496b73efee14a81b51e4f242aae967eaf9548","src/datetime.rs":"3a3642112bb67a6556686a19459dc1768fe6fe46ae6ddc1ef1a876318c93765b","src/de.rs":"862f283727bccb9368f3518e59c0f940f5016ca310c9ca10c44dbcd5b24281b9","src/lib.rs":"7cfff3e3073b6890c679654d4e1104734d1388b21618dded989818db2cd28f1d","src/macros.rs":"81a7e1b7884714cb23af28e9415f3fe35395820edad7a534c98593d5c940ec0c","src/map.rs":"ffc5539c8884baea62ed0e2ea89b018797c5e2d285f778f1d0e124a69ec29ddc","src/ser.rs":"5bf5e270eb0960fed0559e982dd23805bcbc14e47b1aa0543c95e997afa60851","src/spanned.rs":"01b8776279c1ef3fe2e81188e3e8f672430220482c5765178b57dac78522b1b3","src/tokens.rs":"9c1b92dac2c2397270af20c07812661677595936940e26bfebc6963d4fbb6502","src/value.rs":"b2f2985a29c53e0126959a251244e822397ac584e37f8537a775bd356b7f77fa","tests/enum_external_deserialize.rs":"32515d5fa80e36efed6006da6514b5054c5c903960d9d884866d608ce9d23c35"},"package":"a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"}
\ No newline at end of file
diff --git a/vendor/toml/Cargo.lock b/vendor/toml/Cargo.lock
deleted file mode 100644
index 67c84c07..00000000
--- a/vendor/toml/Cargo.lock
+++ /dev/null
@@ -1,101 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "autocfg"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
-
-[[package]]
-name = "indexmap"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712d7b3ea5827fcb9d4fda14bf4da5f136f0db2ae9c8f4bd4e2d1c6fde4e6db2"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
-
-[[package]]
-name = "proc-macro2"
-version = "0.4.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quote"
-version = "0.6.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "ryu"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
-
-[[package]]
-name = "serde"
-version = "1.0.98"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe5626ac617da2f2d9c48af5515a21d5a480dbd151e01bb1c355e26a3e68113"
-
-[[package]]
-name = "serde_derive"
-version = "1.0.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4d6115a3ca25c224e409185325afc16a0d5aaaabc15c42b09587d6f1ba39a5b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf540260cfee6da923831f4776ddc495ada940c30117977c70f1313a6130545"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "0.15.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "734ecc29cd36e8123850d9bf21dfd62ef8300aaa8f879aabaa899721808be37c"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-dependencies = [
- "indexmap",
- "serde",
- "serde_derive",
- "serde_json",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
diff --git a/vendor/toml/Cargo.toml b/vendor/toml/Cargo.toml
deleted file mode 100644
index ab91710e..00000000
--- a/vendor/toml/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "toml"
-version = "0.5.8"
-authors = ["Alex Crichton <alex@alexcrichton.com>"]
-description = "A native Rust encoder and decoder of TOML-formatted files and streams. Provides\nimplementations of the standard Serialize/Deserialize traits for TOML data to\nfacilitate deserializing and serializing Rust structures.\n"
-homepage = "https://github.com/alexcrichton/toml-rs"
-documentation = "https://docs.rs/toml"
-readme = "README.md"
-keywords = ["encoding"]
-categories = ["config", "encoding", "parser-implementations"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/alexcrichton/toml-rs"
-[dependencies.indexmap]
-version = "1.0"
-optional = true
-
-[dependencies.serde]
-version = "1.0.97"
-[dev-dependencies.serde_derive]
-version = "1.0"
-
-[dev-dependencies.serde_json]
-version = "1.0"
-
-[features]
-default = []
-preserve_order = ["indexmap"]
diff --git a/vendor/toml/LICENSE-APACHE b/vendor/toml/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/toml/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/toml/LICENSE-MIT b/vendor/toml/LICENSE-MIT
deleted file mode 100644
index 39e0ed66..00000000
--- a/vendor/toml/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 Alex Crichton
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/toml/README.md b/vendor/toml/README.md
deleted file mode 100644
index 21dd1088..00000000
--- a/vendor/toml/README.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# toml-rs
-
-[![Latest Version](https://img.shields.io/crates/v/toml.svg)](https://crates.io/crates/toml)
-[![Documentation](https://docs.rs/toml/badge.svg)](https://docs.rs/toml)
-
-A [TOML][toml] decoder and encoder for Rust. This library is currently compliant
-with the v0.5.0 version of TOML. This library will also likely continue to stay
-up to date with the TOML specification as changes happen.
-
-[toml]: https://github.com/toml-lang/toml
-
-```toml
-# Cargo.toml
-[dependencies]
-toml = "0.5"
-```
-
-This crate also supports serialization/deserialization through the
-[serde](https://serde.rs) crate on crates.io. Currently the older `rustc-serialize`
-crate is not supported in the 0.3+ series of the `toml` crate, but 0.2 can be
-used for that support.
-
-# License
-
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in toml-rs by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
diff --git a/vendor/toml/examples/decode.rs b/vendor/toml/examples/decode.rs
deleted file mode 100644
index b5d6a991..00000000
--- a/vendor/toml/examples/decode.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! An example showing off the usage of `Deserialize` to automatically decode
-//! TOML into a Rust `struct`
-
-#![deny(warnings)]
-
-use serde_derive::Deserialize;
-
-/// This is what we're going to decode into. Each field is optional, meaning
-/// that it doesn't have to be present in TOML.
-#[derive(Debug, Deserialize)]
-struct Config {
-    global_string: Option<String>,
-    global_integer: Option<u64>,
-    server: Option<ServerConfig>,
-    peers: Option<Vec<PeerConfig>>,
-}
-
-/// Sub-structs are decoded from tables, so this will decode from the `[server]`
-/// table.
-///
-/// Again, each field is optional, meaning they don't have to be present.
-#[derive(Debug, Deserialize)]
-struct ServerConfig {
-    ip: Option<String>,
-    port: Option<u64>,
-}
-
-#[derive(Debug, Deserialize)]
-struct PeerConfig {
-    ip: Option<String>,
-    port: Option<u64>,
-}
-
-fn main() {
-    let toml_str = r#"
-        global_string = "test"
-        global_integer = 5
-
-        [server]
-        ip = "127.0.0.1"
-        port = 80
-
-        [[peers]]
-        ip = "127.0.0.1"
-        port = 8080
-
-        [[peers]]
-        ip = "127.0.0.1"
-    "#;
-
-    let decoded: Config = toml::from_str(toml_str).unwrap();
-    println!("{:#?}", decoded);
-}
diff --git a/vendor/toml/examples/enum_external.rs b/vendor/toml/examples/enum_external.rs
deleted file mode 100644
index a7dd84ab..00000000
--- a/vendor/toml/examples/enum_external.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! An example showing off the usage of `Deserialize` to automatically decode
-//! TOML into a Rust `struct`, with enums.
-
-#![deny(warnings)]
-
-use serde_derive::Deserialize;
-
-/// This is what we're going to decode into.
-#[derive(Debug, Deserialize)]
-struct Config {
-    plain: MyEnum,
-    plain_table: MyEnum,
-    tuple: MyEnum,
-    #[serde(rename = "struct")]
-    structv: MyEnum,
-    newtype: MyEnum,
-    my_enum: Vec<MyEnum>,
-}
-
-#[derive(Debug, Deserialize)]
-enum MyEnum {
-    Plain,
-    Tuple(i64, bool),
-    NewType(String),
-    Struct { value: i64 },
-}
-
-fn main() {
-    let toml_str = r#"
-    plain = "Plain"
-    plain_table = { Plain = {} }
-    tuple = { Tuple = { 0 = 123, 1 = true } }
-    struct = { Struct = { value = 123 } }
-    newtype = { NewType = "value" }
-    my_enum = [
-        { Plain = {} },
-        { Tuple = { 0 = 123, 1 = true } },
-        { NewType = "value" },
-        { Struct = { value = 123 } }
-    ]"#;
-
-    let decoded: Config = toml::from_str(toml_str).unwrap();
-    println!("{:#?}", decoded);
-}
diff --git a/vendor/toml/examples/toml2json.rs b/vendor/toml/examples/toml2json.rs
deleted file mode 100644
index 1b90c9fd..00000000
--- a/vendor/toml/examples/toml2json.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![deny(warnings)]
-
-use std::env;
-use std::fs::File;
-use std::io;
-use std::io::prelude::*;
-
-use serde_json::Value as Json;
-use toml::Value as Toml;
-
-fn main() {
-    let mut args = env::args();
-    let mut input = String::new();
-    if args.len() > 1 {
-        let name = args.nth(1).unwrap();
-        File::open(&name)
-            .and_then(|mut f| f.read_to_string(&mut input))
-            .unwrap();
-    } else {
-        io::stdin().read_to_string(&mut input).unwrap();
-    }
-
-    match input.parse() {
-        Ok(toml) => {
-            let json = convert(toml);
-            println!("{}", serde_json::to_string_pretty(&json).unwrap());
-        }
-        Err(error) => println!("failed to parse TOML: {}", error),
-    }
-}
-
-fn convert(toml: Toml) -> Json {
-    match toml {
-        Toml::String(s) => Json::String(s),
-        Toml::Integer(i) => Json::Number(i.into()),
-        Toml::Float(f) => {
-            let n = serde_json::Number::from_f64(f).expect("float infinite and nan not allowed");
-            Json::Number(n)
-        }
-        Toml::Boolean(b) => Json::Bool(b),
-        Toml::Array(arr) => Json::Array(arr.into_iter().map(convert).collect()),
-        Toml::Table(table) => {
-            Json::Object(table.into_iter().map(|(k, v)| (k, convert(v))).collect())
-        }
-        Toml::Datetime(dt) => Json::String(dt.to_string()),
-    }
-}
diff --git a/vendor/toml/src/datetime.rs b/vendor/toml/src/datetime.rs
deleted file mode 100644
index bbaa30c4..00000000
--- a/vendor/toml/src/datetime.rs
+++ /dev/null
@@ -1,425 +0,0 @@
-use std::error;
-use std::fmt;
-use std::str::{self, FromStr};
-
-use serde::{de, ser};
-
-/// A parsed TOML datetime value
-///
-/// This structure is intended to represent the datetime primitive type that can
-/// be encoded into TOML documents. This type is a parsed version that contains
-/// all metadata internally.
-///
-/// Currently this type is intentionally conservative and only supports
-/// `to_string` as an accessor. Over time though it's intended that it'll grow
-/// more support!
-///
-/// Note that if you're using `Deserialize` to deserialize a TOML document, you
-/// can use this as a placeholder for where you're expecting a datetime to be
-/// specified.
-///
-/// Also note though that while this type implements `Serialize` and
-/// `Deserialize` it's only recommended to use this type with the TOML format,
-/// otherwise encoded in other formats it may look a little odd.
-#[derive(PartialEq, Clone)]
-pub struct Datetime {
-    date: Option<Date>,
-    time: Option<Time>,
-    offset: Option<Offset>,
-}
-
-/// Error returned from parsing a `Datetime` in the `FromStr` implementation.
-#[derive(Debug, Clone)]
-pub struct DatetimeParseError {
-    _private: (),
-}
-
-// Currently serde itself doesn't have a datetime type, so we map our `Datetime`
-// to a special valid in the serde data model. Namely one with thiese special
-// fields/struct names.
-//
-// In general the TOML encoder/decoder will catch this and not literally emit
-// these strings but rather emit datetimes as they're intended.
-pub const FIELD: &str = "$__toml_private_datetime";
-pub const NAME: &str = "$__toml_private_Datetime";
-
-#[derive(PartialEq, Clone)]
-struct Date {
-    year: u16,
-    month: u8,
-    day: u8,
-}
-
-#[derive(PartialEq, Clone)]
-struct Time {
-    hour: u8,
-    minute: u8,
-    second: u8,
-    nanosecond: u32,
-}
-
-#[derive(PartialEq, Clone)]
-enum Offset {
-    Z,
-    Custom { hours: i8, minutes: u8 },
-}
-
-impl fmt::Debug for Datetime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-impl fmt::Display for Datetime {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(ref date) = self.date {
-            write!(f, "{}", date)?;
-        }
-        if let Some(ref time) = self.time {
-            if self.date.is_some() {
-                write!(f, "T")?;
-            }
-            write!(f, "{}", time)?;
-        }
-        if let Some(ref offset) = self.offset {
-            write!(f, "{}", offset)?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for Date {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
-    }
-}
-
-impl fmt::Display for Time {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:02}:{:02}:{:02}", self.hour, self.minute, self.second)?;
-        if self.nanosecond != 0 {
-            let s = format!("{:09}", self.nanosecond);
-            write!(f, ".{}", s.trim_end_matches('0'))?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Display for Offset {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Offset::Z => write!(f, "Z"),
-            Offset::Custom { hours, minutes } => write!(f, "{:+03}:{:02}", hours, minutes),
-        }
-    }
-}
-
-impl FromStr for Datetime {
-    type Err = DatetimeParseError;
-
-    fn from_str(date: &str) -> Result<Datetime, DatetimeParseError> {
-        // Accepted formats:
-        //
-        // 0000-00-00T00:00:00.00Z
-        // 0000-00-00T00:00:00.00
-        // 0000-00-00
-        // 00:00:00.00
-        if date.len() < 3 {
-            return Err(DatetimeParseError { _private: () });
-        }
-        let mut offset_allowed = true;
-        let mut chars = date.chars();
-
-        // First up, parse the full date if we can
-        let full_date = if chars.clone().nth(2) == Some(':') {
-            offset_allowed = false;
-            None
-        } else {
-            let y1 = u16::from(digit(&mut chars)?);
-            let y2 = u16::from(digit(&mut chars)?);
-            let y3 = u16::from(digit(&mut chars)?);
-            let y4 = u16::from(digit(&mut chars)?);
-
-            match chars.next() {
-                Some('-') => {}
-                _ => return Err(DatetimeParseError { _private: () }),
-            }
-
-            let m1 = digit(&mut chars)?;
-            let m2 = digit(&mut chars)?;
-
-            match chars.next() {
-                Some('-') => {}
-                _ => return Err(DatetimeParseError { _private: () }),
-            }
-
-            let d1 = digit(&mut chars)?;
-            let d2 = digit(&mut chars)?;
-
-            let date = Date {
-                year: y1 * 1000 + y2 * 100 + y3 * 10 + y4,
-                month: m1 * 10 + m2,
-                day: d1 * 10 + d2,
-            };
-
-            if date.month < 1 || date.month > 12 {
-                return Err(DatetimeParseError { _private: () });
-            }
-            if date.day < 1 || date.day > 31 {
-                return Err(DatetimeParseError { _private: () });
-            }
-
-            Some(date)
-        };
-
-        // Next parse the "partial-time" if available
-        let next = chars.clone().next();
-        let partial_time = if full_date.is_some()
-            && (next == Some('T') || next == Some('t') || next == Some(' '))
-        {
-            chars.next();
-            true
-        } else {
-            full_date.is_none()
-        };
-
-        let time = if partial_time {
-            let h1 = digit(&mut chars)?;
-            let h2 = digit(&mut chars)?;
-            match chars.next() {
-                Some(':') => {}
-                _ => return Err(DatetimeParseError { _private: () }),
-            }
-            let m1 = digit(&mut chars)?;
-            let m2 = digit(&mut chars)?;
-            match chars.next() {
-                Some(':') => {}
-                _ => return Err(DatetimeParseError { _private: () }),
-            }
-            let s1 = digit(&mut chars)?;
-            let s2 = digit(&mut chars)?;
-
-            let mut nanosecond = 0;
-            if chars.clone().next() == Some('.') {
-                chars.next();
-                let whole = chars.as_str();
-
-                let mut end = whole.len();
-                for (i, byte) in whole.bytes().enumerate() {
-                    match byte {
-                        b'0'..=b'9' => {
-                            if i < 9 {
-                                let p = 10_u32.pow(8 - i as u32);
-                                nanosecond += p * u32::from(byte - b'0');
-                            }
-                        }
-                        _ => {
-                            end = i;
-                            break;
-                        }
-                    }
-                }
-                if end == 0 {
-                    return Err(DatetimeParseError { _private: () });
-                }
-                chars = whole[end..].chars();
-            }
-
-            let time = Time {
-                hour: h1 * 10 + h2,
-                minute: m1 * 10 + m2,
-                second: s1 * 10 + s2,
-                nanosecond,
-            };
-
-            if time.hour > 24 {
-                return Err(DatetimeParseError { _private: () });
-            }
-            if time.minute > 59 {
-                return Err(DatetimeParseError { _private: () });
-            }
-            if time.second > 59 {
-                return Err(DatetimeParseError { _private: () });
-            }
-            if time.nanosecond > 999_999_999 {
-                return Err(DatetimeParseError { _private: () });
-            }
-
-            Some(time)
-        } else {
-            offset_allowed = false;
-            None
-        };
-
-        // And finally, parse the offset
-        let offset = if offset_allowed {
-            let next = chars.clone().next();
-            if next == Some('Z') || next == Some('z') {
-                chars.next();
-                Some(Offset::Z)
-            } else if next.is_none() {
-                None
-            } else {
-                let sign = match next {
-                    Some('+') => 1,
-                    Some('-') => -1,
-                    _ => return Err(DatetimeParseError { _private: () }),
-                };
-                chars.next();
-                let h1 = digit(&mut chars)? as i8;
-                let h2 = digit(&mut chars)? as i8;
-                match chars.next() {
-                    Some(':') => {}
-                    _ => return Err(DatetimeParseError { _private: () }),
-                }
-                let m1 = digit(&mut chars)?;
-                let m2 = digit(&mut chars)?;
-
-                Some(Offset::Custom {
-                    hours: sign * (h1 * 10 + h2),
-                    minutes: m1 * 10 + m2,
-                })
-            }
-        } else {
-            None
-        };
-
-        // Return an error if we didn't hit eof, otherwise return our parsed
-        // date
-        if chars.next().is_some() {
-            return Err(DatetimeParseError { _private: () });
-        }
-
-        Ok(Datetime {
-            date: full_date,
-            time,
-            offset,
-        })
-    }
-}
-
-fn digit(chars: &mut str::Chars<'_>) -> Result<u8, DatetimeParseError> {
-    match chars.next() {
-        Some(c) if '0' <= c && c <= '9' => Ok(c as u8 - b'0'),
-        _ => Err(DatetimeParseError { _private: () }),
-    }
-}
-
-impl ser::Serialize for Datetime {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: ser::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut s = serializer.serialize_struct(NAME, 1)?;
-        s.serialize_field(FIELD, &self.to_string())?;
-        s.end()
-    }
-}
-
-impl<'de> de::Deserialize<'de> for Datetime {
-    fn deserialize<D>(deserializer: D) -> Result<Datetime, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct DatetimeVisitor;
-
-        impl<'de> de::Visitor<'de> for DatetimeVisitor {
-            type Value = Datetime;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a TOML datetime")
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let value = visitor.next_key::<DatetimeKey>()?;
-                if value.is_none() {
-                    return Err(de::Error::custom("datetime key not found"));
-                }
-                let v: DatetimeFromString = visitor.next_value()?;
-                Ok(v.value)
-            }
-        }
-
-        static FIELDS: [&str; 1] = [FIELD];
-        deserializer.deserialize_struct(NAME, &FIELDS, DatetimeVisitor)
-    }
-}
-
-struct DatetimeKey;
-
-impl<'de> de::Deserialize<'de> for DatetimeKey {
-    fn deserialize<D>(deserializer: D) -> Result<DatetimeKey, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct FieldVisitor;
-
-        impl<'de> de::Visitor<'de> for FieldVisitor {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a valid datetime field")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<(), E>
-            where
-                E: de::Error,
-            {
-                if s == FIELD {
-                    Ok(())
-                } else {
-                    Err(de::Error::custom("expected field with custom name"))
-                }
-            }
-        }
-
-        deserializer.deserialize_identifier(FieldVisitor)?;
-        Ok(DatetimeKey)
-    }
-}
-
-pub struct DatetimeFromString {
-    pub value: Datetime,
-}
-
-impl<'de> de::Deserialize<'de> for DatetimeFromString {
-    fn deserialize<D>(deserializer: D) -> Result<DatetimeFromString, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct Visitor;
-
-        impl<'de> de::Visitor<'de> for Visitor {
-            type Value = DatetimeFromString;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("string containing a datetime")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<DatetimeFromString, E>
-            where
-                E: de::Error,
-            {
-                match s.parse() {
-                    Ok(date) => Ok(DatetimeFromString { value: date }),
-                    Err(e) => Err(de::Error::custom(e)),
-                }
-            }
-        }
-
-        deserializer.deserialize_str(Visitor)
-    }
-}
-
-impl fmt::Display for DatetimeParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "failed to parse datetime".fmt(f)
-    }
-}
-
-impl error::Error for DatetimeParseError {}
diff --git a/vendor/toml/src/de.rs b/vendor/toml/src/de.rs
deleted file mode 100644
index 64112932..00000000
--- a/vendor/toml/src/de.rs
+++ /dev/null
@@ -1,2263 +0,0 @@
-//! Deserializing TOML into Rust structures.
-//!
-//! This module contains all the Serde support for deserializing TOML documents
-//! into Rust structures. Note that some top-level functions here are also
-//! provided at the top of the crate.
-
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::error;
-use std::f64;
-use std::fmt;
-use std::iter;
-use std::marker::PhantomData;
-use std::str;
-use std::vec;
-
-use serde::de;
-use serde::de::value::BorrowedStrDeserializer;
-use serde::de::IntoDeserializer;
-
-use crate::datetime;
-use crate::spanned;
-use crate::tokens::{Error as TokenError, Span, Token, Tokenizer};
-
-/// Type Alias for a TOML Table pair
-type TablePair<'a> = ((Span, Cow<'a, str>), Value<'a>);
-
-/// Deserializes a byte slice into a type.
-///
-/// This function will attempt to interpret `bytes` as UTF-8 data and then
-/// deserialize `T` from the TOML document provided.
-pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
-where
-    T: de::Deserialize<'de>,
-{
-    match str::from_utf8(bytes) {
-        Ok(s) => from_str(s),
-        Err(e) => Err(Error::custom(None, e.to_string())),
-    }
-}
-
-/// Deserializes a string into a type.
-///
-/// This function will attempt to interpret `s` as a TOML document and
-/// deserialize `T` from the document.
-///
-/// # Examples
-///
-/// ```
-/// use serde_derive::Deserialize;
-///
-/// #[derive(Deserialize)]
-/// struct Config {
-///     title: String,
-///     owner: Owner,
-/// }
-///
-/// #[derive(Deserialize)]
-/// struct Owner {
-///     name: String,
-/// }
-///
-/// fn main() {
-///     let config: Config = toml::from_str(r#"
-///         title = 'TOML Example'
-///
-///         [owner]
-///         name = 'Lisa'
-///     "#).unwrap();
-///
-///     assert_eq!(config.title, "TOML Example");
-///     assert_eq!(config.owner.name, "Lisa");
-/// }
-/// ```
-pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
-where
-    T: de::Deserialize<'de>,
-{
-    let mut d = Deserializer::new(s);
-    let ret = T::deserialize(&mut d)?;
-    d.end()?;
-    Ok(ret)
-}
-
-/// Errors that can occur when deserializing a type.
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct Error {
-    inner: Box<ErrorInner>,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-struct ErrorInner {
-    kind: ErrorKind,
-    line: Option<usize>,
-    col: usize,
-    at: Option<usize>,
-    message: String,
-    key: Vec<String>,
-}
-
-/// Errors that can occur when deserializing a type.
-#[derive(Debug, PartialEq, Eq, Clone)]
-enum ErrorKind {
-    /// EOF was reached when looking for a value
-    UnexpectedEof,
-
-    /// An invalid character not allowed in a string was found
-    InvalidCharInString(char),
-
-    /// An invalid character was found as an escape
-    InvalidEscape(char),
-
-    /// An invalid character was found in a hex escape
-    InvalidHexEscape(char),
-
-    /// An invalid escape value was specified in a hex escape in a string.
-    ///
-    /// Valid values are in the plane of unicode codepoints.
-    InvalidEscapeValue(u32),
-
-    /// A newline in a string was encountered when one was not allowed.
-    NewlineInString,
-
-    /// An unexpected character was encountered, typically when looking for a
-    /// value.
-    Unexpected(char),
-
-    /// An unterminated string was found where EOF was found before the ending
-    /// EOF mark.
-    UnterminatedString,
-
-    /// A newline was found in a table key.
-    NewlineInTableKey,
-
-    /// A number failed to parse
-    NumberInvalid,
-
-    /// A date or datetime was invalid
-    DateInvalid,
-
-    /// Wanted one sort of token, but found another.
-    Wanted {
-        /// Expected token type
-        expected: &'static str,
-        /// Actually found token type
-        found: &'static str,
-    },
-
-    /// A duplicate table definition was found.
-    DuplicateTable(String),
-
-    /// A previously defined table was redefined as an array.
-    RedefineAsArray,
-
-    /// An empty table key was found.
-    EmptyTableKey,
-
-    /// Multiline strings are not allowed for key
-    MultilineStringKey,
-
-    /// A custom error which could be generated when deserializing a particular
-    /// type.
-    Custom,
-
-    /// A tuple with a certain number of elements was expected but something
-    /// else was found.
-    ExpectedTuple(usize),
-
-    /// Expected table keys to be in increasing tuple index order, but something
-    /// else was found.
-    ExpectedTupleIndex {
-        /// Expected index.
-        expected: usize,
-        /// Key that was specified.
-        found: String,
-    },
-
-    /// An empty table was expected but entries were found
-    ExpectedEmptyTable,
-
-    /// Dotted key attempted to extend something that is not a table.
-    DottedKeyInvalidType,
-
-    /// An unexpected key was encountered.
-    ///
-    /// Used when deserializing a struct with a limited set of fields.
-    UnexpectedKeys {
-        /// The unexpected keys.
-        keys: Vec<String>,
-        /// Keys that may be specified.
-        available: &'static [&'static str],
-    },
-
-    /// Unquoted string was found when quoted one was expected
-    UnquotedString,
-
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-/// Deserialization implementation for TOML.
-pub struct Deserializer<'a> {
-    require_newline_after_table: bool,
-    allow_duplciate_after_longer_table: bool,
-    input: &'a str,
-    tokens: Tokenizer<'a>,
-}
-
-impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let mut tables = self.tables()?;
-        let table_indices = build_table_indices(&tables);
-        let table_pindices = build_table_pindices(&tables);
-
-        let res = visitor.visit_map(MapVisitor {
-            values: Vec::new().into_iter().peekable(),
-            next_value: None,
-            depth: 0,
-            cur: 0,
-            cur_parent: 0,
-            max: tables.len(),
-            table_indices: &table_indices,
-            table_pindices: &table_pindices,
-            tables: &mut tables,
-            array: false,
-            de: self,
-        });
-        res.map_err(|mut err| {
-            // Errors originating from this library (toml), have an offset
-            // attached to them already. Other errors, like those originating
-            // from serde (like "missing field") or from a custom deserializer,
-            // do not have offsets on them. Here, we do a best guess at their
-            // location, by attributing them to the "current table" (the last
-            // item in `tables`).
-            err.fix_offset(|| tables.last().map(|table| table.at));
-            err.fix_linecol(|at| self.to_linecol(at));
-            err
-        })
-    }
-
-    // Called when the type to deserialize is an enum, as opposed to a field in the type.
-    fn deserialize_enum<V>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let (value, name) = self.string_or_table()?;
-        match value.e {
-            E::String(val) => visitor.visit_enum(val.into_deserializer()),
-            E::InlineTable(values) => {
-                if values.len() != 1 {
-                    Err(Error::from_kind(
-                        Some(value.start),
-                        ErrorKind::Wanted {
-                            expected: "exactly 1 element",
-                            found: if values.is_empty() {
-                                "zero elements"
-                            } else {
-                                "more than 1 element"
-                            },
-                        },
-                    ))
-                } else {
-                    visitor.visit_enum(InlineTableDeserializer {
-                        values: values.into_iter(),
-                        next_value: None,
-                    })
-                }
-            }
-            E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
-                name: name.expect("Expected table header to be passed."),
-                value,
-            }),
-            e => Err(Error::from_kind(
-                Some(value.start),
-                ErrorKind::Wanted {
-                    expected: "string or table",
-                    found: e.type_name(),
-                },
-            )),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
-            let start = 0;
-            let end = self.input.len();
-
-            let res = visitor.visit_map(SpannedDeserializer {
-                phantom_data: PhantomData,
-                start: Some(start),
-                value: Some(self),
-                end: Some(end),
-            });
-            return res;
-        }
-
-        self.deserialize_any(visitor)
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map unit newtype_struct
-        ignored_any unit_struct tuple_struct tuple option identifier
-    }
-}
-
-// Builds a datastructure that allows for efficient sublinear lookups.
-// The returned HashMap contains a mapping from table header (like [a.b.c])
-// to list of tables with that precise name. The tables are being identified
-// by their index in the passed slice. We use a list as the implementation
-// uses this data structure for arrays as well as tables,
-// so if any top level [[name]] array contains multiple entries,
-// there are multiple entires in the list.
-// The lookup is performed in the `SeqAccess` implementation of `MapVisitor`.
-// The lists are ordered, which we exploit in the search code by using
-// bisection.
-fn build_table_indices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
-    let mut res = HashMap::new();
-    for (i, table) in tables.iter().enumerate() {
-        let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
-        res.entry(header).or_insert_with(Vec::new).push(i);
-    }
-    res
-}
-
-// Builds a datastructure that allows for efficient sublinear lookups.
-// The returned HashMap contains a mapping from table header (like [a.b.c])
-// to list of tables whose name at least starts with the specified
-// name. So searching for [a.b] would give both [a.b.c.d] as well as [a.b.e].
-// The tables are being identified by their index in the passed slice.
-//
-// A list is used for two reasons: First, the implementation also
-// stores arrays in the same data structure and any top level array
-// of size 2 or greater creates multiple entries in the list with the
-// same shared name. Second, there can be multiple tables sharing
-// the same prefix.
-//
-// The lookup is performed in the `MapAccess` implementation of `MapVisitor`.
-// The lists are ordered, which we exploit in the search code by using
-// bisection.
-fn build_table_pindices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
-    let mut res = HashMap::new();
-    for (i, table) in tables.iter().enumerate() {
-        let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
-        for len in 0..=header.len() {
-            res.entry(header[..len].to_owned())
-                .or_insert_with(Vec::new)
-                .push(i);
-        }
-    }
-    res
-}
-
-fn headers_equal<'a, 'b>(hdr_a: &[(Span, Cow<'a, str>)], hdr_b: &[(Span, Cow<'b, str>)]) -> bool {
-    if hdr_a.len() != hdr_b.len() {
-        return false;
-    }
-    hdr_a.iter().zip(hdr_b.iter()).all(|(h1, h2)| h1.1 == h2.1)
-}
-
-struct Table<'a> {
-    at: usize,
-    header: Vec<(Span, Cow<'a, str>)>,
-    values: Option<Vec<TablePair<'a>>>,
-    array: bool,
-}
-
-struct MapVisitor<'de, 'b> {
-    values: iter::Peekable<vec::IntoIter<TablePair<'de>>>,
-    next_value: Option<TablePair<'de>>,
-    depth: usize,
-    cur: usize,
-    cur_parent: usize,
-    max: usize,
-    table_indices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
-    table_pindices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
-    tables: &'b mut [Table<'de>],
-    array: bool,
-    de: &'b mut Deserializer<'de>,
-}
-
-impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.cur_parent == self.max || self.cur == self.max {
-            return Ok(None);
-        }
-
-        loop {
-            assert!(self.next_value.is_none());
-            if let Some((key, value)) = self.values.next() {
-                let ret = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
-                self.next_value = Some((key, value));
-                return Ok(Some(ret));
-            }
-
-            let next_table = {
-                let prefix_stripped = self.tables[self.cur_parent].header[..self.depth]
-                    .iter()
-                    .map(|v| v.1.clone())
-                    .collect::<Vec<_>>();
-                self.table_pindices
-                    .get(&prefix_stripped)
-                    .and_then(|entries| {
-                        let start = entries.binary_search(&self.cur).unwrap_or_else(|v| v);
-                        if start == entries.len() || entries[start] < self.cur {
-                            return None;
-                        }
-                        entries[start..]
-                            .iter()
-                            .filter_map(|i| if *i < self.max { Some(*i) } else { None })
-                            .map(|i| (i, &self.tables[i]))
-                            .find(|(_, table)| table.values.is_some())
-                            .map(|p| p.0)
-                    })
-            };
-
-            let pos = match next_table {
-                Some(pos) => pos,
-                None => return Ok(None),
-            };
-            self.cur = pos;
-
-            // Test to see if we're duplicating our parent's table, and if so
-            // then this is an error in the toml format
-            if self.cur_parent != pos {
-                if headers_equal(
-                    &self.tables[self.cur_parent].header,
-                    &self.tables[pos].header,
-                ) {
-                    let at = self.tables[pos].at;
-                    let name = self.tables[pos]
-                        .header
-                        .iter()
-                        .map(|k| k.1.to_owned())
-                        .collect::<Vec<_>>()
-                        .join(".");
-                    return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
-                }
-
-                // If we're here we know we should share the same prefix, and if
-                // the longer table was defined first then we want to narrow
-                // down our parent's length if possible to ensure that we catch
-                // duplicate tables defined afterwards.
-                if !self.de.allow_duplciate_after_longer_table {
-                    let parent_len = self.tables[self.cur_parent].header.len();
-                    let cur_len = self.tables[pos].header.len();
-                    if cur_len < parent_len {
-                        self.cur_parent = pos;
-                    }
-                }
-            }
-
-            let table = &mut self.tables[pos];
-
-            // If we're not yet at the appropriate depth for this table then we
-            // just next the next portion of its header and then continue
-            // decoding.
-            if self.depth != table.header.len() {
-                let key = &table.header[self.depth];
-                let key = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
-                return Ok(Some(key));
-            }
-
-            // Rule out cases like:
-            //
-            //      [[foo.bar]]
-            //      [[foo]]
-            if table.array {
-                let kind = ErrorKind::RedefineAsArray;
-                return Err(self.de.error(table.at, kind));
-            }
-
-            self.values = table
-                .values
-                .take()
-                .expect("Unable to read table values")
-                .into_iter()
-                .peekable();
-        }
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        if let Some((k, v)) = self.next_value.take() {
-            match seed.deserialize(ValueDeserializer::new(v)) {
-                Ok(v) => return Ok(v),
-                Err(mut e) => {
-                    e.add_key_context(&k.1);
-                    return Err(e);
-                }
-            }
-        }
-
-        let array =
-            self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
-        self.cur += 1;
-        let res = seed.deserialize(MapVisitor {
-            values: Vec::new().into_iter().peekable(),
-            next_value: None,
-            depth: self.depth + if array { 0 } else { 1 },
-            cur_parent: self.cur - 1,
-            cur: 0,
-            max: self.max,
-            array,
-            table_indices: &*self.table_indices,
-            table_pindices: &*self.table_pindices,
-            tables: &mut *self.tables,
-            de: &mut *self.de,
-        });
-        res.map_err(|mut e| {
-            e.add_key_context(&self.tables[self.cur - 1].header[self.depth].1);
-            e
-        })
-    }
-}
-
-impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
-    type Error = Error;
-
-    fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        assert!(self.next_value.is_none());
-        assert!(self.values.next().is_none());
-
-        if self.cur_parent == self.max {
-            return Ok(None);
-        }
-
-        let header_stripped = self.tables[self.cur_parent]
-            .header
-            .iter()
-            .map(|v| v.1.clone())
-            .collect::<Vec<_>>();
-        let start_idx = self.cur_parent + 1;
-        let next = self
-            .table_indices
-            .get(&header_stripped)
-            .and_then(|entries| {
-                let start = entries.binary_search(&start_idx).unwrap_or_else(|v| v);
-                if start == entries.len() || entries[start] < start_idx {
-                    return None;
-                }
-                entries[start..]
-                    .iter()
-                    .filter_map(|i| if *i < self.max { Some(*i) } else { None })
-                    .map(|i| (i, &self.tables[i]))
-                    .find(|(_, table)| table.array)
-                    .map(|p| p.0)
-            })
-            .unwrap_or(self.max);
-
-        let ret = seed.deserialize(MapVisitor {
-            values: self.tables[self.cur_parent]
-                .values
-                .take()
-                .expect("Unable to read table values")
-                .into_iter()
-                .peekable(),
-            next_value: None,
-            depth: self.depth + 1,
-            cur_parent: self.cur_parent,
-            max: next,
-            cur: 0,
-            array: false,
-            table_indices: &*self.table_indices,
-            table_pindices: &*self.table_pindices,
-            tables: &mut self.tables,
-            de: &mut self.de,
-        })?;
-        self.cur_parent = next;
-        Ok(Some(ret))
-    }
-}
-
-impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if self.array {
-            visitor.visit_seq(self)
-        } else {
-            visitor.visit_map(self)
-        }
-    }
-
-    // `None` is interpreted as a missing field so be sure to implement `Some`
-    // as a present field.
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_some(self)
-    }
-
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_struct<V>(
-        mut self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if name == spanned::NAME
-            && fields == [spanned::START, spanned::END, spanned::VALUE]
-            && !(self.array && !self.values.peek().is_none())
-        {
-            // TODO we can't actually emit spans here for the *entire* table/array
-            // due to the format that toml uses. Setting the start and end to 0 is
-            // *detectable* (and no reasonable span would look like that),
-            // it would be better to expose this in the API via proper
-            // ADTs like Option<T>.
-            let start = 0;
-            let end = 0;
-
-            let res = visitor.visit_map(SpannedDeserializer {
-                phantom_data: PhantomData,
-                start: Some(start),
-                value: Some(self),
-                end: Some(end),
-            });
-            return res;
-        }
-
-        self.deserialize_any(visitor)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if self.tables.len() != 1 {
-            return Err(Error::custom(
-                Some(self.cur),
-                "enum table must contain exactly one table".into(),
-            ));
-        }
-        let table = &mut self.tables[0];
-        let values = table.values.take().expect("table has no values?");
-        if table.header.is_empty() {
-            return Err(self.de.error(self.cur, ErrorKind::EmptyTableKey));
-        }
-        let name = table.header[table.header.len() - 1].1.to_owned();
-        visitor.visit_enum(DottedTableDeserializer {
-            name,
-            value: Value {
-                e: E::DottedTable(values),
-                start: 0,
-                end: 0,
-            },
-        })
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map unit identifier
-        ignored_any unit_struct tuple_struct tuple
-    }
-}
-
-struct StrDeserializer<'a> {
-    span: Option<Span>,
-    key: Cow<'a, str>,
-}
-
-impl<'a> StrDeserializer<'a> {
-    fn spanned(inner: (Span, Cow<'a, str>)) -> StrDeserializer<'a> {
-        StrDeserializer {
-            span: Some(inner.0),
-            key: inner.1,
-        }
-    }
-    fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
-        StrDeserializer { span: None, key }
-    }
-}
-
-impl<'a, 'b> de::IntoDeserializer<'a, Error> for StrDeserializer<'a> {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.key {
-            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
-            Cow::Owned(s) => visitor.visit_string(s),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
-            if let Some(span) = self.span {
-                return visitor.visit_map(SpannedDeserializer {
-                    phantom_data: PhantomData,
-                    start: Some(span.start),
-                    value: Some(StrDeserializer::new(self.key)),
-                    end: Some(span.end),
-                });
-            }
-        }
-        self.deserialize_any(visitor)
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map option unit newtype_struct
-        ignored_any unit_struct tuple_struct tuple enum identifier
-    }
-}
-
-struct ValueDeserializer<'a> {
-    value: Value<'a>,
-    validate_struct_keys: bool,
-}
-
-impl<'a> ValueDeserializer<'a> {
-    fn new(value: Value<'a>) -> ValueDeserializer<'a> {
-        ValueDeserializer {
-            value,
-            validate_struct_keys: false,
-        }
-    }
-
-    fn with_struct_key_validation(mut self) -> Self {
-        self.validate_struct_keys = true;
-        self
-    }
-}
-
-impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let start = self.value.start;
-        let res = match self.value.e {
-            E::Integer(i) => visitor.visit_i64(i),
-            E::Boolean(b) => visitor.visit_bool(b),
-            E::Float(f) => visitor.visit_f64(f),
-            E::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
-            E::String(Cow::Owned(s)) => visitor.visit_string(s),
-            E::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
-                date: s,
-                visited: false,
-            }),
-            E::Array(values) => {
-                let mut s = de::value::SeqDeserializer::new(values.into_iter());
-                let ret = visitor.visit_seq(&mut s)?;
-                s.end()?;
-                Ok(ret)
-            }
-            E::InlineTable(values) | E::DottedTable(values) => {
-                visitor.visit_map(InlineTableDeserializer {
-                    values: values.into_iter(),
-                    next_value: None,
-                })
-            }
-        };
-        res.map_err(|mut err| {
-            // Attribute the error to whatever value returned the error.
-            err.fix_offset(|| Some(start));
-            err
-        })
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if name == datetime::NAME && fields == [datetime::FIELD] {
-            if let E::Datetime(s) = self.value.e {
-                return visitor.visit_map(DatetimeDeserializer {
-                    date: s,
-                    visited: false,
-                });
-            }
-        }
-
-        if self.validate_struct_keys {
-            match self.value.e {
-                E::InlineTable(ref values) | E::DottedTable(ref values) => {
-                    let extra_fields = values
-                        .iter()
-                        .filter_map(|key_value| {
-                            let (ref key, ref _val) = *key_value;
-                            if !fields.contains(&&*(key.1)) {
-                                Some(key.clone())
-                            } else {
-                                None
-                            }
-                        })
-                        .collect::<Vec<_>>();
-
-                    if !extra_fields.is_empty() {
-                        return Err(Error::from_kind(
-                            Some(self.value.start),
-                            ErrorKind::UnexpectedKeys {
-                                keys: extra_fields
-                                    .iter()
-                                    .map(|k| k.1.to_string())
-                                    .collect::<Vec<_>>(),
-                                available: fields,
-                            },
-                        ));
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
-            let start = self.value.start;
-            let end = self.value.end;
-
-            return visitor.visit_map(SpannedDeserializer {
-                phantom_data: PhantomData,
-                start: Some(start),
-                value: Some(self.value),
-                end: Some(end),
-            });
-        }
-
-        self.deserialize_any(visitor)
-    }
-
-    // `None` is interpreted as a missing field so be sure to implement `Some`
-    // as a present field.
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_some(self)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &'static str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value.e {
-            E::String(val) => visitor.visit_enum(val.into_deserializer()),
-            E::InlineTable(values) => {
-                if values.len() != 1 {
-                    Err(Error::from_kind(
-                        Some(self.value.start),
-                        ErrorKind::Wanted {
-                            expected: "exactly 1 element",
-                            found: if values.is_empty() {
-                                "zero elements"
-                            } else {
-                                "more than 1 element"
-                            },
-                        },
-                    ))
-                } else {
-                    visitor.visit_enum(InlineTableDeserializer {
-                        values: values.into_iter(),
-                        next_value: None,
-                    })
-                }
-            }
-            e => Err(Error::from_kind(
-                Some(self.value.start),
-                ErrorKind::Wanted {
-                    expected: "string or inline table",
-                    found: e.type_name(),
-                },
-            )),
-        }
-    }
-
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map unit identifier
-        ignored_any unit_struct tuple_struct tuple
-    }
-}
-
-impl<'de, 'b> de::IntoDeserializer<'de, Error> for MapVisitor<'de, 'b> {
-    type Deserializer = MapVisitor<'de, 'b>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de, 'b> de::IntoDeserializer<'de, Error> for &'b mut Deserializer<'de> {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
-    type Deserializer = ValueDeserializer<'de>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        ValueDeserializer::new(self)
-    }
-}
-
-struct SpannedDeserializer<'de, T: de::IntoDeserializer<'de, Error>> {
-    phantom_data: PhantomData<&'de ()>,
-    start: Option<usize>,
-    end: Option<usize>,
-    value: Option<T>,
-}
-
-impl<'de, T> de::MapAccess<'de> for SpannedDeserializer<'de, T>
-where
-    T: de::IntoDeserializer<'de, Error>,
-{
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.start.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
-                .map(Some)
-        } else if self.end.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
-                .map(Some)
-        } else if self.value.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
-                .map(Some)
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        if let Some(start) = self.start.take() {
-            seed.deserialize(start.into_deserializer())
-        } else if let Some(end) = self.end.take() {
-            seed.deserialize(end.into_deserializer())
-        } else if let Some(value) = self.value.take() {
-            seed.deserialize(value.into_deserializer())
-        } else {
-            panic!("next_value_seed called before next_key_seed")
-        }
-    }
-}
-
-struct DatetimeDeserializer<'a> {
-    visited: bool,
-    date: &'a str,
-}
-
-impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.visited {
-            return Ok(None);
-        }
-        self.visited = true;
-        seed.deserialize(DatetimeFieldDeserializer).map(Some)
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(StrDeserializer::new(self.date.into()))
-    }
-}
-
-struct DatetimeFieldDeserializer;
-
-impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(datetime::FIELD)
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        bytes byte_buf map struct option unit newtype_struct
-        ignored_any unit_struct tuple_struct tuple enum identifier
-    }
-}
-
-struct DottedTableDeserializer<'a> {
-    name: Cow<'a, str>,
-    value: Value<'a>,
-}
-
-impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
-    type Error = Error;
-    type Variant = TableEnumDeserializer<'de>;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        let (name, value) = (self.name, self.value);
-        seed.deserialize(StrDeserializer::new(name))
-            .map(|val| (val, TableEnumDeserializer { value }))
-    }
-}
-
-struct InlineTableDeserializer<'a> {
-    values: vec::IntoIter<TablePair<'a>>,
-    next_value: Option<Value<'a>>,
-}
-
-impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        let (key, value) = match self.values.next() {
-            Some(pair) => pair,
-            None => return Ok(None),
-        };
-        self.next_value = Some(value);
-        seed.deserialize(StrDeserializer::spanned(key)).map(Some)
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        let value = self.next_value.take().expect("Unable to read table values");
-        seed.deserialize(ValueDeserializer::new(value))
-    }
-}
-
-impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
-    type Error = Error;
-    type Variant = TableEnumDeserializer<'de>;
-
-    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        let (key, value) = match self.values.next() {
-            Some(pair) => pair,
-            None => {
-                return Err(Error::from_kind(
-                    None, // FIXME: How do we get an offset here?
-                    ErrorKind::Wanted {
-                        expected: "table with exactly 1 entry",
-                        found: "empty table",
-                    },
-                ));
-            }
-        };
-
-        seed.deserialize(StrDeserializer::new(key.1))
-            .map(|val| (val, TableEnumDeserializer { value }))
-    }
-}
-
-/// Deserializes table values into enum variants.
-struct TableEnumDeserializer<'a> {
-    value: Value<'a>,
-}
-
-impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Self::Error> {
-        match self.value.e {
-            E::InlineTable(values) | E::DottedTable(values) => {
-                if values.is_empty() {
-                    Ok(())
-                } else {
-                    Err(Error::from_kind(
-                        Some(self.value.start),
-                        ErrorKind::ExpectedEmptyTable,
-                    ))
-                }
-            }
-            e => Err(Error::from_kind(
-                Some(self.value.start),
-                ErrorKind::Wanted {
-                    expected: "table",
-                    found: e.type_name(),
-                },
-            )),
-        }
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(ValueDeserializer::new(self.value))
-    }
-
-    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value.e {
-            E::InlineTable(values) | E::DottedTable(values) => {
-                let tuple_values = values
-                    .into_iter()
-                    .enumerate()
-                    .map(|(index, (key, value))| match key.1.parse::<usize>() {
-                        Ok(key_index) if key_index == index => Ok(value),
-                        Ok(_) | Err(_) => Err(Error::from_kind(
-                            Some(key.0.start),
-                            ErrorKind::ExpectedTupleIndex {
-                                expected: index,
-                                found: key.1.to_string(),
-                            },
-                        )),
-                    })
-                    // Fold all values into a `Vec`, or return the first error.
-                    .fold(Ok(Vec::with_capacity(len)), |result, value_result| {
-                        result.and_then(move |mut tuple_values| match value_result {
-                            Ok(value) => {
-                                tuple_values.push(value);
-                                Ok(tuple_values)
-                            }
-                            // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
-                            Err(e) => Err(e),
-                        })
-                    })?;
-
-                if tuple_values.len() == len {
-                    de::Deserializer::deserialize_seq(
-                        ValueDeserializer::new(Value {
-                            e: E::Array(tuple_values),
-                            start: self.value.start,
-                            end: self.value.end,
-                        }),
-                        visitor,
-                    )
-                } else {
-                    Err(Error::from_kind(
-                        Some(self.value.start),
-                        ErrorKind::ExpectedTuple(len),
-                    ))
-                }
-            }
-            e => Err(Error::from_kind(
-                Some(self.value.start),
-                ErrorKind::Wanted {
-                    expected: "table",
-                    found: e.type_name(),
-                },
-            )),
-        }
-    }
-
-    fn struct_variant<V>(
-        self,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        de::Deserializer::deserialize_struct(
-            ValueDeserializer::new(self.value).with_struct_key_validation(),
-            "", // TODO: this should be the variant name
-            fields,
-            visitor,
-        )
-    }
-}
-
-impl<'a> Deserializer<'a> {
-    /// Creates a new deserializer which will be deserializing the string
-    /// provided.
-    pub fn new(input: &'a str) -> Deserializer<'a> {
-        Deserializer {
-            tokens: Tokenizer::new(input),
-            input,
-            require_newline_after_table: true,
-            allow_duplciate_after_longer_table: false,
-        }
-    }
-
-    /// The `Deserializer::end` method should be called after a value has been
-    /// fully deserialized.  This allows the `Deserializer` to validate that the
-    /// input stream is at the end or that it only has trailing
-    /// whitespace/comments.
-    pub fn end(&mut self) -> Result<(), Error> {
-        Ok(())
-    }
-
-    /// Historical versions of toml-rs accidentally allowed a newline after a
-    /// table definition, but the TOML spec requires a newline after a table
-    /// definition header.
-    ///
-    /// This option can be set to `false` (the default is `true`) to emulate
-    /// this behavior for backwards compatibility with older toml-rs versions.
-    pub fn set_require_newline_after_table(&mut self, require: bool) {
-        self.require_newline_after_table = require;
-    }
-
-    /// Historical versions of toml-rs accidentally allowed a duplicate table
-    /// header after a longer table header was previously defined. This is
-    /// invalid according to the TOML spec, however.
-    ///
-    /// This option can be set to `true` (the default is `false`) to emulate
-    /// this behavior for backwards compatibility with older toml-rs versions.
-    pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
-        self.allow_duplciate_after_longer_table = allow;
-    }
-
-    fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
-        let mut tables = Vec::new();
-        let mut cur_table = Table {
-            at: 0,
-            header: Vec::new(),
-            values: None,
-            array: false,
-        };
-
-        while let Some(line) = self.line()? {
-            match line {
-                Line::Table {
-                    at,
-                    mut header,
-                    array,
-                } => {
-                    if !cur_table.header.is_empty() || cur_table.values.is_some() {
-                        tables.push(cur_table);
-                    }
-                    cur_table = Table {
-                        at,
-                        header: Vec::new(),
-                        values: Some(Vec::new()),
-                        array,
-                    };
-                    loop {
-                        let part = header.next().map_err(|e| self.token_error(e));
-                        match part? {
-                            Some(part) => cur_table.header.push(part),
-                            None => break,
-                        }
-                    }
-                }
-                Line::KeyValue(key, value) => {
-                    if cur_table.values.is_none() {
-                        cur_table.values = Some(Vec::new());
-                    }
-                    self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
-                }
-            }
-        }
-        if !cur_table.header.is_empty() || cur_table.values.is_some() {
-            tables.push(cur_table);
-        }
-        Ok(tables)
-    }
-
-    fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
-        loop {
-            self.eat_whitespace()?;
-            if self.eat_comment()? {
-                continue;
-            }
-            if self.eat(Token::Newline)? {
-                continue;
-            }
-            break;
-        }
-
-        match self.peek()? {
-            Some((_, Token::LeftBracket)) => self.table_header().map(Some),
-            Some(_) => self.key_value().map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn table_header(&mut self) -> Result<Line<'a>, Error> {
-        let start = self.tokens.current();
-        self.expect(Token::LeftBracket)?;
-        let array = self.eat(Token::LeftBracket)?;
-        let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
-        if self.require_newline_after_table {
-            self.tokens.skip_to_newline();
-        } else {
-            loop {
-                match self.next()? {
-                    Some((_, Token::RightBracket)) => {
-                        if array {
-                            self.eat(Token::RightBracket)?;
-                        }
-                        break;
-                    }
-                    Some((_, Token::Newline)) | None => break,
-                    _ => {}
-                }
-            }
-            self.eat_whitespace()?;
-        }
-        Ok(Line::Table {
-            at: start,
-            header: ret,
-            array,
-        })
-    }
-
-    fn key_value(&mut self) -> Result<Line<'a>, Error> {
-        let key = self.dotted_key()?;
-        self.eat_whitespace()?;
-        self.expect(Token::Equals)?;
-        self.eat_whitespace()?;
-
-        let value = self.value()?;
-        self.eat_whitespace()?;
-        if !self.eat_comment()? {
-            self.eat_newline_or_eof()?;
-        }
-
-        Ok(Line::KeyValue(key, value))
-    }
-
-    fn value(&mut self) -> Result<Value<'a>, Error> {
-        let at = self.tokens.current();
-        let value = match self.next()? {
-            Some((Span { start, end }, Token::String { val, .. })) => Value {
-                e: E::String(val),
-                start,
-                end,
-            },
-            Some((Span { start, end }, Token::Keylike("true"))) => Value {
-                e: E::Boolean(true),
-                start,
-                end,
-            },
-            Some((Span { start, end }, Token::Keylike("false"))) => Value {
-                e: E::Boolean(false),
-                start,
-                end,
-            },
-            Some((span, Token::Keylike(key))) => self.parse_keylike(at, span, key)?,
-            Some((span, Token::Plus)) => self.number_leading_plus(span)?,
-            Some((Span { start, .. }, Token::LeftBrace)) => {
-                self.inline_table().map(|(Span { end, .. }, table)| Value {
-                    e: E::InlineTable(table),
-                    start,
-                    end,
-                })?
-            }
-            Some((Span { start, .. }, Token::LeftBracket)) => {
-                self.array().map(|(Span { end, .. }, array)| Value {
-                    e: E::Array(array),
-                    start,
-                    end,
-                })?
-            }
-            Some(token) => {
-                return Err(self.error(
-                    at,
-                    ErrorKind::Wanted {
-                        expected: "a value",
-                        found: token.1.describe(),
-                    },
-                ));
-            }
-            None => return Err(self.eof()),
-        };
-        Ok(value)
-    }
-
-    fn parse_keylike(&mut self, at: usize, span: Span, key: &'a str) -> Result<Value<'a>, Error> {
-        if key == "inf" || key == "nan" {
-            return self.number_or_date(span, key);
-        }
-
-        let first_char = key.chars().next().expect("key should not be empty here");
-        match first_char {
-            '-' | '0'..='9' => self.number_or_date(span, key),
-            _ => Err(self.error(at, ErrorKind::UnquotedString)),
-        }
-    }
-
-    fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
-        if s.contains('T')
-            || s.contains('t')
-            || (s.len() > 1 && s[1..].contains('-') && !s.contains("e-") && !s.contains("E-"))
-        {
-            self.datetime(span, s, false)
-                .map(|(Span { start, end }, d)| Value {
-                    e: E::Datetime(d),
-                    start,
-                    end,
-                })
-        } else if self.eat(Token::Colon)? {
-            self.datetime(span, s, true)
-                .map(|(Span { start, end }, d)| Value {
-                    e: E::Datetime(d),
-                    start,
-                    end,
-                })
-        } else {
-            self.number(span, s)
-        }
-    }
-
-    /// Returns a string or table value type.
-    ///
-    /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
-    /// structures (tuple, newtype, struct) must be represented as a table.
-    fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
-        match self.peek()? {
-            Some((span, Token::LeftBracket)) => {
-                let tables = self.tables()?;
-                if tables.len() != 1 {
-                    return Err(Error::from_kind(
-                        Some(span.start),
-                        ErrorKind::Wanted {
-                            expected: "exactly 1 table",
-                            found: if tables.is_empty() {
-                                "zero tables"
-                            } else {
-                                "more than 1 table"
-                            },
-                        },
-                    ));
-                }
-
-                let table = tables
-                    .into_iter()
-                    .next()
-                    .expect("Expected exactly one table");
-                let header = table
-                    .header
-                    .last()
-                    .expect("Expected at least one header value for table.");
-
-                let start = table.at;
-                let end = table
-                    .values
-                    .as_ref()
-                    .and_then(|values| values.last())
-                    .map(|&(_, ref val)| val.end)
-                    .unwrap_or_else(|| header.1.len());
-                Ok((
-                    Value {
-                        e: E::DottedTable(table.values.unwrap_or_else(Vec::new)),
-                        start,
-                        end,
-                    },
-                    Some(header.1.clone()),
-                ))
-            }
-            Some(_) => self.value().map(|val| (val, None)),
-            None => Err(self.eof()),
-        }
-    }
-
-    fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
-        let to_integer = |f| Value {
-            e: E::Integer(f),
-            start,
-            end,
-        };
-        if s.starts_with("0x") {
-            self.integer(&s[2..], 16).map(to_integer)
-        } else if s.starts_with("0o") {
-            self.integer(&s[2..], 8).map(to_integer)
-        } else if s.starts_with("0b") {
-            self.integer(&s[2..], 2).map(to_integer)
-        } else if s.contains('e') || s.contains('E') {
-            self.float(s, None).map(|f| Value {
-                e: E::Float(f),
-                start,
-                end,
-            })
-        } else if self.eat(Token::Period)? {
-            let at = self.tokens.current();
-            match self.next()? {
-                Some((Span { start, end }, Token::Keylike(after))) => {
-                    self.float(s, Some(after)).map(|f| Value {
-                        e: E::Float(f),
-                        start,
-                        end,
-                    })
-                }
-                _ => Err(self.error(at, ErrorKind::NumberInvalid)),
-            }
-        } else if s == "inf" {
-            Ok(Value {
-                e: E::Float(f64::INFINITY),
-                start,
-                end,
-            })
-        } else if s == "-inf" {
-            Ok(Value {
-                e: E::Float(f64::NEG_INFINITY),
-                start,
-                end,
-            })
-        } else if s == "nan" {
-            Ok(Value {
-                e: E::Float(f64::NAN),
-                start,
-                end,
-            })
-        } else if s == "-nan" {
-            Ok(Value {
-                e: E::Float(-f64::NAN),
-                start,
-                end,
-            })
-        } else {
-            self.integer(s, 10).map(to_integer)
-        }
-    }
-
-    fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
-        let start_token = self.tokens.current();
-        match self.next()? {
-            Some((Span { end, .. }, Token::Keylike(s))) => self.number(Span { start, end }, s),
-            _ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
-        }
-    }
-
-    fn integer(&self, s: &'a str, radix: u32) -> Result<i64, Error> {
-        let allow_sign = radix == 10;
-        let allow_leading_zeros = radix != 10;
-        let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
-        let start = self.tokens.substr_offset(s);
-        if suffix != "" {
-            return Err(self.error(start, ErrorKind::NumberInvalid));
-        }
-        i64::from_str_radix(&prefix.replace("_", "").trim_start_matches('+'), radix)
-            .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
-    }
-
-    fn parse_integer(
-        &self,
-        s: &'a str,
-        allow_sign: bool,
-        allow_leading_zeros: bool,
-        radix: u32,
-    ) -> Result<(&'a str, &'a str), Error> {
-        let start = self.tokens.substr_offset(s);
-
-        let mut first = true;
-        let mut first_zero = false;
-        let mut underscore = false;
-        let mut end = s.len();
-        for (i, c) in s.char_indices() {
-            let at = i + start;
-            if i == 0 && (c == '+' || c == '-') && allow_sign {
-                continue;
-            }
-
-            if c == '0' && first {
-                first_zero = true;
-            } else if c.is_digit(radix) {
-                if !first && first_zero && !allow_leading_zeros {
-                    return Err(self.error(at, ErrorKind::NumberInvalid));
-                }
-                underscore = false;
-            } else if c == '_' && first {
-                return Err(self.error(at, ErrorKind::NumberInvalid));
-            } else if c == '_' && !underscore {
-                underscore = true;
-            } else {
-                end = i;
-                break;
-            }
-            first = false;
-        }
-        if first || underscore {
-            return Err(self.error(start, ErrorKind::NumberInvalid));
-        }
-        Ok((&s[..end], &s[end..]))
-    }
-
-    fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
-        let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
-        let start = self.tokens.substr_offset(integral);
-
-        let mut fraction = None;
-        if let Some(after) = after_decimal {
-            if suffix != "" {
-                return Err(self.error(start, ErrorKind::NumberInvalid));
-            }
-            let (a, b) = self.parse_integer(after, false, true, 10)?;
-            fraction = Some(a);
-            suffix = b;
-        }
-
-        let mut exponent = None;
-        if suffix.starts_with('e') || suffix.starts_with('E') {
-            let (a, b) = if suffix.len() == 1 {
-                self.eat(Token::Plus)?;
-                match self.next()? {
-                    Some((_, Token::Keylike(s))) => self.parse_integer(s, false, true, 10)?,
-                    _ => return Err(self.error(start, ErrorKind::NumberInvalid)),
-                }
-            } else {
-                self.parse_integer(&suffix[1..], true, true, 10)?
-            };
-            if b != "" {
-                return Err(self.error(start, ErrorKind::NumberInvalid));
-            }
-            exponent = Some(a);
-        } else if !suffix.is_empty() {
-            return Err(self.error(start, ErrorKind::NumberInvalid));
-        }
-
-        let mut number = integral
-            .trim_start_matches('+')
-            .chars()
-            .filter(|c| *c != '_')
-            .collect::<String>();
-        if let Some(fraction) = fraction {
-            number.push_str(".");
-            number.extend(fraction.chars().filter(|c| *c != '_'));
-        }
-        if let Some(exponent) = exponent {
-            number.push_str("E");
-            number.extend(exponent.chars().filter(|c| *c != '_'));
-        }
-        number
-            .parse()
-            .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
-            .and_then(|n: f64| {
-                if n.is_finite() {
-                    Ok(n)
-                } else {
-                    Err(self.error(start, ErrorKind::NumberInvalid))
-                }
-            })
-    }
-
-    fn datetime(
-        &mut self,
-        mut span: Span,
-        date: &'a str,
-        colon_eaten: bool,
-    ) -> Result<(Span, &'a str), Error> {
-        let start = self.tokens.substr_offset(date);
-
-        // Check for space separated date and time.
-        let mut lookahead = self.tokens.clone();
-        if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
-            // Check if hour follows.
-            if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
-                self.next()?; // skip space
-                self.next()?; // skip keylike hour
-            }
-        }
-
-        if colon_eaten || self.eat(Token::Colon)? {
-            // minutes
-            match self.next()? {
-                Some((_, Token::Keylike(_))) => {}
-                _ => return Err(self.error(start, ErrorKind::DateInvalid)),
-            }
-            // Seconds
-            self.expect(Token::Colon)?;
-            match self.next()? {
-                Some((Span { end, .. }, Token::Keylike(_))) => {
-                    span.end = end;
-                }
-                _ => return Err(self.error(start, ErrorKind::DateInvalid)),
-            }
-            // Fractional seconds
-            if self.eat(Token::Period)? {
-                match self.next()? {
-                    Some((Span { end, .. }, Token::Keylike(_))) => {
-                        span.end = end;
-                    }
-                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
-                }
-            }
-
-            // offset
-            if self.eat(Token::Plus)? {
-                match self.next()? {
-                    Some((Span { end, .. }, Token::Keylike(_))) => {
-                        span.end = end;
-                    }
-                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
-                }
-            }
-            if self.eat(Token::Colon)? {
-                match self.next()? {
-                    Some((Span { end, .. }, Token::Keylike(_))) => {
-                        span.end = end;
-                    }
-                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
-                }
-            }
-        }
-
-        let end = self.tokens.current();
-        Ok((span, &self.tokens.input()[start..end]))
-    }
-
-    // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
-    // great to defer parsing everything until later.
-    fn inline_table(&mut self) -> Result<(Span, Vec<TablePair<'a>>), Error> {
-        let mut ret = Vec::new();
-        self.eat_whitespace()?;
-        if let Some(span) = self.eat_spanned(Token::RightBrace)? {
-            return Ok((span, ret));
-        }
-        loop {
-            let key = self.dotted_key()?;
-            self.eat_whitespace()?;
-            self.expect(Token::Equals)?;
-            self.eat_whitespace()?;
-            let value = self.value()?;
-            self.add_dotted_key(key, value, &mut ret)?;
-
-            self.eat_whitespace()?;
-            if let Some(span) = self.eat_spanned(Token::RightBrace)? {
-                return Ok((span, ret));
-            }
-            self.expect(Token::Comma)?;
-            self.eat_whitespace()?;
-        }
-    }
-
-    // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
-    // great to defer parsing everything until later.
-    fn array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error> {
-        let mut ret = Vec::new();
-
-        let intermediate = |me: &mut Deserializer<'_>| {
-            loop {
-                me.eat_whitespace()?;
-                if !me.eat(Token::Newline)? && !me.eat_comment()? {
-                    break;
-                }
-            }
-            Ok(())
-        };
-
-        loop {
-            intermediate(self)?;
-            if let Some(span) = self.eat_spanned(Token::RightBracket)? {
-                return Ok((span, ret));
-            }
-            let value = self.value()?;
-            ret.push(value);
-            intermediate(self)?;
-            if !self.eat(Token::Comma)? {
-                break;
-            }
-        }
-        intermediate(self)?;
-        let span = self.expect_spanned(Token::RightBracket)?;
-        Ok((span, ret))
-    }
-
-    fn table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error> {
-        self.tokens.table_key().map_err(|e| self.token_error(e))
-    }
-
-    fn dotted_key(&mut self) -> Result<Vec<(Span, Cow<'a, str>)>, Error> {
-        let mut result = Vec::new();
-        result.push(self.table_key()?);
-        self.eat_whitespace()?;
-        while self.eat(Token::Period)? {
-            self.eat_whitespace()?;
-            result.push(self.table_key()?);
-            self.eat_whitespace()?;
-        }
-        Ok(result)
-    }
-
-    /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
-    ///
-    /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
-    /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
-    /// hierarchy.
-    ///
-    /// # Parameters
-    ///
-    /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
-    ///                `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
-    /// * `value`: The parsed value.
-    /// * `values`: The `Vec` to store the value in.
-    fn add_dotted_key(
-        &self,
-        mut key_parts: Vec<(Span, Cow<'a, str>)>,
-        value: Value<'a>,
-        values: &mut Vec<TablePair<'a>>,
-    ) -> Result<(), Error> {
-        let key = key_parts.remove(0);
-        if key_parts.is_empty() {
-            values.push((key, value));
-            return Ok(());
-        }
-        match values.iter_mut().find(|&&mut (ref k, _)| *k.1 == key.1) {
-            Some(&mut (
-                _,
-                Value {
-                    e: E::DottedTable(ref mut v),
-                    ..
-                },
-            )) => {
-                return self.add_dotted_key(key_parts, value, v);
-            }
-            Some(&mut (_, Value { start, .. })) => {
-                return Err(self.error(start, ErrorKind::DottedKeyInvalidType));
-            }
-            None => {}
-        }
-        // The start/end value is somewhat misleading here.
-        let table_values = Value {
-            e: E::DottedTable(Vec::new()),
-            start: value.start,
-            end: value.end,
-        };
-        values.push((key, table_values));
-        let last_i = values.len() - 1;
-        if let (
-            _,
-            Value {
-                e: E::DottedTable(ref mut v),
-                ..
-            },
-        ) = values[last_i]
-        {
-            self.add_dotted_key(key_parts, value, v)?;
-        }
-        Ok(())
-    }
-
-    fn eat_whitespace(&mut self) -> Result<(), Error> {
-        self.tokens
-            .eat_whitespace()
-            .map_err(|e| self.token_error(e))
-    }
-
-    fn eat_comment(&mut self) -> Result<bool, Error> {
-        self.tokens.eat_comment().map_err(|e| self.token_error(e))
-    }
-
-    fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
-        self.tokens
-            .eat_newline_or_eof()
-            .map_err(|e| self.token_error(e))
-    }
-
-    fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
-        self.tokens.eat(expected).map_err(|e| self.token_error(e))
-    }
-
-    fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
-        self.tokens
-            .eat_spanned(expected)
-            .map_err(|e| self.token_error(e))
-    }
-
-    fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
-        self.tokens
-            .expect(expected)
-            .map_err(|e| self.token_error(e))
-    }
-
-    fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
-        self.tokens
-            .expect_spanned(expected)
-            .map_err(|e| self.token_error(e))
-    }
-
-    fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
-        self.tokens.next().map_err(|e| self.token_error(e))
-    }
-
-    fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
-        self.tokens.peek().map_err(|e| self.token_error(e))
-    }
-
-    fn eof(&self) -> Error {
-        self.error(self.input.len(), ErrorKind::UnexpectedEof)
-    }
-
-    fn token_error(&self, error: TokenError) -> Error {
-        match error {
-            TokenError::InvalidCharInString(at, ch) => {
-                self.error(at, ErrorKind::InvalidCharInString(ch))
-            }
-            TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
-            TokenError::InvalidEscapeValue(at, v) => {
-                self.error(at, ErrorKind::InvalidEscapeValue(v))
-            }
-            TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
-            TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
-            TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
-            TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
-            TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
-            TokenError::Wanted {
-                at,
-                expected,
-                found,
-            } => self.error(at, ErrorKind::Wanted { expected, found }),
-            TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey),
-            TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
-        }
-    }
-
-    fn error(&self, at: usize, kind: ErrorKind) -> Error {
-        let mut err = Error::from_kind(Some(at), kind);
-        err.fix_linecol(|at| self.to_linecol(at));
-        err
-    }
-
-    /// Converts a byte offset from an error message to a (line, column) pair
-    ///
-    /// All indexes are 0-based.
-    fn to_linecol(&self, offset: usize) -> (usize, usize) {
-        let mut cur = 0;
-        // Use split_terminator instead of lines so that if there is a `\r`,
-        // it is included in the offset calculation. The `+1` values below
-        // account for the `\n`.
-        for (i, line) in self.input.split_terminator('\n').enumerate() {
-            if cur + line.len() + 1 > offset {
-                return (i, offset - cur);
-            }
-            cur += line.len() + 1;
-        }
-        (self.input.lines().count(), 0)
-    }
-}
-
-impl Error {
-    /// Produces a (line, column) pair of the position of the error if available
-    ///
-    /// All indexes are 0-based.
-    pub fn line_col(&self) -> Option<(usize, usize)> {
-        self.inner.line.map(|line| (line, self.inner.col))
-    }
-
-    fn from_kind(at: Option<usize>, kind: ErrorKind) -> Error {
-        Error {
-            inner: Box::new(ErrorInner {
-                kind,
-                line: None,
-                col: 0,
-                at,
-                message: String::new(),
-                key: Vec::new(),
-            }),
-        }
-    }
-
-    fn custom(at: Option<usize>, s: String) -> Error {
-        Error {
-            inner: Box::new(ErrorInner {
-                kind: ErrorKind::Custom,
-                line: None,
-                col: 0,
-                at,
-                message: s,
-                key: Vec::new(),
-            }),
-        }
-    }
-
-    pub(crate) fn add_key_context(&mut self, key: &str) {
-        self.inner.key.insert(0, key.to_string());
-    }
-
-    fn fix_offset<F>(&mut self, f: F)
-    where
-        F: FnOnce() -> Option<usize>,
-    {
-        // An existing offset is always better positioned than anything we
-        // might want to add later.
-        if self.inner.at.is_none() {
-            self.inner.at = f();
-        }
-    }
-
-    fn fix_linecol<F>(&mut self, f: F)
-    where
-        F: FnOnce(usize) -> (usize, usize),
-    {
-        if let Some(at) = self.inner.at {
-            let (line, col) = f(at);
-            self.inner.line = Some(line);
-            self.inner.col = col;
-        }
-    }
-}
-
-impl std::convert::From<Error> for std::io::Error {
-    fn from(e: Error) -> Self {
-        std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.inner.kind {
-            ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?,
-            ErrorKind::InvalidCharInString(c) => write!(
-                f,
-                "invalid character in string: `{}`",
-                c.escape_default().collect::<String>()
-            )?,
-            ErrorKind::InvalidEscape(c) => write!(
-                f,
-                "invalid escape character in string: `{}`",
-                c.escape_default().collect::<String>()
-            )?,
-            ErrorKind::InvalidHexEscape(c) => write!(
-                f,
-                "invalid hex escape character in string: `{}`",
-                c.escape_default().collect::<String>()
-            )?,
-            ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?,
-            ErrorKind::NewlineInString => "newline in string found".fmt(f)?,
-            ErrorKind::Unexpected(ch) => write!(
-                f,
-                "unexpected character found: `{}`",
-                ch.escape_default().collect::<String>()
-            )?,
-            ErrorKind::UnterminatedString => "unterminated string".fmt(f)?,
-            ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?,
-            ErrorKind::Wanted { expected, found } => {
-                write!(f, "expected {}, found {}", expected, found)?
-            }
-            ErrorKind::NumberInvalid => "invalid number".fmt(f)?,
-            ErrorKind::DateInvalid => "invalid date".fmt(f)?,
-            ErrorKind::DuplicateTable(ref s) => {
-                write!(f, "redefinition of table `{}`", s)?;
-            }
-            ErrorKind::RedefineAsArray => "table redefined as array".fmt(f)?,
-            ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?,
-            ErrorKind::MultilineStringKey => "multiline strings are not allowed for key".fmt(f)?,
-            ErrorKind::Custom => self.inner.message.fmt(f)?,
-            ErrorKind::ExpectedTuple(l) => write!(f, "expected table with length {}", l)?,
-            ErrorKind::ExpectedTupleIndex {
-                expected,
-                ref found,
-            } => write!(f, "expected table key `{}`, but was `{}`", expected, found)?,
-            ErrorKind::ExpectedEmptyTable => "expected empty table".fmt(f)?,
-            ErrorKind::DottedKeyInvalidType => {
-                "dotted key attempted to extend non-table type".fmt(f)?
-            }
-            ErrorKind::UnexpectedKeys {
-                ref keys,
-                available,
-            } => write!(
-                f,
-                "unexpected keys in table: `{:?}`, available keys: `{:?}`",
-                keys, available
-            )?,
-            ErrorKind::UnquotedString => write!(
-                f,
-                "invalid TOML value, did you mean to use a quoted string?"
-            )?,
-            ErrorKind::__Nonexhaustive => panic!(),
-        }
-
-        if !self.inner.key.is_empty() {
-            write!(f, " for key `")?;
-            for (i, k) in self.inner.key.iter().enumerate() {
-                if i > 0 {
-                    write!(f, ".")?;
-                }
-                write!(f, "{}", k)?;
-            }
-            write!(f, "`")?;
-        }
-
-        if let Some(line) = self.inner.line {
-            write!(f, " at line {} column {}", line + 1, self.inner.col + 1)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl error::Error for Error {}
-
-impl de::Error for Error {
-    fn custom<T: fmt::Display>(msg: T) -> Error {
-        Error::custom(None, msg.to_string())
-    }
-}
-
-enum Line<'a> {
-    Table {
-        at: usize,
-        header: Header<'a>,
-        array: bool,
-    },
-    KeyValue(Vec<(Span, Cow<'a, str>)>, Value<'a>),
-}
-
-struct Header<'a> {
-    first: bool,
-    array: bool,
-    require_newline_after_table: bool,
-    tokens: Tokenizer<'a>,
-}
-
-impl<'a> Header<'a> {
-    fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> {
-        Header {
-            first: true,
-            array,
-            tokens,
-            require_newline_after_table,
-        }
-    }
-
-    fn next(&mut self) -> Result<Option<(Span, Cow<'a, str>)>, TokenError> {
-        self.tokens.eat_whitespace()?;
-
-        if self.first || self.tokens.eat(Token::Period)? {
-            self.first = false;
-            self.tokens.eat_whitespace()?;
-            self.tokens.table_key().map(|t| t).map(Some)
-        } else {
-            self.tokens.expect(Token::RightBracket)?;
-            if self.array {
-                self.tokens.expect(Token::RightBracket)?;
-            }
-
-            self.tokens.eat_whitespace()?;
-            if self.require_newline_after_table && !self.tokens.eat_comment()? {
-                self.tokens.eat_newline_or_eof()?;
-            }
-            Ok(None)
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Value<'a> {
-    e: E<'a>,
-    start: usize,
-    end: usize,
-}
-
-#[derive(Debug)]
-enum E<'a> {
-    Integer(i64),
-    Float(f64),
-    Boolean(bool),
-    String(Cow<'a, str>),
-    Datetime(&'a str),
-    Array(Vec<Value<'a>>),
-    InlineTable(Vec<TablePair<'a>>),
-    DottedTable(Vec<TablePair<'a>>),
-}
-
-impl<'a> E<'a> {
-    fn type_name(&self) -> &'static str {
-        match *self {
-            E::String(..) => "string",
-            E::Integer(..) => "integer",
-            E::Float(..) => "float",
-            E::Boolean(..) => "boolean",
-            E::Datetime(..) => "datetime",
-            E::Array(..) => "array",
-            E::InlineTable(..) => "inline table",
-            E::DottedTable(..) => "dotted table",
-        }
-    }
-}
diff --git a/vendor/toml/src/lib.rs b/vendor/toml/src/lib.rs
deleted file mode 100644
index 00421b11..00000000
--- a/vendor/toml/src/lib.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-//! A [TOML]-parsing library
-//!
-//! This library implements a [TOML] v0.5.0 compatible parser,
-//! primarily supporting the [`serde`] library for encoding/decoding
-//! various types in Rust.
-//!
-//! TOML itself is a simple, ergonomic, and readable configuration format:
-//!
-//! ```toml
-//! [package]
-//! name = "toml"
-//! version = "0.4.2"
-//! authors = ["Alex Crichton <alex@alexcrichton.com>"]
-//!
-//! [dependencies]
-//! serde = "1.0"
-//! ```
-//!
-//! The TOML format tends to be relatively common throughout the Rust community
-//! for configuration, notably being used by [Cargo], Rust's package manager.
-//!
-//! ## TOML values
-//!
-//! A value in TOML is represented with the [`Value`] enum in this crate:
-//!
-//! ```rust,ignore
-//! pub enum Value {
-//!     String(String),
-//!     Integer(i64),
-//!     Float(f64),
-//!     Boolean(bool),
-//!     Datetime(Datetime),
-//!     Array(Array),
-//!     Table(Table),
-//! }
-//! ```
-//!
-//! TOML is similar to JSON with the notable addition of a [`Datetime`]
-//! type. In general, TOML and JSON are interchangeable in terms of
-//! formats.
-//!
-//! ## Parsing TOML
-//!
-//! The easiest way to parse a TOML document is via the [`Value`] type:
-//!
-//! ```rust
-//! use toml::Value;
-//!
-//! let value = "foo = 'bar'".parse::<Value>().unwrap();
-//!
-//! assert_eq!(value["foo"].as_str(), Some("bar"));
-//! ```
-//!
-//! The [`Value`] type implements a number of convenience methods and
-//! traits; the example above uses [`FromStr`] to parse a [`str`] into a
-//! [`Value`].
-//!
-//! ## Deserialization and Serialization
-//!
-//! This crate supports [`serde`] 1.0 with a number of
-//! implementations of the `Deserialize`, `Serialize`, `Deserializer`, and
-//! `Serializer` traits. Namely, you'll find:
-//!
-//! * `Deserialize for Value`
-//! * `Serialize for Value`
-//! * `Deserialize for Datetime`
-//! * `Serialize for Datetime`
-//! * `Deserializer for de::Deserializer`
-//! * `Serializer for ser::Serializer`
-//! * `Deserializer for Value`
-//!
-//! This means that you can use Serde to deserialize/serialize the
-//! [`Value`] type as well as the [`Datetime`] type in this crate. You can also
-//! use the [`Deserializer`], [`Serializer`], or [`Value`] type itself to act as
-//! a deserializer/serializer for arbitrary types.
-//!
-//! An example of deserializing with TOML is:
-//!
-//! ```rust
-//! use serde_derive::Deserialize;
-//!
-//! #[derive(Deserialize)]
-//! struct Config {
-//!     ip: String,
-//!     port: Option<u16>,
-//!     keys: Keys,
-//! }
-//!
-//! #[derive(Deserialize)]
-//! struct Keys {
-//!     github: String,
-//!     travis: Option<String>,
-//! }
-//!
-//! fn main() {
-//!     let config: Config = toml::from_str(r#"
-//!         ip = '127.0.0.1'
-//!
-//!         [keys]
-//!         github = 'xxxxxxxxxxxxxxxxx'
-//!         travis = 'yyyyyyyyyyyyyyyyy'
-//!     "#).unwrap();
-//!
-//!     assert_eq!(config.ip, "127.0.0.1");
-//!     assert_eq!(config.port, None);
-//!     assert_eq!(config.keys.github, "xxxxxxxxxxxxxxxxx");
-//!     assert_eq!(config.keys.travis.as_ref().unwrap(), "yyyyyyyyyyyyyyyyy");
-//! }
-//! ```
-//!
-//! You can serialize types in a similar fashion:
-//!
-//! ```rust
-//! use serde_derive::Serialize;
-//!
-//! #[derive(Serialize)]
-//! struct Config {
-//!     ip: String,
-//!     port: Option<u16>,
-//!     keys: Keys,
-//! }
-//!
-//! #[derive(Serialize)]
-//! struct Keys {
-//!     github: String,
-//!     travis: Option<String>,
-//! }
-//!
-//! fn main() {
-//!     let config = Config {
-//!         ip: "127.0.0.1".to_string(),
-//!         port: None,
-//!         keys: Keys {
-//!             github: "xxxxxxxxxxxxxxxxx".to_string(),
-//!             travis: Some("yyyyyyyyyyyyyyyyy".to_string()),
-//!         },
-//!     };
-//!
-//!     let toml = toml::to_string(&config).unwrap();
-//! }
-//! ```
-//!
-//! [TOML]: https://github.com/toml-lang/toml
-//! [Cargo]: https://crates.io/
-//! [`serde`]: https://serde.rs/
-
-#![doc(html_root_url = "https://docs.rs/toml/0.5")]
-#![deny(missing_docs)]
-#![warn(rust_2018_idioms)]
-// Makes rustc abort compilation if there are any unsafe blocks in the crate.
-// Presence of this annotation is picked up by tools such as cargo-geiger
-// and lets them ensure that there is indeed no unsafe code as opposed to
-// something they couldn't detect (e.g. unsafe added via macro expansion, etc).
-#![forbid(unsafe_code)]
-
-pub mod map;
-pub mod value;
-#[doc(no_inline)]
-pub use crate::value::Value;
-mod datetime;
-
-pub mod ser;
-#[doc(no_inline)]
-pub use crate::ser::{to_string, to_string_pretty, to_vec, Serializer};
-pub mod de;
-#[doc(no_inline)]
-pub use crate::de::{from_slice, from_str, Deserializer};
-mod tokens;
-
-#[doc(hidden)]
-pub mod macros;
-
-mod spanned;
-pub use crate::spanned::Spanned;
-
-// Just for rustdoc
-#[allow(unused_imports)]
-use crate::datetime::Datetime;
-#[allow(unused_imports)]
-use core::str::FromStr;
diff --git a/vendor/toml/src/macros.rs b/vendor/toml/src/macros.rs
deleted file mode 100644
index 0731afef..00000000
--- a/vendor/toml/src/macros.rs
+++ /dev/null
@@ -1,462 +0,0 @@
-pub use serde::de::{Deserialize, IntoDeserializer};
-
-use crate::value::{Array, Table, Value};
-
-/// Construct a [`toml::Value`] from TOML syntax.
-///
-/// [`toml::Value`]: value/enum.Value.html
-///
-/// ```rust
-/// fn main() {
-///     let cargo_toml = toml::toml! {
-///         [package]
-///         name = "toml"
-///         version = "0.4.5"
-///         authors = ["Alex Crichton <alex@alexcrichton.com>"]
-///
-///         [badges]
-///         travis-ci = { repository = "alexcrichton/toml-rs" }
-///
-///         [dependencies]
-///         serde = "1.0"
-///
-///         [dev-dependencies]
-///         serde_derive = "1.0"
-///         serde_json = "1.0"
-///     };
-///
-///     println!("{:#?}", cargo_toml);
-/// }
-/// ```
-#[macro_export]
-macro_rules! toml {
-    ($($toml:tt)+) => {{
-        let table = $crate::value::Table::new();
-        let mut root = $crate::Value::Table(table);
-        $crate::toml_internal!(@toplevel root [] $($toml)+);
-        root
-    }};
-}
-
-// TT-muncher to parse TOML syntax into a toml::Value.
-//
-//    @toplevel -- Parse tokens outside of an inline table or inline array. In
-//                 this state, `[table headers]` and `[[array headers]]` are
-//                 allowed and `key = value` pairs are not separated by commas.
-//
-//    @topleveldatetime -- Helper to parse a Datetime from string and insert it
-//                 into a table, continuing in the @toplevel state.
-//
-//    @path -- Turn a path segment into a string. Segments that look like idents
-//                 are stringified, while quoted segments like `"cfg(windows)"`
-//                 are not.
-//
-//    @value -- Parse the value part of a `key = value` pair, which may be a
-//                 primitive or inline table or inline array.
-//
-//    @table -- Parse the contents of an inline table, returning them as a
-//                 toml::Value::Table.
-//
-//    @tabledatetime -- Helper to parse a Datetime from string and insert it
-//                 into a table, continuing in the @table state.
-//
-//    @array -- Parse the contents of an inline array, returning them as a
-//                 toml::Value::Array.
-//
-//    @arraydatetime -- Helper to parse a Datetime from string and push it into
-//                 an array, continuing in the @array state.
-//
-//    @trailingcomma -- Helper to append a comma to a sequence of tokens if the
-//                 sequence is non-empty and does not already end in a trailing
-//                 comma.
-//
-#[macro_export]
-#[doc(hidden)]
-macro_rules! toml_internal {
-    // Base case, no elements remaining.
-    (@toplevel $root:ident [$($path:tt)*]) => {};
-
-    // Parse negative number `key = -value`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = - $v:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = (-$v) $($rest)*);
-    };
-
-    // Parse positive number `key = +value`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = + $v:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($($k)-+).+ = ($v) $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T00:32:00.999999-07:00`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T00:32:00-07:00`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse local datetime `key = 1979-05-27T00:32:00.999999`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
-    };
-    // Space instead of T.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T07:32:00Z` and local datetime `key = 1979-05-27T07:32:00`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
-    };
-    // Space instead of T.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse local date `key = 1979-05-27`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
-    };
-
-    // Parse local time `key = 00:32:00.999999`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt . $frac:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse local time `key = 07:32:00`.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt $($rest:tt)*) => {
-        $crate::toml_internal!(@topleveldatetime $root [$($path)*] $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse any other `key = value` including string, inline array, inline
-    // table, number, and boolean.
-    (@toplevel $root:ident [$($path:tt)*] $($($k:tt)-+).+ = $v:tt $($rest:tt)*) => {{
-        $crate::macros::insert_toml(
-            &mut $root,
-            &[$($path)* $(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($rest)*);
-    }};
-
-    // Parse array header `[[bin]]`.
-    (@toplevel $root:ident $oldpath:tt [[$($($path:tt)-+).+]] $($rest:tt)*) => {
-        $crate::macros::push_toml(
-            &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+]);
-        $crate::toml_internal!(@toplevel $root [$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+] $($rest)*);
-    };
-
-    // Parse table header `[patch.crates-io]`.
-    (@toplevel $root:ident $oldpath:tt [$($($path:tt)-+).+] $($rest:tt)*) => {
-        $crate::macros::insert_toml(
-            &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+],
-            $crate::Value::Table($crate::value::Table::new()));
-        $crate::toml_internal!(@toplevel $root [$(&concat!($("-", $crate::toml_internal!(@path $path),)+)[1..],)+] $($rest)*);
-    };
-
-    // Parse datetime from string and insert into table.
-    (@topleveldatetime $root:ident [$($path:tt)*] $($($k:tt)-+).+ = ($($datetime:tt)+) $($rest:tt)*) => {
-        $crate::macros::insert_toml(
-            &mut $root,
-            &[$($path)* $(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@toplevel $root [$($path)*] $($rest)*);
-    };
-
-    // Turn a path segment into a string.
-    (@path $ident:ident) => {
-        stringify!($ident)
-    };
-
-    // For a path segment that is not an ident, expect that it is already a
-    // quoted string, like in `[target."cfg(windows)".dependencies]`.
-    (@path $quoted:tt) => {
-        $quoted
-    };
-
-    // Construct a Value from an inline table.
-    (@value { $($inline:tt)* }) => {{
-        let mut table = $crate::Value::Table($crate::value::Table::new());
-        $crate::toml_internal!(@trailingcomma (@table table) $($inline)*);
-        table
-    }};
-
-    // Construct a Value from an inline array.
-    (@value [ $($inline:tt)* ]) => {{
-        let mut array = $crate::value::Array::new();
-        $crate::toml_internal!(@trailingcomma (@array array) $($inline)*);
-        $crate::Value::Array(array)
-    }};
-
-    (@value (-nan)) => {
-        $crate::Value::Float(-::std::f64::NAN)
-    };
-
-    (@value (nan)) => {
-        $crate::Value::Float(::std::f64::NAN)
-    };
-
-    (@value nan) => {
-        $crate::Value::Float(::std::f64::NAN)
-    };
-
-    (@value (-inf)) => {
-        $crate::Value::Float(::std::f64::NEG_INFINITY)
-    };
-
-    (@value (inf)) => {
-        $crate::Value::Float(::std::f64::INFINITY)
-    };
-
-    (@value inf) => {
-        $crate::Value::Float(::std::f64::INFINITY)
-    };
-
-    // Construct a Value from any other type, probably string or boolean or number.
-    (@value $v:tt) => {{
-        // TODO: Implement this with something like serde_json::to_value instead.
-        let de = $crate::macros::IntoDeserializer::<$crate::de::Error>::into_deserializer($v);
-        <$crate::Value as $crate::macros::Deserialize>::deserialize(de).unwrap()
-    }};
-
-    // Base case of inline table.
-    (@table $root:ident) => {};
-
-    // Parse negative number `key = -value`.
-    (@table $root:ident $($($k:tt)-+).+ = - $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@table $root $($($k)-+).+ = (-$v) , $($rest)*);
-    };
-
-    // Parse positive number `key = +value`.
-    (@table $root:ident $($($k:tt)-+).+ = + $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@table $root $($($k)-+).+ = ($v) , $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T00:32:00.999999-07:00`.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T00:32:00-07:00`.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse local datetime `key = 1979-05-27T00:32:00.999999`.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
-    };
-    // Space instead of T.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse offset datetime `key = 1979-05-27T07:32:00Z` and local datetime `key = 1979-05-27T07:32:00`.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $dhr : $min : $sec) $($rest)*);
-    };
-    // Space instead of T.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse local date `key = 1979-05-27`.
-    (@table $root:ident $($($k:tt)-+).+ = $yr:tt - $mo:tt - $day:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($yr - $mo - $day) $($rest)*);
-    };
-
-    // Parse local time `key = 00:32:00.999999`.
-    (@table $root:ident $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse local time `key = 07:32:00`.
-    (@table $root:ident $($($k:tt)-+).+ = $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@tabledatetime $root $($($k)-+).+ = ($hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse any other type, probably string or boolean or number.
-    (@table $root:ident $($($k:tt)-+).+ = $v:tt , $($rest:tt)*) => {
-        $crate::macros::insert_toml(
-            &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@table $root $($rest)*);
-    };
-
-    // Parse a Datetime from string and continue in @table state.
-    (@tabledatetime $root:ident $($($k:tt)-+).+ = ($($datetime:tt)*) $($rest:tt)*) => {
-        $crate::macros::insert_toml(
-            &mut $root,
-            &[$(&concat!($("-", $crate::toml_internal!(@path $k),)+)[1..], )+],
-            $crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@table $root $($rest)*);
-    };
-
-    // Base case of inline array.
-    (@array $root:ident) => {};
-
-    // Parse negative number `-value`.
-    (@array $root:ident - $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@array $root (-$v) , $($rest)*);
-    };
-
-    // Parse positive number `+value`.
-    (@array $root:ident + $v:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@array $root ($v) , $($rest)*);
-    };
-
-    // Parse offset datetime `1979-05-27T00:32:00.999999-07:00`.
-    (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse offset datetime `1979-05-27T00:32:00-07:00`.
-    (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-    // Space instead of T.
-    (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt - $tzh:tt : $tzm:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec - $tzh : $tzm) $($rest)*);
-    };
-
-    // Parse local datetime `1979-05-27T00:32:00.999999`.
-    (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec . $frac) $($rest)*);
-    };
-    // Space instead of T.
-    (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse offset datetime `1979-05-27T07:32:00Z` and local datetime `1979-05-27T07:32:00`.
-    (@array $root:ident $yr:tt - $mo:tt - $dhr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $dhr : $min : $sec) $($rest)*);
-    };
-    // Space instead of T.
-    (@array $root:ident $yr:tt - $mo:tt - $day:tt $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day T $hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse local date `1979-05-27`.
-    (@array $root:ident $yr:tt - $mo:tt - $day:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($yr - $mo - $day) $($rest)*);
-    };
-
-    // Parse local time `00:32:00.999999`.
-    (@array $root:ident $hr:tt : $min:tt : $sec:tt . $frac:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($hr : $min : $sec . $frac) $($rest)*);
-    };
-
-    // Parse local time `07:32:00`.
-    (@array $root:ident $hr:tt : $min:tt : $sec:tt , $($rest:tt)*) => {
-        $crate::toml_internal!(@arraydatetime $root ($hr : $min : $sec) $($rest)*);
-    };
-
-    // Parse any other type, probably string or boolean or number.
-    (@array $root:ident $v:tt , $($rest:tt)*) => {
-        $root.push($crate::toml_internal!(@value $v));
-        $crate::toml_internal!(@array $root $($rest)*);
-    };
-
-    // Parse a Datetime from string and continue in @array state.
-    (@arraydatetime $root:ident ($($datetime:tt)*) $($rest:tt)*) => {
-        $root.push($crate::Value::Datetime(concat!($(stringify!($datetime)),+).parse().unwrap()));
-        $crate::toml_internal!(@array $root $($rest)*);
-    };
-
-    // No trailing comma required if the tokens are empty.
-    (@trailingcomma ($($args:tt)*)) => {
-        $crate::toml_internal!($($args)*);
-    };
-
-    // Tokens end with a trailing comma, do not append another one.
-    (@trailingcomma ($($args:tt)*) ,) => {
-        $crate::toml_internal!($($args)* ,);
-    };
-
-    // Tokens end with something other than comma, append a trailing comma.
-    (@trailingcomma ($($args:tt)*) $last:tt) => {
-        $crate::toml_internal!($($args)* $last ,);
-    };
-
-    // Not yet at the last token.
-    (@trailingcomma ($($args:tt)*) $first:tt $($rest:tt)+) => {
-        $crate::toml_internal!(@trailingcomma ($($args)* $first) $($rest)+);
-    };
-}
-
-// Called when parsing a `key = value` pair.
-// Inserts an entry into the table at the given path.
-pub fn insert_toml(root: &mut Value, path: &[&str], value: Value) {
-    *traverse(root, path) = value;
-}
-
-// Called when parsing an `[[array header]]`.
-// Pushes an empty table onto the array at the given path.
-pub fn push_toml(root: &mut Value, path: &[&str]) {
-    let target = traverse(root, path);
-    if !target.is_array() {
-        *target = Value::Array(Array::new());
-    }
-    target
-        .as_array_mut()
-        .unwrap()
-        .push(Value::Table(Table::new()));
-}
-
-fn traverse<'a>(root: &'a mut Value, path: &[&str]) -> &'a mut Value {
-    let mut cur = root;
-    for &key in path {
-        // Lexical lifetimes :D
-        let cur1 = cur;
-        let cur2;
-
-        // From the TOML spec:
-        //
-        // > Each double-bracketed sub-table will belong to the most recently
-        // > defined table element above it.
-        if cur1.is_array() {
-            cur2 = cur1.as_array_mut().unwrap().last_mut().unwrap();
-        } else {
-            cur2 = cur1;
-        };
-
-        // We are about to index into this value, so it better be a table.
-        if !cur2.is_table() {
-            *cur2 = Value::Table(Table::new());
-        }
-
-        if !cur2.as_table().unwrap().contains_key(key) {
-            // Insert an empty table for the next loop iteration to point to.
-            let empty = Value::Table(Table::new());
-            cur2.as_table_mut().unwrap().insert(key.to_owned(), empty);
-        }
-
-        // Step into the current table.
-        cur = cur2.as_table_mut().unwrap().get_mut(key).unwrap();
-    }
-    cur
-}
diff --git a/vendor/toml/src/map.rs b/vendor/toml/src/map.rs
deleted file mode 100644
index d130a1d5..00000000
--- a/vendor/toml/src/map.rs
+++ /dev/null
@@ -1,595 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A map of String to toml::Value.
-//!
-//! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`
-//! feature of toml-rs to use [`LinkedHashMap`] instead.
-//!
-//! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
-//! [`LinkedHashMap`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-
-use crate::value::Value;
-use serde::{de, ser};
-use std::borrow::Borrow;
-use std::fmt::{self, Debug};
-use std::hash::Hash;
-use std::iter::FromIterator;
-use std::ops;
-
-#[cfg(not(feature = "preserve_order"))]
-use std::collections::{btree_map, BTreeMap};
-
-#[cfg(feature = "preserve_order")]
-use indexmap::{self, IndexMap};
-
-/// Represents a TOML key/value type.
-pub struct Map<K, V> {
-    map: MapImpl<K, V>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type MapImpl<K, V> = BTreeMap<K, V>;
-#[cfg(feature = "preserve_order")]
-type MapImpl<K, V> = IndexMap<K, V>;
-
-impl Map<String, Value> {
-    /// Makes a new empty Map.
-    #[inline]
-    pub fn new() -> Self {
-        Map {
-            map: MapImpl::new(),
-        }
-    }
-
-    #[cfg(not(feature = "preserve_order"))]
-    /// Makes a new empty Map with the given initial capacity.
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        // does not support with_capacity
-        let _ = capacity;
-        Map {
-            map: BTreeMap::new(),
-        }
-    }
-
-    #[cfg(feature = "preserve_order")]
-    /// Makes a new empty Map with the given initial capacity.
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Map {
-            map: IndexMap::with_capacity(capacity),
-        }
-    }
-
-    /// Clears the map, removing all values.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.map.clear()
-    }
-
-    /// Returns a reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&Value>
-    where
-        String: Borrow<Q>,
-        Q: Ord + Eq + Hash,
-    {
-        self.map.get(key)
-    }
-
-    /// Returns true if the map contains a value for the specified key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
-    where
-        String: Borrow<Q>,
-        Q: Ord + Eq + Hash,
-    {
-        self.map.contains_key(key)
-    }
-
-    /// Returns a mutable reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut Value>
-    where
-        String: Borrow<Q>,
-        Q: Ord + Eq + Hash,
-    {
-        self.map.get_mut(key)
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not have this key present, `None` is returned.
-    ///
-    /// If the map did have this key present, the value is updated, and the old
-    /// value is returned. The key is not updated, though; this matters for
-    /// types that can be `==` without being identical.
-    #[inline]
-    pub fn insert(&mut self, k: String, v: Value) -> Option<Value> {
-        self.map.insert(k, v)
-    }
-
-    /// Removes a key from the map, returning the value at the key if the key
-    /// was previously in the map.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<Value>
-    where
-        String: Borrow<Q>,
-        Q: Ord + Eq + Hash,
-    {
-        self.map.remove(key)
-    }
-
-    /// Gets the given key's corresponding entry in the map for in-place
-    /// manipulation.
-    pub fn entry<S>(&mut self, key: S) -> Entry<'_>
-    where
-        S: Into<String>,
-    {
-        #[cfg(feature = "preserve_order")]
-        use indexmap::map::Entry as EntryImpl;
-        #[cfg(not(feature = "preserve_order"))]
-        use std::collections::btree_map::Entry as EntryImpl;
-
-        match self.map.entry(key.into()) {
-            EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant }),
-            EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied }),
-        }
-    }
-
-    /// Returns the number of elements in the map.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.map.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.map.is_empty()
-    }
-
-    /// Gets an iterator over the entries of the map.
-    #[inline]
-    pub fn iter(&self) -> Iter<'_> {
-        Iter {
-            iter: self.map.iter(),
-        }
-    }
-
-    /// Gets a mutable iterator over the entries of the map.
-    #[inline]
-    pub fn iter_mut(&mut self) -> IterMut<'_> {
-        IterMut {
-            iter: self.map.iter_mut(),
-        }
-    }
-
-    /// Gets an iterator over the keys of the map.
-    #[inline]
-    pub fn keys(&self) -> Keys<'_> {
-        Keys {
-            iter: self.map.keys(),
-        }
-    }
-
-    /// Gets an iterator over the values of the map.
-    #[inline]
-    pub fn values(&self) -> Values<'_> {
-        Values {
-            iter: self.map.values(),
-        }
-    }
-}
-
-impl Default for Map<String, Value> {
-    #[inline]
-    fn default() -> Self {
-        Map {
-            map: MapImpl::new(),
-        }
-    }
-}
-
-impl Clone for Map<String, Value> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Map {
-            map: self.map.clone(),
-        }
-    }
-}
-
-impl PartialEq for Map<String, Value> {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        self.map.eq(&other.map)
-    }
-}
-
-/// Access an element of this map. Panics if the given key is not present in the
-/// map.
-impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map<String, Value>
-where
-    String: Borrow<Q>,
-    Q: Ord + Eq + Hash,
-{
-    type Output = Value;
-
-    fn index(&self, index: &Q) -> &Value {
-        self.map.index(index)
-    }
-}
-
-/// Mutably access an element of this map. Panics if the given key is not
-/// present in the map.
-impl<'a, Q: ?Sized> ops::IndexMut<&'a Q> for Map<String, Value>
-where
-    String: Borrow<Q>,
-    Q: Ord + Eq + Hash,
-{
-    fn index_mut(&mut self, index: &Q) -> &mut Value {
-        self.map.get_mut(index).expect("no entry found for key")
-    }
-}
-
-impl Debug for Map<String, Value> {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        self.map.fmt(formatter)
-    }
-}
-
-impl ser::Serialize for Map<String, Value> {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: ser::Serializer,
-    {
-        use serde::ser::SerializeMap;
-        let mut map = serializer.serialize_map(Some(self.len()))?;
-        for (k, v) in self {
-            map.serialize_key(k)?;
-            map.serialize_value(v)?;
-        }
-        map.end()
-    }
-}
-
-impl<'de> de::Deserialize<'de> for Map<String, Value> {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct Visitor;
-
-        impl<'de> de::Visitor<'de> for Visitor {
-            type Value = Map<String, Value>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a map")
-            }
-
-            #[inline]
-            fn visit_unit<E>(self) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok(Map::new())
-            }
-
-            #[inline]
-            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let mut values = Map::new();
-
-                while let Some((key, value)) = visitor.next_entry()? {
-                    values.insert(key, value);
-                }
-
-                Ok(values)
-            }
-        }
-
-        deserializer.deserialize_map(Visitor)
-    }
-}
-
-impl FromIterator<(String, Value)> for Map<String, Value> {
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = (String, Value)>,
-    {
-        Map {
-            map: FromIterator::from_iter(iter),
-        }
-    }
-}
-
-impl Extend<(String, Value)> for Map<String, Value> {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = (String, Value)>,
-    {
-        self.map.extend(iter);
-    }
-}
-
-macro_rules! delegate_iterator {
-    (($name:ident $($generics:tt)*) => $item:ty) => {
-        impl $($generics)* Iterator for $name $($generics)* {
-            type Item = $item;
-            #[inline]
-            fn next(&mut self) -> Option<Self::Item> {
-                self.iter.next()
-            }
-            #[inline]
-            fn size_hint(&self) -> (usize, Option<usize>) {
-                self.iter.size_hint()
-            }
-        }
-
-        impl $($generics)* DoubleEndedIterator for $name $($generics)* {
-            #[inline]
-            fn next_back(&mut self) -> Option<Self::Item> {
-                self.iter.next_back()
-            }
-        }
-
-        impl $($generics)* ExactSizeIterator for $name $($generics)* {
-            #[inline]
-            fn len(&self) -> usize {
-                self.iter.len()
-            }
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// A view into a single entry in a map, which may either be vacant or occupied.
-/// This enum is constructed from the [`entry`] method on [`Map`].
-///
-/// [`entry`]: struct.Map.html#method.entry
-/// [`Map`]: struct.Map.html
-pub enum Entry<'a> {
-    /// A vacant Entry.
-    Vacant(VacantEntry<'a>),
-    /// An occupied Entry.
-    Occupied(OccupiedEntry<'a>),
-}
-
-/// A vacant Entry. It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-pub struct VacantEntry<'a> {
-    vacant: VacantEntryImpl<'a>,
-}
-
-/// An occupied Entry. It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-pub struct OccupiedEntry<'a> {
-    occupied: OccupiedEntryImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type VacantEntryImpl<'a> = btree_map::VacantEntry<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type VacantEntryImpl<'a> = indexmap::map::VacantEntry<'a, String, Value>;
-
-#[cfg(not(feature = "preserve_order"))]
-type OccupiedEntryImpl<'a> = btree_map::OccupiedEntry<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type OccupiedEntryImpl<'a> = indexmap::map::OccupiedEntry<'a, String, Value>;
-
-impl<'a> Entry<'a> {
-    /// Returns a reference to this entry's key.
-    pub fn key(&self) -> &String {
-        match *self {
-            Entry::Vacant(ref e) => e.key(),
-            Entry::Occupied(ref e) => e.key(),
-        }
-    }
-
-    /// Ensures a value is in the entry by inserting the default if empty, and
-    /// returns a mutable reference to the value in the entry.
-    pub fn or_insert(self, default: Value) -> &'a mut Value {
-        match self {
-            Entry::Vacant(entry) => entry.insert(default),
-            Entry::Occupied(entry) => entry.into_mut(),
-        }
-    }
-
-    /// Ensures a value is in the entry by inserting the result of the default
-    /// function if empty, and returns a mutable reference to the value in the
-    /// entry.
-    pub fn or_insert_with<F>(self, default: F) -> &'a mut Value
-    where
-        F: FnOnce() -> Value,
-    {
-        match self {
-            Entry::Vacant(entry) => entry.insert(default()),
-            Entry::Occupied(entry) => entry.into_mut(),
-        }
-    }
-}
-
-impl<'a> VacantEntry<'a> {
-    /// Gets a reference to the key that would be used when inserting a value
-    /// through the VacantEntry.
-    #[inline]
-    pub fn key(&self) -> &String {
-        self.vacant.key()
-    }
-
-    /// Sets the value of the entry with the VacantEntry's key, and returns a
-    /// mutable reference to it.
-    #[inline]
-    pub fn insert(self, value: Value) -> &'a mut Value {
-        self.vacant.insert(value)
-    }
-}
-
-impl<'a> OccupiedEntry<'a> {
-    /// Gets a reference to the key in the entry.
-    #[inline]
-    pub fn key(&self) -> &String {
-        self.occupied.key()
-    }
-
-    /// Gets a reference to the value in the entry.
-    #[inline]
-    pub fn get(&self) -> &Value {
-        self.occupied.get()
-    }
-
-    /// Gets a mutable reference to the value in the entry.
-    #[inline]
-    pub fn get_mut(&mut self) -> &mut Value {
-        self.occupied.get_mut()
-    }
-
-    /// Converts the entry into a mutable reference to its value.
-    #[inline]
-    pub fn into_mut(self) -> &'a mut Value {
-        self.occupied.into_mut()
-    }
-
-    /// Sets the value of the entry with the `OccupiedEntry`'s key, and returns
-    /// the entry's old value.
-    #[inline]
-    pub fn insert(&mut self, value: Value) -> Value {
-        self.occupied.insert(value)
-    }
-
-    /// Takes the value of the entry out of the map, and returns it.
-    #[inline]
-    pub fn remove(self) -> Value {
-        self.occupied.remove()
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> IntoIterator for &'a Map<String, Value> {
-    type Item = (&'a String, &'a Value);
-    type IntoIter = Iter<'a>;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        Iter {
-            iter: self.map.iter(),
-        }
-    }
-}
-
-/// An iterator over a toml::Map's entries.
-pub struct Iter<'a> {
-    iter: IterImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IterImpl<'a> = btree_map::Iter<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type IterImpl<'a> = indexmap::map::Iter<'a, String, Value>;
-
-delegate_iterator!((Iter<'a>) => (&'a String, &'a Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> IntoIterator for &'a mut Map<String, Value> {
-    type Item = (&'a String, &'a mut Value);
-    type IntoIter = IterMut<'a>;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        IterMut {
-            iter: self.map.iter_mut(),
-        }
-    }
-}
-
-/// A mutable iterator over a toml::Map's entries.
-pub struct IterMut<'a> {
-    iter: IterMutImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IterMutImpl<'a> = btree_map::IterMut<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type IterMutImpl<'a> = indexmap::map::IterMut<'a, String, Value>;
-
-delegate_iterator!((IterMut<'a>) => (&'a String, &'a mut Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl IntoIterator for Map<String, Value> {
-    type Item = (String, Value);
-    type IntoIter = IntoIter;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter {
-            iter: self.map.into_iter(),
-        }
-    }
-}
-
-/// An owning iterator over a toml::Map's entries.
-pub struct IntoIter {
-    iter: IntoIterImpl,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IntoIterImpl = btree_map::IntoIter<String, Value>;
-#[cfg(feature = "preserve_order")]
-type IntoIterImpl = indexmap::map::IntoIter<String, Value>;
-
-delegate_iterator!((IntoIter) => (String, Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// An iterator over a toml::Map's keys.
-pub struct Keys<'a> {
-    iter: KeysImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type KeysImpl<'a> = btree_map::Keys<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type KeysImpl<'a> = indexmap::map::Keys<'a, String, Value>;
-
-delegate_iterator!((Keys<'a>) => &'a String);
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// An iterator over a toml::Map's values.
-pub struct Values<'a> {
-    iter: ValuesImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type ValuesImpl<'a> = btree_map::Values<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type ValuesImpl<'a> = indexmap::map::Values<'a, String, Value>;
-
-delegate_iterator!((Values<'a>) => &'a Value);
diff --git a/vendor/toml/src/ser.rs b/vendor/toml/src/ser.rs
deleted file mode 100644
index e1155417..00000000
--- a/vendor/toml/src/ser.rs
+++ /dev/null
@@ -1,1854 +0,0 @@
-//! Serializing Rust structures into TOML.
-//!
-//! This module contains all the Serde support for serializing Rust structures
-//! into TOML documents (as strings). Note that some top-level functions here
-//! are also provided at the top of the crate.
-//!
-//! Note that the TOML format has a restriction that if a table itself contains
-//! tables, all keys with non-table values must be emitted first. This is
-//! typically easy to ensure happens when you're defining a `struct` as you can
-//! reorder the fields manually, but when working with maps (such as `BTreeMap`
-//! or `HashMap`) this can lead to serialization errors. In those situations you
-//! may use the `tables_last` function in this module like so:
-//!
-//! ```rust
-//! # use serde_derive::Serialize;
-//! # use std::collections::HashMap;
-//! #[derive(Serialize)]
-//! struct Manifest {
-//!     package: Package,
-//!     #[serde(serialize_with = "toml::ser::tables_last")]
-//!     dependencies: HashMap<String, Dependency>,
-//! }
-//! # type Package = String;
-//! # type Dependency = String;
-//! # fn main() {}
-//! ```
-
-use std::cell::Cell;
-use std::error;
-use std::fmt::{self, Write};
-use std::marker;
-use std::rc::Rc;
-
-use crate::datetime;
-use serde::ser;
-
-/// Serialize the given data structure as a TOML byte vector.
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, if `T` contains a map with non-string keys, or if `T` attempts to
-/// serialize an unsupported datatype such as an enum, tuple, or tuple struct.
-pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Error>
-where
-    T: ser::Serialize,
-{
-    to_string(value).map(|e| e.into_bytes())
-}
-
-/// Serialize the given data structure as a String of TOML.
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, if `T` contains a map with non-string keys, or if `T` attempts to
-/// serialize an unsupported datatype such as an enum, tuple, or tuple struct.
-///
-/// # Examples
-///
-/// ```
-/// use serde_derive::Serialize;
-///
-/// #[derive(Serialize)]
-/// struct Config {
-///     database: Database,
-/// }
-///
-/// #[derive(Serialize)]
-/// struct Database {
-///     ip: String,
-///     port: Vec<u16>,
-///     connection_max: u32,
-///     enabled: bool,
-/// }
-///
-/// fn main() {
-///     let config = Config {
-///         database: Database {
-///             ip: "192.168.1.1".to_string(),
-///             port: vec![8001, 8002, 8003],
-///             connection_max: 5000,
-///             enabled: false,
-///         },
-///     };
-///
-///     let toml = toml::to_string(&config).unwrap();
-///     println!("{}", toml)
-/// }
-/// ```
-pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error>
-where
-    T: ser::Serialize,
-{
-    let mut dst = String::with_capacity(128);
-    value.serialize(&mut Serializer::new(&mut dst))?;
-    Ok(dst)
-}
-
-/// Serialize the given data structure as a "pretty" String of TOML.
-///
-/// This is identical to `to_string` except the output string has a more
-/// "pretty" output. See `Serializer::pretty` for more details.
-pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String, Error>
-where
-    T: ser::Serialize,
-{
-    let mut dst = String::with_capacity(128);
-    value.serialize(&mut Serializer::pretty(&mut dst))?;
-    Ok(dst)
-}
-
-/// Errors that can occur when serializing a type.
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Error {
-    /// Indicates that a Rust type was requested to be serialized but it was not
-    /// supported.
-    ///
-    /// Currently the TOML format does not support serializing types such as
-    /// enums, tuples and tuple structs.
-    UnsupportedType,
-
-    /// The key of all TOML maps must be strings, but serialization was
-    /// attempted where the key of a map was not a string.
-    KeyNotString,
-
-    /// An error that we never omit but keep for backwards compatibility
-    #[doc(hidden)]
-    KeyNewline,
-
-    /// An array had to be homogenous, but now it is allowed to be heterogenous.
-    #[doc(hidden)]
-    ArrayMixedType,
-
-    /// All values in a TOML table must be emitted before further tables are
-    /// emitted. If a value is emitted *after* a table then this error is
-    /// generated.
-    ValueAfterTable,
-
-    /// A serialized date was invalid.
-    DateInvalid,
-
-    /// A serialized number was invalid.
-    NumberInvalid,
-
-    /// None was attempted to be serialized, but it's not supported.
-    UnsupportedNone,
-
-    /// A custom error which could be generated when serializing a particular
-    /// type.
-    Custom(String),
-
-    #[doc(hidden)]
-    __Nonexhaustive,
-}
-
-#[derive(Debug, Default, Clone)]
-/// Internal place for holding array setings
-struct ArraySettings {
-    indent: usize,
-    trailing_comma: bool,
-}
-
-impl ArraySettings {
-    fn pretty() -> ArraySettings {
-        ArraySettings {
-            indent: 4,
-            trailing_comma: true,
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-/// String settings
-struct StringSettings {
-    /// Whether to use literal strings when possible
-    literal: bool,
-}
-
-impl StringSettings {
-    fn pretty() -> StringSettings {
-        StringSettings { literal: true }
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-/// Internal struct for holding serialization settings
-struct Settings {
-    array: Option<ArraySettings>,
-    string: Option<StringSettings>,
-}
-
-/// Serialization implementation for TOML.
-///
-/// This structure implements serialization support for TOML to serialize an
-/// arbitrary type to TOML. Note that the TOML format does not support all
-/// datatypes in Rust, such as enums, tuples, and tuple structs. These types
-/// will generate an error when serialized.
-///
-/// Currently a serializer always writes its output to an in-memory `String`,
-/// which is passed in when creating the serializer itself.
-pub struct Serializer<'a> {
-    dst: &'a mut String,
-    state: State<'a>,
-    settings: Rc<Settings>,
-}
-
-#[derive(Debug, Copy, Clone)]
-enum ArrayState {
-    Started,
-    StartedAsATable,
-}
-
-#[derive(Debug, Clone)]
-enum State<'a> {
-    Table {
-        key: &'a str,
-        parent: &'a State<'a>,
-        first: &'a Cell<bool>,
-        table_emitted: &'a Cell<bool>,
-    },
-    Array {
-        parent: &'a State<'a>,
-        first: &'a Cell<bool>,
-        type_: &'a Cell<Option<ArrayState>>,
-        len: Option<usize>,
-    },
-    End,
-}
-
-#[doc(hidden)]
-pub struct SerializeSeq<'a, 'b> {
-    ser: &'b mut Serializer<'a>,
-    first: Cell<bool>,
-    type_: Cell<Option<ArrayState>>,
-    len: Option<usize>,
-}
-
-#[doc(hidden)]
-pub enum SerializeTable<'a, 'b> {
-    Datetime(&'b mut Serializer<'a>),
-    Table {
-        ser: &'b mut Serializer<'a>,
-        key: String,
-        first: Cell<bool>,
-        table_emitted: Cell<bool>,
-    },
-}
-
-impl<'a> Serializer<'a> {
-    /// Creates a new serializer which will emit TOML into the buffer provided.
-    ///
-    /// The serializer can then be used to serialize a type after which the data
-    /// will be present in `dst`.
-    pub fn new(dst: &'a mut String) -> Serializer<'a> {
-        Serializer {
-            dst,
-            state: State::End,
-            settings: Rc::new(Settings::default()),
-        }
-    }
-
-    /// Instantiate a "pretty" formatter
-    ///
-    /// By default this will use:
-    ///
-    /// - pretty strings: strings with newlines will use the `'''` syntax. See
-    ///   `Serializer::pretty_string`
-    /// - pretty arrays: each item in arrays will be on a newline, have an indentation of 4 and
-    ///   have a trailing comma. See `Serializer::pretty_array`
-    pub fn pretty(dst: &'a mut String) -> Serializer<'a> {
-        Serializer {
-            dst,
-            state: State::End,
-            settings: Rc::new(Settings {
-                array: Some(ArraySettings::pretty()),
-                string: Some(StringSettings::pretty()),
-            }),
-        }
-    }
-
-    /// Enable or Disable pretty strings
-    ///
-    /// If enabled, literal strings will be used when possible and strings with
-    /// one or more newlines will use triple quotes (i.e.: `'''` or `"""`)
-    ///
-    /// # Examples
-    ///
-    /// Instead of:
-    ///
-    /// ```toml,ignore
-    /// single = "no newlines"
-    /// text = "\nfoo\nbar\n"
-    /// ```
-    ///
-    /// You will have:
-    ///
-    /// ```toml,ignore
-    /// single = 'no newlines'
-    /// text = '''
-    /// foo
-    /// bar
-    /// '''
-    /// ```
-    pub fn pretty_string(&mut self, value: bool) -> &mut Self {
-        Rc::get_mut(&mut self.settings).unwrap().string = if value {
-            Some(StringSettings::pretty())
-        } else {
-            None
-        };
-        self
-    }
-
-    /// Enable or Disable Literal strings for pretty strings
-    ///
-    /// If enabled, literal strings will be used when possible and strings with
-    /// one or more newlines will use triple quotes (i.e.: `'''` or `"""`)
-    ///
-    /// If disabled, literal strings will NEVER be used and strings with one or
-    /// more newlines will use `"""`
-    ///
-    /// # Examples
-    ///
-    /// Instead of:
-    ///
-    /// ```toml,ignore
-    /// single = "no newlines"
-    /// text = "\nfoo\nbar\n"
-    /// ```
-    ///
-    /// You will have:
-    ///
-    /// ```toml,ignore
-    /// single = "no newlines"
-    /// text = """
-    /// foo
-    /// bar
-    /// """
-    /// ```
-    pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self {
-        let use_default = if let Some(ref mut s) = Rc::get_mut(&mut self.settings).unwrap().string {
-            s.literal = value;
-            false
-        } else {
-            true
-        };
-
-        if use_default {
-            let mut string = StringSettings::pretty();
-            string.literal = value;
-            Rc::get_mut(&mut self.settings).unwrap().string = Some(string);
-        }
-        self
-    }
-
-    /// Enable or Disable pretty arrays
-    ///
-    /// If enabled, arrays will always have each item on their own line.
-    ///
-    /// Some specific features can be controlled via other builder methods:
-    ///
-    /// - `Serializer::pretty_array_indent`: set the indent to a value other
-    ///   than 4.
-    /// - `Serializer::pretty_array_trailing_comma`: enable/disable the trailing
-    ///   comma on the last item.
-    ///
-    /// # Examples
-    ///
-    /// Instead of:
-    ///
-    /// ```toml,ignore
-    /// array = ["foo", "bar"]
-    /// ```
-    ///
-    /// You will have:
-    ///
-    /// ```toml,ignore
-    /// array = [
-    ///     "foo",
-    ///     "bar",
-    /// ]
-    /// ```
-    pub fn pretty_array(&mut self, value: bool) -> &mut Self {
-        Rc::get_mut(&mut self.settings).unwrap().array = if value {
-            Some(ArraySettings::pretty())
-        } else {
-            None
-        };
-        self
-    }
-
-    /// Set the indent for pretty arrays
-    ///
-    /// See `Serializer::pretty_array` for more details.
-    pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self {
-        let use_default = if let Some(ref mut a) = Rc::get_mut(&mut self.settings).unwrap().array {
-            a.indent = value;
-            false
-        } else {
-            true
-        };
-
-        if use_default {
-            let mut array = ArraySettings::pretty();
-            array.indent = value;
-            Rc::get_mut(&mut self.settings).unwrap().array = Some(array);
-        }
-        self
-    }
-
-    /// Specify whether to use a trailing comma when serializing pretty arrays
-    ///
-    /// See `Serializer::pretty_array` for more details.
-    pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self {
-        let use_default = if let Some(ref mut a) = Rc::get_mut(&mut self.settings).unwrap().array {
-            a.trailing_comma = value;
-            false
-        } else {
-            true
-        };
-
-        if use_default {
-            let mut array = ArraySettings::pretty();
-            array.trailing_comma = value;
-            Rc::get_mut(&mut self.settings).unwrap().array = Some(array);
-        }
-        self
-    }
-
-    fn display<T: fmt::Display>(&mut self, t: T, type_: ArrayState) -> Result<(), Error> {
-        self.emit_key(type_)?;
-        write!(self.dst, "{}", t).map_err(ser::Error::custom)?;
-        if let State::Table { .. } = self.state {
-            self.dst.push_str("\n");
-        }
-        Ok(())
-    }
-
-    fn emit_key(&mut self, type_: ArrayState) -> Result<(), Error> {
-        self.array_type(type_)?;
-        let state = self.state.clone();
-        self._emit_key(&state)
-    }
-
-    // recursive implementation of `emit_key` above
-    fn _emit_key(&mut self, state: &State<'_>) -> Result<(), Error> {
-        match *state {
-            State::End => Ok(()),
-            State::Array {
-                parent,
-                first,
-                type_,
-                len,
-            } => {
-                assert!(type_.get().is_some());
-                if first.get() {
-                    self._emit_key(parent)?;
-                }
-                self.emit_array(first, len)
-            }
-            State::Table {
-                parent,
-                first,
-                table_emitted,
-                key,
-            } => {
-                if table_emitted.get() {
-                    return Err(Error::ValueAfterTable);
-                }
-                if first.get() {
-                    self.emit_table_header(parent)?;
-                    first.set(false);
-                }
-                self.escape_key(key)?;
-                self.dst.push_str(" = ");
-                Ok(())
-            }
-        }
-    }
-
-    fn emit_array(&mut self, first: &Cell<bool>, len: Option<usize>) -> Result<(), Error> {
-        match (len, &self.settings.array) {
-            (Some(0..=1), _) | (_, &None) => {
-                if first.get() {
-                    self.dst.push_str("[")
-                } else {
-                    self.dst.push_str(", ")
-                }
-            }
-            (_, &Some(ref a)) => {
-                if first.get() {
-                    self.dst.push_str("[\n")
-                } else {
-                    self.dst.push_str(",\n")
-                }
-                for _ in 0..a.indent {
-                    self.dst.push_str(" ");
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn array_type(&mut self, type_: ArrayState) -> Result<(), Error> {
-        let prev = match self.state {
-            State::Array { type_, .. } => type_,
-            _ => return Ok(()),
-        };
-        if prev.get().is_none() {
-            prev.set(Some(type_));
-        }
-        Ok(())
-    }
-
-    fn escape_key(&mut self, key: &str) -> Result<(), Error> {
-        let ok = key.chars().all(|c| match c {
-            'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' => true,
-            _ => false,
-        });
-        if ok {
-            write!(self.dst, "{}", key).map_err(ser::Error::custom)?;
-        } else {
-            self.emit_str(key, true)?;
-        }
-        Ok(())
-    }
-
-    fn emit_str(&mut self, value: &str, is_key: bool) -> Result<(), Error> {
-        #[derive(PartialEq)]
-        enum Type {
-            NewlineTripple,
-            OnelineTripple,
-            OnelineSingle,
-        }
-
-        enum Repr {
-            /// represent as a literal string (using '')
-            Literal(String, Type),
-            /// represent the std way (using "")
-            Std(Type),
-        }
-
-        fn do_pretty(value: &str) -> Repr {
-            // For doing pretty prints we store in a new String
-            // because there are too many cases where pretty cannot
-            // work. We need to determine:
-            // - if we are a "multi-line" pretty (if there are \n)
-            // - if ['''] appears if multi or ['] if single
-            // - if there are any invalid control characters
-            //
-            // Doing it any other way would require multiple passes
-            // to determine if a pretty string works or not.
-            let mut out = String::with_capacity(value.len() * 2);
-            let mut ty = Type::OnelineSingle;
-            // found consecutive single quotes
-            let mut max_found_singles = 0;
-            let mut found_singles = 0;
-            let mut can_be_pretty = true;
-
-            for ch in value.chars() {
-                if can_be_pretty {
-                    if ch == '\'' {
-                        found_singles += 1;
-                        if found_singles >= 3 {
-                            can_be_pretty = false;
-                        }
-                    } else {
-                        if found_singles > max_found_singles {
-                            max_found_singles = found_singles;
-                        }
-                        found_singles = 0
-                    }
-                    match ch {
-                        '\t' => {}
-                        '\n' => ty = Type::NewlineTripple,
-                        // Escape codes are needed if any ascii control
-                        // characters are present, including \b \f \r.
-                        c if c <= '\u{1f}' || c == '\u{7f}' => can_be_pretty = false,
-                        _ => {}
-                    }
-                    out.push(ch);
-                } else {
-                    // the string cannot be represented as pretty,
-                    // still check if it should be multiline
-                    if ch == '\n' {
-                        ty = Type::NewlineTripple;
-                    }
-                }
-            }
-            if can_be_pretty && found_singles > 0 && value.ends_with('\'') {
-                // We cannot escape the ending quote so we must use """
-                can_be_pretty = false;
-            }
-            if !can_be_pretty {
-                debug_assert!(ty != Type::OnelineTripple);
-                return Repr::Std(ty);
-            }
-            if found_singles > max_found_singles {
-                max_found_singles = found_singles;
-            }
-            debug_assert!(max_found_singles < 3);
-            if ty == Type::OnelineSingle && max_found_singles >= 1 {
-                // no newlines, but must use ''' because it has ' in it
-                ty = Type::OnelineTripple;
-            }
-            Repr::Literal(out, ty)
-        }
-
-        let repr = if !is_key && self.settings.string.is_some() {
-            match (&self.settings.string, do_pretty(value)) {
-                (&Some(StringSettings { literal: false, .. }), Repr::Literal(_, ty)) => {
-                    Repr::Std(ty)
-                }
-                (_, r) => r,
-            }
-        } else {
-            Repr::Std(Type::OnelineSingle)
-        };
-        match repr {
-            Repr::Literal(literal, ty) => {
-                // A pretty string
-                match ty {
-                    Type::NewlineTripple => self.dst.push_str("'''\n"),
-                    Type::OnelineTripple => self.dst.push_str("'''"),
-                    Type::OnelineSingle => self.dst.push('\''),
-                }
-                self.dst.push_str(&literal);
-                match ty {
-                    Type::OnelineSingle => self.dst.push('\''),
-                    _ => self.dst.push_str("'''"),
-                }
-            }
-            Repr::Std(ty) => {
-                match ty {
-                    Type::NewlineTripple => self.dst.push_str("\"\"\"\n"),
-                    // note: OnelineTripple can happen if do_pretty wants to do
-                    // '''it's one line'''
-                    // but settings.string.literal == false
-                    Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'),
-                }
-                for ch in value.chars() {
-                    match ch {
-                        '\u{8}' => self.dst.push_str("\\b"),
-                        '\u{9}' => self.dst.push_str("\\t"),
-                        '\u{a}' => match ty {
-                            Type::NewlineTripple => self.dst.push('\n'),
-                            Type::OnelineSingle => self.dst.push_str("\\n"),
-                            _ => unreachable!(),
-                        },
-                        '\u{c}' => self.dst.push_str("\\f"),
-                        '\u{d}' => self.dst.push_str("\\r"),
-                        '\u{22}' => self.dst.push_str("\\\""),
-                        '\u{5c}' => self.dst.push_str("\\\\"),
-                        c if c <= '\u{1f}' || c == '\u{7f}' => {
-                            write!(self.dst, "\\u{:04X}", ch as u32).map_err(ser::Error::custom)?;
-                        }
-                        ch => self.dst.push(ch),
-                    }
-                }
-                match ty {
-                    Type::NewlineTripple => self.dst.push_str("\"\"\""),
-                    Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'),
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn emit_table_header(&mut self, state: &State<'_>) -> Result<(), Error> {
-        let array_of_tables = match *state {
-            State::End => return Ok(()),
-            State::Array { .. } => true,
-            _ => false,
-        };
-
-        // Unlike [..]s, we can't omit [[..]] ancestors, so be sure to emit table
-        // headers for them.
-        let mut p = state;
-        if let State::Array { first, parent, .. } = *state {
-            if first.get() {
-                p = parent;
-            }
-        }
-        while let State::Table { first, parent, .. } = *p {
-            p = parent;
-            if !first.get() {
-                break;
-            }
-            if let State::Array {
-                parent: &State::Table { .. },
-                ..
-            } = *parent
-            {
-                self.emit_table_header(parent)?;
-                break;
-            }
-        }
-
-        match *state {
-            State::Table { first, .. } => {
-                if !first.get() {
-                    // Newline if we are a table that is not the first
-                    // table in the document.
-                    self.dst.push('\n');
-                }
-            }
-            State::Array { parent, first, .. } => {
-                if !first.get() {
-                    // Always newline if we are not the first item in the
-                    // table-array
-                    self.dst.push('\n');
-                } else if let State::Table { first, .. } = *parent {
-                    if !first.get() {
-                        // Newline if we are not the first item in the document
-                        self.dst.push('\n');
-                    }
-                }
-            }
-            _ => {}
-        }
-        self.dst.push_str("[");
-        if array_of_tables {
-            self.dst.push_str("[");
-        }
-        self.emit_key_part(state)?;
-        if array_of_tables {
-            self.dst.push_str("]");
-        }
-        self.dst.push_str("]\n");
-        Ok(())
-    }
-
-    fn emit_key_part(&mut self, key: &State<'_>) -> Result<bool, Error> {
-        match *key {
-            State::Array { parent, .. } => self.emit_key_part(parent),
-            State::End => Ok(true),
-            State::Table {
-                key,
-                parent,
-                table_emitted,
-                ..
-            } => {
-                table_emitted.set(true);
-                let first = self.emit_key_part(parent)?;
-                if !first {
-                    self.dst.push_str(".");
-                }
-                self.escape_key(key)?;
-                Ok(false)
-            }
-        }
-    }
-}
-
-macro_rules! serialize_float {
-    ($this:expr, $v:expr) => {{
-        $this.emit_key(ArrayState::Started)?;
-        if ($v.is_nan() || $v == 0.0) && $v.is_sign_negative() {
-            write!($this.dst, "-").map_err(ser::Error::custom)?;
-        }
-        if $v.is_nan() {
-            write!($this.dst, "nan").map_err(ser::Error::custom)?;
-        } else {
-            write!($this.dst, "{}", $v).map_err(ser::Error::custom)?;
-        }
-        if $v % 1.0 == 0.0 {
-            write!($this.dst, ".0").map_err(ser::Error::custom)?;
-        }
-        if let State::Table { .. } = $this.state {
-            $this.dst.push_str("\n");
-        }
-        return Ok(());
-    }};
-}
-
-impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
-    type Ok = ();
-    type Error = Error;
-    type SerializeSeq = SerializeSeq<'a, 'b>;
-    type SerializeTuple = SerializeSeq<'a, 'b>;
-    type SerializeTupleStruct = SerializeSeq<'a, 'b>;
-    type SerializeTupleVariant = SerializeSeq<'a, 'b>;
-    type SerializeMap = SerializeTable<'a, 'b>;
-    type SerializeStruct = SerializeTable<'a, 'b>;
-    type SerializeStructVariant = ser::Impossible<(), Error>;
-
-    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
-        self.display(v, ArrayState::Started)
-    }
-
-    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
-        serialize_float!(self, v)
-    }
-
-    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
-        serialize_float!(self, v)
-    }
-
-    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
-        let mut buf = [0; 4];
-        self.serialize_str(v.encode_utf8(&mut buf))
-    }
-
-    fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
-        self.emit_key(ArrayState::Started)?;
-        self.emit_str(value, false)?;
-        if let State::Table { .. } = self.state {
-            self.dst.push_str("\n");
-        }
-        Ok(())
-    }
-
-    fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error> {
-        use serde::ser::Serialize;
-        value.serialize(self)
-    }
-
-    fn serialize_none(self) -> Result<(), Self::Error> {
-        Err(Error::UnsupportedNone)
-    }
-
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_unit(self) -> Result<(), Self::Error> {
-        Err(Error::UnsupportedType)
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
-        Err(Error::UnsupportedType)
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<(), Self::Error> {
-        self.serialize_str(variant)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::UnsupportedType)
-    }
-
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        self.array_type(ArrayState::Started)?;
-        Ok(SerializeSeq {
-            ser: self,
-            first: Cell::new(true),
-            type_: Cell::new(None),
-            len,
-        })
-    }
-
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        self.array_type(ArrayState::StartedAsATable)?;
-        Ok(SerializeTable::Table {
-            ser: self,
-            key: String::new(),
-            first: Cell::new(true),
-            table_emitted: Cell::new(false),
-        })
-    }
-
-    fn serialize_struct(
-        self,
-        name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        if name == datetime::NAME {
-            self.array_type(ArrayState::Started)?;
-            Ok(SerializeTable::Datetime(self))
-        } else {
-            self.array_type(ArrayState::StartedAsATable)?;
-            Ok(SerializeTable::Table {
-                ser: self,
-                key: String::new(),
-                first: Cell::new(true),
-                table_emitted: Cell::new(false),
-            })
-        }
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(Error::UnsupportedType)
-    }
-}
-
-impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(&mut Serializer {
-            dst: &mut *self.ser.dst,
-            state: State::Array {
-                parent: &self.ser.state,
-                first: &self.first,
-                type_: &self.type_,
-                len: self.len,
-            },
-            settings: self.ser.settings.clone(),
-        })?;
-        self.first.set(false);
-        Ok(())
-    }
-
-    fn end(self) -> Result<(), Error> {
-        match self.type_.get() {
-            Some(ArrayState::StartedAsATable) => return Ok(()),
-            Some(ArrayState::Started) => match (self.len, &self.ser.settings.array) {
-                (Some(0..=1), _) | (_, &None) => {
-                    self.ser.dst.push_str("]");
-                }
-                (_, &Some(ref a)) => {
-                    if a.trailing_comma {
-                        self.ser.dst.push_str(",");
-                    }
-                    self.ser.dst.push_str("\n]");
-                }
-            },
-            None => {
-                assert!(self.first.get());
-                self.ser.emit_key(ArrayState::Started)?;
-                self.ser.dst.push_str("[]")
-            }
-        }
-        if let State::Table { .. } = self.ser.state {
-            self.ser.dst.push_str("\n");
-        }
-        Ok(())
-    }
-}
-
-impl<'a, 'b> ser::SerializeTuple for SerializeSeq<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<(), Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl<'a, 'b> ser::SerializeTupleVariant for SerializeSeq<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<(), Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl<'a, 'b> ser::SerializeTupleStruct for SerializeSeq<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<(), Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        match *self {
-            SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
-            SerializeTable::Table { ref mut key, .. } => {
-                key.truncate(0);
-                *key = input.serialize(StringExtractor)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        match *self {
-            SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
-            SerializeTable::Table {
-                ref mut ser,
-                ref key,
-                ref first,
-                ref table_emitted,
-                ..
-            } => {
-                let res = value.serialize(&mut Serializer {
-                    dst: &mut *ser.dst,
-                    state: State::Table {
-                        key,
-                        parent: &ser.state,
-                        first,
-                        table_emitted,
-                    },
-                    settings: ser.settings.clone(),
-                });
-                match res {
-                    Ok(()) => first.set(false),
-                    Err(Error::UnsupportedNone) => {}
-                    Err(e) => return Err(e),
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn end(self) -> Result<(), Error> {
-        match self {
-            SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
-            SerializeTable::Table { ser, first, .. } => {
-                if first.get() {
-                    let state = ser.state.clone();
-                    ser.emit_table_header(&state)?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: ser::Serialize,
-    {
-        match *self {
-            SerializeTable::Datetime(ref mut ser) => {
-                if key == datetime::FIELD {
-                    value.serialize(DateStrEmitter(&mut *ser))?;
-                } else {
-                    return Err(Error::DateInvalid);
-                }
-            }
-            SerializeTable::Table {
-                ref mut ser,
-                ref first,
-                ref table_emitted,
-                ..
-            } => {
-                let res = value.serialize(&mut Serializer {
-                    dst: &mut *ser.dst,
-                    state: State::Table {
-                        key,
-                        parent: &ser.state,
-                        first,
-                        table_emitted,
-                    },
-                    settings: ser.settings.clone(),
-                });
-                match res {
-                    Ok(()) => first.set(false),
-                    Err(Error::UnsupportedNone) => {}
-                    Err(e) => return Err(e),
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn end(self) -> Result<(), Error> {
-        match self {
-            SerializeTable::Datetime(_) => {}
-            SerializeTable::Table { ser, first, .. } => {
-                if first.get() {
-                    let state = ser.state.clone();
-                    ser.emit_table_header(&state)?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-struct DateStrEmitter<'a, 'b>(&'b mut Serializer<'a>);
-
-impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
-    type Ok = ();
-    type Error = Error;
-    type SerializeSeq = ser::Impossible<(), Error>;
-    type SerializeTuple = ser::Impossible<(), Error>;
-    type SerializeTupleStruct = ser::Impossible<(), Error>;
-    type SerializeTupleVariant = ser::Impossible<(), Error>;
-    type SerializeMap = ser::Impossible<(), Error>;
-    type SerializeStruct = ser::Impossible<(), Error>;
-    type SerializeStructVariant = ser::Impossible<(), Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_char(self, _v: char) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
-        self.0.display(value, ArrayState::Started)?;
-        Ok(())
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_none(self) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_unit(self) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<(), Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-}
-
-struct StringExtractor;
-
-impl ser::Serializer for StringExtractor {
-    type Ok = String;
-    type Error = Error;
-    type SerializeSeq = ser::Impossible<String, Error>;
-    type SerializeTuple = ser::Impossible<String, Error>;
-    type SerializeTupleStruct = ser::Impossible<String, Error>;
-    type SerializeTupleVariant = ser::Impossible<String, Error>;
-    type SerializeMap = ser::Impossible<String, Error>;
-    type SerializeStruct = ser::Impossible<String, Error>;
-    type SerializeStructVariant = ser::Impossible<String, Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_char(self, _v: char) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_str(self, value: &str) -> Result<String, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_none(self) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<String, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_unit(self) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<String, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<String, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<String, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Error::UnsupportedType => "unsupported Rust type".fmt(f),
-            Error::KeyNotString => "map key was not a string".fmt(f),
-            Error::ValueAfterTable => "values must be emitted before tables".fmt(f),
-            Error::DateInvalid => "a serialized date was invalid".fmt(f),
-            Error::NumberInvalid => "a serialized number was invalid".fmt(f),
-            Error::UnsupportedNone => "unsupported None value".fmt(f),
-            Error::Custom(ref s) => s.fmt(f),
-            Error::KeyNewline => unreachable!(),
-            Error::ArrayMixedType => unreachable!(),
-            Error::__Nonexhaustive => panic!(),
-        }
-    }
-}
-
-impl error::Error for Error {}
-
-impl ser::Error for Error {
-    fn custom<T: fmt::Display>(msg: T) -> Error {
-        Error::Custom(msg.to_string())
-    }
-}
-
-enum Category {
-    Primitive,
-    Array,
-    Table,
-}
-
-/// Convenience function to serialize items in a map in an order valid with
-/// TOML.
-///
-/// TOML carries the restriction that keys in a table must be serialized last if
-/// their value is a table itself. This isn't always easy to guarantee, so this
-/// helper can be used like so:
-///
-/// ```rust
-/// # use serde_derive::Serialize;
-/// # use std::collections::HashMap;
-/// #[derive(Serialize)]
-/// struct Manifest {
-///     package: Package,
-///     #[serde(serialize_with = "toml::ser::tables_last")]
-///     dependencies: HashMap<String, Dependency>,
-/// }
-/// # type Package = String;
-/// # type Dependency = String;
-/// # fn main() {}
-/// ```
-pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S) -> Result<S::Ok, S::Error>
-where
-    &'a I: IntoIterator<Item = (K, V)>,
-    K: ser::Serialize,
-    V: ser::Serialize,
-    S: ser::Serializer,
-{
-    use serde::ser::SerializeMap;
-
-    let mut map = serializer.serialize_map(None)?;
-    for (k, v) in data {
-        if let Category::Primitive = v.serialize(Categorize::new())? {
-            map.serialize_entry(&k, &v)?;
-        }
-    }
-    for (k, v) in data {
-        if let Category::Array = v.serialize(Categorize::new())? {
-            map.serialize_entry(&k, &v)?;
-        }
-    }
-    for (k, v) in data {
-        if let Category::Table = v.serialize(Categorize::new())? {
-            map.serialize_entry(&k, &v)?;
-        }
-    }
-    map.end()
-}
-
-struct Categorize<E>(marker::PhantomData<E>);
-
-impl<E> Categorize<E> {
-    fn new() -> Self {
-        Categorize(marker::PhantomData)
-    }
-}
-
-impl<E: ser::Error> ser::Serializer for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-    type SerializeSeq = Self;
-    type SerializeTuple = Self;
-    type SerializeTupleStruct = Self;
-    type SerializeTupleVariant = Self;
-    type SerializeMap = Self;
-    type SerializeStruct = Self;
-    type SerializeStructVariant = ser::Impossible<Category, E>;
-
-    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Primitive)
-    }
-
-    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Array)
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-
-    fn serialize_some<T: ?Sized + ser::Serialize>(self, v: &T) -> Result<Self::Ok, Self::Error> {
-        v.serialize(self)
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-
-    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
-        self,
-        _: &'static str,
-        v: &T,
-    ) -> Result<Self::Ok, Self::Error> {
-        v.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: &T,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-
-    fn serialize_seq(self, _: Option<usize>) -> Result<Self, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_map(self, _: Option<usize>) -> Result<Self, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self, Self::Error> {
-        Ok(self)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _: &'static str,
-        _: u32,
-        _: &'static str,
-        _: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(ser::Error::custom("unsupported"))
-    }
-}
-
-impl<E: ser::Error> ser::SerializeSeq for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Array)
-    }
-}
-
-impl<E: ser::Error> ser::SerializeTuple for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Array)
-    }
-}
-
-impl<E: ser::Error> ser::SerializeTupleVariant for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Array)
-    }
-}
-
-impl<E: ser::Error> ser::SerializeTupleStruct for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Array)
-    }
-}
-
-impl<E: ser::Error> ser::SerializeMap for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Table)
-    }
-}
-
-impl<E: ser::Error> ser::SerializeStruct for Categorize<E> {
-    type Ok = Category;
-    type Error = E;
-
-    fn serialize_field<T: ?Sized>(&mut self, _: &'static str, _: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(Category::Table)
-    }
-}
diff --git a/vendor/toml/src/spanned.rs b/vendor/toml/src/spanned.rs
deleted file mode 100644
index 9ee56ae6..00000000
--- a/vendor/toml/src/spanned.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-use serde::{de, ser};
-use std::borrow::Borrow;
-use std::cmp::Ordering;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-
-pub(crate) const NAME: &str = "$__toml_private_Spanned";
-pub(crate) const START: &str = "$__toml_private_start";
-pub(crate) const END: &str = "$__toml_private_end";
-pub(crate) const VALUE: &str = "$__toml_private_value";
-
-/// A spanned value, indicating the range at which it is defined in the source.
-///
-/// ```
-/// use serde_derive::Deserialize;
-/// use toml::Spanned;
-///
-/// #[derive(Deserialize)]
-/// struct Value {
-///     s: Spanned<String>,
-/// }
-///
-/// fn main() {
-///     let t = "s = \"value\"\n";
-///
-///     let u: Value = toml::from_str(t).unwrap();
-///
-///     assert_eq!(u.s.start(), 4);
-///     assert_eq!(u.s.end(), 11);
-///     assert_eq!(u.s.get_ref(), "value");
-///     assert_eq!(u.s.into_inner(), String::from("value"));
-/// }
-/// ```
-#[derive(Clone, Debug)]
-pub struct Spanned<T> {
-    /// The start range.
-    start: usize,
-    /// The end range (exclusive).
-    end: usize,
-    /// The spanned value.
-    value: T,
-}
-
-impl<T> Spanned<T> {
-    /// Access the start of the span of the contained value.
-    pub fn start(&self) -> usize {
-        self.start
-    }
-
-    /// Access the end of the span of the contained value.
-    pub fn end(&self) -> usize {
-        self.end
-    }
-
-    /// Get the span of the contained value.
-    pub fn span(&self) -> (usize, usize) {
-        (self.start, self.end)
-    }
-
-    /// Consumes the spanned value and returns the contained value.
-    pub fn into_inner(self) -> T {
-        self.value
-    }
-
-    /// Returns a reference to the contained value.
-    pub fn get_ref(&self) -> &T {
-        &self.value
-    }
-
-    /// Returns a mutable reference to the contained value.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.value
-    }
-}
-
-impl Borrow<str> for Spanned<String> {
-    fn borrow(&self) -> &str {
-        &self.get_ref()
-    }
-}
-
-impl<T: PartialEq> PartialEq for Spanned<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.value.eq(&other.value)
-    }
-}
-
-impl<T: Eq> Eq for Spanned<T> {}
-
-impl<T: Hash> Hash for Spanned<T> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.value.hash(state);
-    }
-}
-
-impl<T: PartialOrd> PartialOrd for Spanned<T> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.value.partial_cmp(&other.value)
-    }
-}
-
-impl<T: Ord> Ord for Spanned<T> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.value.cmp(&other.value)
-    }
-}
-
-impl<'de, T> de::Deserialize<'de> for Spanned<T>
-where
-    T: de::Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Spanned<T>, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct SpannedVisitor<T>(::std::marker::PhantomData<T>);
-
-        impl<'de, T> de::Visitor<'de> for SpannedVisitor<T>
-        where
-            T: de::Deserialize<'de>,
-        {
-            type Value = Spanned<T>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a TOML spanned")
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                if visitor.next_key()? != Some(START) {
-                    return Err(de::Error::custom("spanned start key not found"));
-                }
-
-                let start: usize = visitor.next_value()?;
-
-                if visitor.next_key()? != Some(END) {
-                    return Err(de::Error::custom("spanned end key not found"));
-                }
-
-                let end: usize = visitor.next_value()?;
-
-                if visitor.next_key()? != Some(VALUE) {
-                    return Err(de::Error::custom("spanned value key not found"));
-                }
-
-                let value: T = visitor.next_value()?;
-
-                Ok(Spanned { start, end, value })
-            }
-        }
-
-        let visitor = SpannedVisitor(::std::marker::PhantomData);
-
-        static FIELDS: [&str; 3] = [START, END, VALUE];
-        deserializer.deserialize_struct(NAME, &FIELDS, visitor)
-    }
-}
-
-impl<T: ser::Serialize> ser::Serialize for Spanned<T> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: ser::Serializer,
-    {
-        self.value.serialize(serializer)
-    }
-}
diff --git a/vendor/toml/src/tokens.rs b/vendor/toml/src/tokens.rs
deleted file mode 100644
index fd8b6b98..00000000
--- a/vendor/toml/src/tokens.rs
+++ /dev/null
@@ -1,744 +0,0 @@
-use std::borrow::Cow;
-use std::char;
-use std::str;
-use std::string;
-use std::string::String as StdString;
-
-use self::Token::*;
-
-/// A span, designating a range of bytes where a token is located.
-#[derive(Eq, PartialEq, Debug, Clone, Copy)]
-pub struct Span {
-    /// The start of the range.
-    pub start: usize,
-    /// The end of the range (exclusive).
-    pub end: usize,
-}
-
-impl From<Span> for (usize, usize) {
-    fn from(Span { start, end }: Span) -> (usize, usize) {
-        (start, end)
-    }
-}
-
-#[derive(Eq, PartialEq, Debug)]
-pub enum Token<'a> {
-    Whitespace(&'a str),
-    Newline,
-    Comment(&'a str),
-
-    Equals,
-    Period,
-    Comma,
-    Colon,
-    Plus,
-    LeftBrace,
-    RightBrace,
-    LeftBracket,
-    RightBracket,
-
-    Keylike(&'a str),
-    String {
-        src: &'a str,
-        val: Cow<'a, str>,
-        multiline: bool,
-    },
-}
-
-#[derive(Eq, PartialEq, Debug)]
-pub enum Error {
-    InvalidCharInString(usize, char),
-    InvalidEscape(usize, char),
-    InvalidHexEscape(usize, char),
-    InvalidEscapeValue(usize, u32),
-    NewlineInString(usize),
-    Unexpected(usize, char),
-    UnterminatedString(usize),
-    NewlineInTableKey(usize),
-    MultilineStringKey(usize),
-    EmptyTableKey(usize),
-    Wanted {
-        at: usize,
-        expected: &'static str,
-        found: &'static str,
-    },
-}
-
-#[derive(Clone)]
-pub struct Tokenizer<'a> {
-    input: &'a str,
-    chars: CrlfFold<'a>,
-}
-
-#[derive(Clone)]
-struct CrlfFold<'a> {
-    chars: str::CharIndices<'a>,
-}
-
-#[derive(Debug)]
-enum MaybeString {
-    NotEscaped(usize),
-    Owned(string::String),
-}
-
-impl<'a> Tokenizer<'a> {
-    pub fn new(input: &'a str) -> Tokenizer<'a> {
-        let mut t = Tokenizer {
-            input,
-            chars: CrlfFold {
-                chars: input.char_indices(),
-            },
-        };
-        // Eat utf-8 BOM
-        t.eatc('\u{feff}');
-        t
-    }
-
-    pub fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
-        let (start, token) = match self.one() {
-            Some((start, '\n')) => (start, Newline),
-            Some((start, ' ')) => (start, self.whitespace_token(start)),
-            Some((start, '\t')) => (start, self.whitespace_token(start)),
-            Some((start, '#')) => (start, self.comment_token(start)),
-            Some((start, '=')) => (start, Equals),
-            Some((start, '.')) => (start, Period),
-            Some((start, ',')) => (start, Comma),
-            Some((start, ':')) => (start, Colon),
-            Some((start, '+')) => (start, Plus),
-            Some((start, '{')) => (start, LeftBrace),
-            Some((start, '}')) => (start, RightBrace),
-            Some((start, '[')) => (start, LeftBracket),
-            Some((start, ']')) => (start, RightBracket),
-            Some((start, '\'')) => {
-                return self
-                    .literal_string(start)
-                    .map(|t| Some((self.step_span(start), t)))
-            }
-            Some((start, '"')) => {
-                return self
-                    .basic_string(start)
-                    .map(|t| Some((self.step_span(start), t)))
-            }
-            Some((start, ch)) if is_keylike(ch) => (start, self.keylike(start)),
-
-            Some((start, ch)) => return Err(Error::Unexpected(start, ch)),
-            None => return Ok(None),
-        };
-
-        let span = self.step_span(start);
-        Ok(Some((span, token)))
-    }
-
-    pub fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
-        self.clone().next()
-    }
-
-    pub fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
-        self.eat_spanned(expected).map(|s| s.is_some())
-    }
-
-    /// Eat a value, returning it's span if it was consumed.
-    pub fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
-        let span = match self.peek()? {
-            Some((span, ref found)) if expected == *found => span,
-            Some(_) => return Ok(None),
-            None => return Ok(None),
-        };
-
-        drop(self.next());
-        Ok(Some(span))
-    }
-
-    pub fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
-        // ignore span
-        let _ = self.expect_spanned(expected)?;
-        Ok(())
-    }
-
-    /// Expect the given token returning its span.
-    pub fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
-        let current = self.current();
-        match self.next()? {
-            Some((span, found)) => {
-                if expected == found {
-                    Ok(span)
-                } else {
-                    Err(Error::Wanted {
-                        at: current,
-                        expected: expected.describe(),
-                        found: found.describe(),
-                    })
-                }
-            }
-            None => Err(Error::Wanted {
-                at: self.input.len(),
-                expected: expected.describe(),
-                found: "eof",
-            }),
-        }
-    }
-
-    pub fn table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error> {
-        let current = self.current();
-        match self.next()? {
-            Some((span, Token::Keylike(k))) => Ok((span, k.into())),
-            Some((
-                span,
-                Token::String {
-                    src,
-                    val,
-                    multiline,
-                },
-            )) => {
-                let offset = self.substr_offset(src);
-                if multiline {
-                    return Err(Error::MultilineStringKey(offset));
-                }
-                if val == "" {
-                    return Err(Error::EmptyTableKey(offset));
-                }
-                match src.find('\n') {
-                    None => Ok((span, val)),
-                    Some(i) => Err(Error::NewlineInTableKey(offset + i)),
-                }
-            }
-            Some((_, other)) => Err(Error::Wanted {
-                at: current,
-                expected: "a table key",
-                found: other.describe(),
-            }),
-            None => Err(Error::Wanted {
-                at: self.input.len(),
-                expected: "a table key",
-                found: "eof",
-            }),
-        }
-    }
-
-    pub fn eat_whitespace(&mut self) -> Result<(), Error> {
-        while self.eatc(' ') || self.eatc('\t') {
-            // ...
-        }
-        Ok(())
-    }
-
-    pub fn eat_comment(&mut self) -> Result<bool, Error> {
-        if !self.eatc('#') {
-            return Ok(false);
-        }
-        drop(self.comment_token(0));
-        self.eat_newline_or_eof().map(|()| true)
-    }
-
-    pub fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
-        let current = self.current();
-        match self.next()? {
-            None | Some((_, Token::Newline)) => Ok(()),
-            Some((_, other)) => Err(Error::Wanted {
-                at: current,
-                expected: "newline",
-                found: other.describe(),
-            }),
-        }
-    }
-
-    pub fn skip_to_newline(&mut self) {
-        loop {
-            match self.one() {
-                Some((_, '\n')) | None => break,
-                _ => {}
-            }
-        }
-    }
-
-    fn eatc(&mut self, ch: char) -> bool {
-        match self.chars.clone().next() {
-            Some((_, ch2)) if ch == ch2 => {
-                self.one();
-                true
-            }
-            _ => false,
-        }
-    }
-
-    pub fn current(&mut self) -> usize {
-        self.chars
-            .clone()
-            .next()
-            .map(|i| i.0)
-            .unwrap_or_else(|| self.input.len())
-    }
-
-    pub fn input(&self) -> &'a str {
-        self.input
-    }
-
-    fn whitespace_token(&mut self, start: usize) -> Token<'a> {
-        while self.eatc(' ') || self.eatc('\t') {
-            // ...
-        }
-        Whitespace(&self.input[start..self.current()])
-    }
-
-    fn comment_token(&mut self, start: usize) -> Token<'a> {
-        while let Some((_, ch)) = self.chars.clone().next() {
-            if ch != '\t' && (ch < '\u{20}' || ch > '\u{10ffff}') {
-                break;
-            }
-            self.one();
-        }
-        Comment(&self.input[start..self.current()])
-    }
-
-    fn read_string(
-        &mut self,
-        delim: char,
-        start: usize,
-        new_ch: &mut dyn FnMut(
-            &mut Tokenizer<'_>,
-            &mut MaybeString,
-            bool,
-            usize,
-            char,
-        ) -> Result<(), Error>,
-    ) -> Result<Token<'a>, Error> {
-        let mut multiline = false;
-        if self.eatc(delim) {
-            if self.eatc(delim) {
-                multiline = true;
-            } else {
-                return Ok(String {
-                    src: &self.input[start..start + 2],
-                    val: Cow::Borrowed(""),
-                    multiline: false,
-                });
-            }
-        }
-        let mut val = MaybeString::NotEscaped(self.current());
-        let mut n = 0;
-        'outer: loop {
-            n += 1;
-            match self.one() {
-                Some((i, '\n')) => {
-                    if multiline {
-                        if self.input.as_bytes()[i] == b'\r' {
-                            val.to_owned(&self.input[..i]);
-                        }
-                        if n == 1 {
-                            val = MaybeString::NotEscaped(self.current());
-                        } else {
-                            val.push('\n');
-                        }
-                        continue;
-                    } else {
-                        return Err(Error::NewlineInString(i));
-                    }
-                }
-                Some((mut i, ch)) if ch == delim => {
-                    if multiline {
-                        if !self.eatc(delim) {
-                            val.push(delim);
-                            continue 'outer;
-                        }
-                        if !self.eatc(delim) {
-                            val.push(delim);
-                            val.push(delim);
-                            continue 'outer;
-                        }
-                        if self.eatc(delim) {
-                            val.push(delim);
-                            i += 1;
-                        }
-                        if self.eatc(delim) {
-                            val.push(delim);
-                            i += 1;
-                        }
-                    }
-                    return Ok(String {
-                        src: &self.input[start..self.current()],
-                        val: val.into_cow(&self.input[..i]),
-                        multiline,
-                    });
-                }
-                Some((i, c)) => new_ch(self, &mut val, multiline, i, c)?,
-                None => return Err(Error::UnterminatedString(start)),
-            }
-        }
-    }
-
-    fn literal_string(&mut self, start: usize) -> Result<Token<'a>, Error> {
-        self.read_string('\'', start, &mut |_me, val, _multi, i, ch| {
-            if ch == '\u{09}' || ('\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}') {
-                val.push(ch);
-                Ok(())
-            } else {
-                Err(Error::InvalidCharInString(i, ch))
-            }
-        })
-    }
-
-    fn basic_string(&mut self, start: usize) -> Result<Token<'a>, Error> {
-        self.read_string('"', start, &mut |me, val, multi, i, ch| match ch {
-            '\\' => {
-                val.to_owned(&me.input[..i]);
-                match me.chars.next() {
-                    Some((_, '"')) => val.push('"'),
-                    Some((_, '\\')) => val.push('\\'),
-                    Some((_, 'b')) => val.push('\u{8}'),
-                    Some((_, 'f')) => val.push('\u{c}'),
-                    Some((_, 'n')) => val.push('\n'),
-                    Some((_, 'r')) => val.push('\r'),
-                    Some((_, 't')) => val.push('\t'),
-                    Some((i, c @ 'u')) | Some((i, c @ 'U')) => {
-                        let len = if c == 'u' { 4 } else { 8 };
-                        val.push(me.hex(start, i, len)?);
-                    }
-                    Some((i, c @ ' ')) | Some((i, c @ '\t')) | Some((i, c @ '\n')) if multi => {
-                        if c != '\n' {
-                            while let Some((_, ch)) = me.chars.clone().next() {
-                                match ch {
-                                    ' ' | '\t' => {
-                                        me.chars.next();
-                                        continue;
-                                    }
-                                    '\n' => {
-                                        me.chars.next();
-                                        break;
-                                    }
-                                    _ => return Err(Error::InvalidEscape(i, c)),
-                                }
-                            }
-                        }
-                        while let Some((_, ch)) = me.chars.clone().next() {
-                            match ch {
-                                ' ' | '\t' | '\n' => {
-                                    me.chars.next();
-                                }
-                                _ => break,
-                            }
-                        }
-                    }
-                    Some((i, c)) => return Err(Error::InvalidEscape(i, c)),
-                    None => return Err(Error::UnterminatedString(start)),
-                }
-                Ok(())
-            }
-            ch if ch == '\u{09}' || ('\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}') => {
-                val.push(ch);
-                Ok(())
-            }
-            _ => Err(Error::InvalidCharInString(i, ch)),
-        })
-    }
-
-    fn hex(&mut self, start: usize, i: usize, len: usize) -> Result<char, Error> {
-        let mut buf = StdString::with_capacity(len);
-        for _ in 0..len {
-            match self.one() {
-                Some((_, ch)) if ch as u32 <= 0x7F && ch.is_digit(16) => buf.push(ch),
-                Some((i, ch)) => return Err(Error::InvalidHexEscape(i, ch)),
-                None => return Err(Error::UnterminatedString(start)),
-            }
-        }
-        let val = u32::from_str_radix(&buf, 16).unwrap();
-        match char::from_u32(val) {
-            Some(ch) => Ok(ch),
-            None => Err(Error::InvalidEscapeValue(i, val)),
-        }
-    }
-
-    fn keylike(&mut self, start: usize) -> Token<'a> {
-        while let Some((_, ch)) = self.peek_one() {
-            if !is_keylike(ch) {
-                break;
-            }
-            self.one();
-        }
-        Keylike(&self.input[start..self.current()])
-    }
-
-    pub fn substr_offset(&self, s: &'a str) -> usize {
-        assert!(s.len() <= self.input.len());
-        let a = self.input.as_ptr() as usize;
-        let b = s.as_ptr() as usize;
-        assert!(a <= b);
-        b - a
-    }
-
-    /// Calculate the span of a single character.
-    fn step_span(&mut self, start: usize) -> Span {
-        let end = self
-            .peek_one()
-            .map(|t| t.0)
-            .unwrap_or_else(|| self.input.len());
-        Span { start, end }
-    }
-
-    /// Peek one char without consuming it.
-    fn peek_one(&mut self) -> Option<(usize, char)> {
-        self.chars.clone().next()
-    }
-
-    /// Take one char.
-    pub fn one(&mut self) -> Option<(usize, char)> {
-        self.chars.next()
-    }
-}
-
-impl<'a> Iterator for CrlfFold<'a> {
-    type Item = (usize, char);
-
-    fn next(&mut self) -> Option<(usize, char)> {
-        self.chars.next().map(|(i, c)| {
-            if c == '\r' {
-                let mut attempt = self.chars.clone();
-                if let Some((_, '\n')) = attempt.next() {
-                    self.chars = attempt;
-                    return (i, '\n');
-                }
-            }
-            (i, c)
-        })
-    }
-}
-
-impl MaybeString {
-    fn push(&mut self, ch: char) {
-        match *self {
-            MaybeString::NotEscaped(..) => {}
-            MaybeString::Owned(ref mut s) => s.push(ch),
-        }
-    }
-
-    fn to_owned(&mut self, input: &str) {
-        match *self {
-            MaybeString::NotEscaped(start) => {
-                *self = MaybeString::Owned(input[start..].to_owned());
-            }
-            MaybeString::Owned(..) => {}
-        }
-    }
-
-    fn into_cow(self, input: &str) -> Cow<'_, str> {
-        match self {
-            MaybeString::NotEscaped(start) => Cow::Borrowed(&input[start..]),
-            MaybeString::Owned(s) => Cow::Owned(s),
-        }
-    }
-}
-
-fn is_keylike(ch: char) -> bool {
-    ('A' <= ch && ch <= 'Z')
-        || ('a' <= ch && ch <= 'z')
-        || ('0' <= ch && ch <= '9')
-        || ch == '-'
-        || ch == '_'
-}
-
-impl<'a> Token<'a> {
-    pub fn describe(&self) -> &'static str {
-        match *self {
-            Token::Keylike(_) => "an identifier",
-            Token::Equals => "an equals",
-            Token::Period => "a period",
-            Token::Comment(_) => "a comment",
-            Token::Newline => "a newline",
-            Token::Whitespace(_) => "whitespace",
-            Token::Comma => "a comma",
-            Token::RightBrace => "a right brace",
-            Token::LeftBrace => "a left brace",
-            Token::RightBracket => "a right bracket",
-            Token::LeftBracket => "a left bracket",
-            Token::String { multiline, .. } => {
-                if multiline {
-                    "a multiline string"
-                } else {
-                    "a string"
-                }
-            }
-            Token::Colon => "a colon",
-            Token::Plus => "a plus",
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Error, Token, Tokenizer};
-    use std::borrow::Cow;
-
-    fn err(input: &str, err: Error) {
-        let mut t = Tokenizer::new(input);
-        let token = t.next().unwrap_err();
-        assert_eq!(token, err);
-        assert!(t.next().unwrap().is_none());
-    }
-
-    #[test]
-    fn literal_strings() {
-        fn t(input: &str, val: &str, multiline: bool) {
-            let mut t = Tokenizer::new(input);
-            let (_, token) = t.next().unwrap().unwrap();
-            assert_eq!(
-                token,
-                Token::String {
-                    src: input,
-                    val: Cow::Borrowed(val),
-                    multiline: multiline,
-                }
-            );
-            assert!(t.next().unwrap().is_none());
-        }
-
-        t("''", "", false);
-        t("''''''", "", true);
-        t("'''\n'''", "", true);
-        t("'a'", "a", false);
-        t("'\"a'", "\"a", false);
-        t("''''a'''", "'a", true);
-        t("'''\n'a\n'''", "'a\n", true);
-        t("'''a\n'a\r\n'''", "a\n'a\n", true);
-    }
-
-    #[test]
-    fn basic_strings() {
-        fn t(input: &str, val: &str, multiline: bool) {
-            let mut t = Tokenizer::new(input);
-            let (_, token) = t.next().unwrap().unwrap();
-            assert_eq!(
-                token,
-                Token::String {
-                    src: input,
-                    val: Cow::Borrowed(val),
-                    multiline: multiline,
-                }
-            );
-            assert!(t.next().unwrap().is_none());
-        }
-
-        t(r#""""#, "", false);
-        t(r#""""""""#, "", true);
-        t(r#""a""#, "a", false);
-        t(r#""""a""""#, "a", true);
-        t(r#""\t""#, "\t", false);
-        t(r#""\u0000""#, "\0", false);
-        t(r#""\U00000000""#, "\0", false);
-        t(r#""\U000A0000""#, "\u{A0000}", false);
-        t(r#""\\t""#, "\\t", false);
-        t("\"\t\"", "\t", false);
-        t("\"\"\"\n\t\"\"\"", "\t", true);
-        t("\"\"\"\\\n\"\"\"", "", true);
-        t(
-            "\"\"\"\\\n     \t   \t  \\\r\n  \t \n  \t \r\n\"\"\"",
-            "",
-            true,
-        );
-        t(r#""\r""#, "\r", false);
-        t(r#""\n""#, "\n", false);
-        t(r#""\b""#, "\u{8}", false);
-        t(r#""a\fa""#, "a\u{c}a", false);
-        t(r#""\"a""#, "\"a", false);
-        t("\"\"\"\na\"\"\"", "a", true);
-        t("\"\"\"\n\"\"\"", "", true);
-        t(r#""""a\"""b""""#, "a\"\"\"b", true);
-        err(r#""\a"#, Error::InvalidEscape(2, 'a'));
-        err("\"\\\n", Error::InvalidEscape(2, '\n'));
-        err("\"\\\r\n", Error::InvalidEscape(2, '\n'));
-        err("\"\\", Error::UnterminatedString(0));
-        err("\"\u{0}", Error::InvalidCharInString(1, '\u{0}'));
-        err(r#""\U00""#, Error::InvalidHexEscape(5, '"'));
-        err(r#""\U00"#, Error::UnterminatedString(0));
-        err(r#""\uD800"#, Error::InvalidEscapeValue(2, 0xd800));
-        err(r#""\UFFFFFFFF"#, Error::InvalidEscapeValue(2, 0xffff_ffff));
-    }
-
-    #[test]
-    fn keylike() {
-        fn t(input: &str) {
-            let mut t = Tokenizer::new(input);
-            let (_, token) = t.next().unwrap().unwrap();
-            assert_eq!(token, Token::Keylike(input));
-            assert!(t.next().unwrap().is_none());
-        }
-        t("foo");
-        t("0bar");
-        t("bar0");
-        t("1234");
-        t("a-b");
-        t("a_B");
-        t("-_-");
-        t("___");
-    }
-
-    #[test]
-    fn all() {
-        fn t(input: &str, expected: &[((usize, usize), Token<'_>, &str)]) {
-            let mut tokens = Tokenizer::new(input);
-            let mut actual: Vec<((usize, usize), Token<'_>, &str)> = Vec::new();
-            while let Some((span, token)) = tokens.next().unwrap() {
-                actual.push((span.into(), token, &input[span.start..span.end]));
-            }
-            for (a, b) in actual.iter().zip(expected) {
-                assert_eq!(a, b);
-            }
-            assert_eq!(actual.len(), expected.len());
-        }
-
-        t(
-            " a ",
-            &[
-                ((0, 1), Token::Whitespace(" "), " "),
-                ((1, 2), Token::Keylike("a"), "a"),
-                ((2, 3), Token::Whitespace(" "), " "),
-            ],
-        );
-
-        t(
-            " a\t [[]] \t [] {} , . =\n# foo \r\n#foo \n ",
-            &[
-                ((0, 1), Token::Whitespace(" "), " "),
-                ((1, 2), Token::Keylike("a"), "a"),
-                ((2, 4), Token::Whitespace("\t "), "\t "),
-                ((4, 5), Token::LeftBracket, "["),
-                ((5, 6), Token::LeftBracket, "["),
-                ((6, 7), Token::RightBracket, "]"),
-                ((7, 8), Token::RightBracket, "]"),
-                ((8, 11), Token::Whitespace(" \t "), " \t "),
-                ((11, 12), Token::LeftBracket, "["),
-                ((12, 13), Token::RightBracket, "]"),
-                ((13, 14), Token::Whitespace(" "), " "),
-                ((14, 15), Token::LeftBrace, "{"),
-                ((15, 16), Token::RightBrace, "}"),
-                ((16, 17), Token::Whitespace(" "), " "),
-                ((17, 18), Token::Comma, ","),
-                ((18, 19), Token::Whitespace(" "), " "),
-                ((19, 20), Token::Period, "."),
-                ((20, 21), Token::Whitespace(" "), " "),
-                ((21, 22), Token::Equals, "="),
-                ((22, 23), Token::Newline, "\n"),
-                ((23, 29), Token::Comment("# foo "), "# foo "),
-                ((29, 31), Token::Newline, "\r\n"),
-                ((31, 36), Token::Comment("#foo "), "#foo "),
-                ((36, 37), Token::Newline, "\n"),
-                ((37, 38), Token::Whitespace(" "), " "),
-            ],
-        );
-    }
-
-    #[test]
-    fn bare_cr_bad() {
-        err("\r", Error::Unexpected(0, '\r'));
-        err("'\n", Error::NewlineInString(1));
-        err("'\u{0}", Error::InvalidCharInString(1, '\u{0}'));
-        err("'", Error::UnterminatedString(0));
-        err("\u{0}", Error::Unexpected(0, '\u{0}'));
-    }
-
-    #[test]
-    fn bad_comment() {
-        let mut t = Tokenizer::new("#\u{0}");
-        t.next().unwrap().unwrap();
-        assert_eq!(t.next(), Err(Error::Unexpected(1, '\u{0}')));
-        assert!(t.next().unwrap().is_none());
-    }
-}
diff --git a/vendor/toml/src/value.rs b/vendor/toml/src/value.rs
deleted file mode 100644
index 38dfe1f6..00000000
--- a/vendor/toml/src/value.rs
+++ /dev/null
@@ -1,1080 +0,0 @@
-//! Definition of a TOML value
-
-use std::collections::{BTreeMap, HashMap};
-use std::fmt;
-use std::hash::Hash;
-use std::mem::discriminant;
-use std::ops;
-use std::str::FromStr;
-use std::vec;
-
-use serde::de;
-use serde::de::IntoDeserializer;
-use serde::ser;
-
-use crate::datetime::{self, DatetimeFromString};
-pub use crate::datetime::{Datetime, DatetimeParseError};
-
-pub use crate::map::Map;
-
-/// Representation of a TOML value.
-#[derive(PartialEq, Clone, Debug)]
-pub enum Value {
-    /// Represents a TOML string
-    String(String),
-    /// Represents a TOML integer
-    Integer(i64),
-    /// Represents a TOML float
-    Float(f64),
-    /// Represents a TOML boolean
-    Boolean(bool),
-    /// Represents a TOML datetime
-    Datetime(Datetime),
-    /// Represents a TOML array
-    Array(Array),
-    /// Represents a TOML table
-    Table(Table),
-}
-
-/// Type representing a TOML array, payload of the `Value::Array` variant
-pub type Array = Vec<Value>;
-
-/// Type representing a TOML table, payload of the `Value::Table` variant.
-/// By default it is backed by a BTreeMap, enable the `preserve_order` feature
-/// to use a LinkedHashMap instead.
-pub type Table = Map<String, Value>;
-
-impl Value {
-    /// Convert a `T` into `toml::Value` which is an enum that can represent
-    /// any valid TOML data.
-    ///
-    /// This conversion can fail if `T`'s implementation of `Serialize` decides to
-    /// fail, or if `T` contains a map with non-string keys.
-    pub fn try_from<T>(value: T) -> Result<Value, crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(Serializer)
-    }
-
-    /// Interpret a `toml::Value` as an instance of type `T`.
-    ///
-    /// This conversion can fail if the structure of the `Value` does not match the
-    /// structure expected by `T`, for example if `T` is a struct type but the
-    /// `Value` contains something other than a TOML table. It can also fail if the
-    /// structure is correct but `T`'s implementation of `Deserialize` decides that
-    /// something is wrong with the data, for example required struct fields are
-    /// missing from the TOML map or some number is too big to fit in the expected
-    /// primitive type.
-    pub fn try_into<'de, T>(self) -> Result<T, crate::de::Error>
-    where
-        T: de::Deserialize<'de>,
-    {
-        de::Deserialize::deserialize(self)
-    }
-
-    /// Index into a TOML array or map. A string index can be used to access a
-    /// value in a map, and a usize index can be used to access an element of an
-    /// array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
-        index.index(self)
-    }
-
-    /// Mutably index into a TOML array or map. A string index can be used to
-    /// access a value in a map, and a usize index can be used to access an
-    /// element of an array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
-        index.index_mut(self)
-    }
-
-    /// Extracts the integer value if it is an integer.
-    pub fn as_integer(&self) -> Option<i64> {
-        match *self {
-            Value::Integer(i) => Some(i),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is an integer.
-    pub fn is_integer(&self) -> bool {
-        self.as_integer().is_some()
-    }
-
-    /// Extracts the float value if it is a float.
-    pub fn as_float(&self) -> Option<f64> {
-        match *self {
-            Value::Float(f) => Some(f),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is a float.
-    pub fn is_float(&self) -> bool {
-        self.as_float().is_some()
-    }
-
-    /// Extracts the boolean value if it is a boolean.
-    pub fn as_bool(&self) -> Option<bool> {
-        match *self {
-            Value::Boolean(b) => Some(b),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is a boolean.
-    pub fn is_bool(&self) -> bool {
-        self.as_bool().is_some()
-    }
-
-    /// Extracts the string of this value if it is a string.
-    pub fn as_str(&self) -> Option<&str> {
-        match *self {
-            Value::String(ref s) => Some(&**s),
-            _ => None,
-        }
-    }
-
-    /// Tests if this value is a string.
-    pub fn is_str(&self) -> bool {
-        self.as_str().is_some()
-    }
-
-    /// Extracts the datetime value if it is a datetime.
-    ///
-    /// Note that a parsed TOML value will only contain ISO 8601 dates. An
-    /// example date is:
-    ///
-    /// ```notrust
-    /// 1979-05-27T07:32:00Z
-    /// ```
-    pub fn as_datetime(&self) -> Option<&Datetime> {
-        match *self {
-            Value::Datetime(ref s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is a datetime.
-    pub fn is_datetime(&self) -> bool {
-        self.as_datetime().is_some()
-    }
-
-    /// Extracts the array value if it is an array.
-    pub fn as_array(&self) -> Option<&Vec<Value>> {
-        match *self {
-            Value::Array(ref s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Extracts the array value if it is an array.
-    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
-        match *self {
-            Value::Array(ref mut s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is an array.
-    pub fn is_array(&self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// Extracts the table value if it is a table.
-    pub fn as_table(&self) -> Option<&Table> {
-        match *self {
-            Value::Table(ref s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Extracts the table value if it is a table.
-    pub fn as_table_mut(&mut self) -> Option<&mut Table> {
-        match *self {
-            Value::Table(ref mut s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Tests whether this value is a table.
-    pub fn is_table(&self) -> bool {
-        self.as_table().is_some()
-    }
-
-    /// Tests whether this and another value have the same type.
-    pub fn same_type(&self, other: &Value) -> bool {
-        discriminant(self) == discriminant(other)
-    }
-
-    /// Returns a human-readable representation of the type of this value.
-    pub fn type_str(&self) -> &'static str {
-        match *self {
-            Value::String(..) => "string",
-            Value::Integer(..) => "integer",
-            Value::Float(..) => "float",
-            Value::Boolean(..) => "boolean",
-            Value::Datetime(..) => "datetime",
-            Value::Array(..) => "array",
-            Value::Table(..) => "table",
-        }
-    }
-}
-
-impl<I> ops::Index<I> for Value
-where
-    I: Index,
-{
-    type Output = Value;
-
-    fn index(&self, index: I) -> &Value {
-        self.get(index).expect("index not found")
-    }
-}
-
-impl<I> ops::IndexMut<I> for Value
-where
-    I: Index,
-{
-    fn index_mut(&mut self, index: I) -> &mut Value {
-        self.get_mut(index).expect("index not found")
-    }
-}
-
-impl<'a> From<&'a str> for Value {
-    #[inline]
-    fn from(val: &'a str) -> Value {
-        Value::String(val.to_string())
-    }
-}
-
-impl<V: Into<Value>> From<Vec<V>> for Value {
-    fn from(val: Vec<V>) -> Value {
-        Value::Array(val.into_iter().map(|v| v.into()).collect())
-    }
-}
-
-impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value {
-    fn from(val: BTreeMap<S, V>) -> Value {
-        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
-
-        Value::Table(table)
-    }
-}
-
-impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value {
-    fn from(val: HashMap<S, V>) -> Value {
-        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
-
-        Value::Table(table)
-    }
-}
-
-macro_rules! impl_into_value {
-    ($variant:ident : $T:ty) => {
-        impl From<$T> for Value {
-            #[inline]
-            fn from(val: $T) -> Value {
-                Value::$variant(val.into())
-            }
-        }
-    };
-}
-
-impl_into_value!(String: String);
-impl_into_value!(Integer: i64);
-impl_into_value!(Integer: i32);
-impl_into_value!(Integer: i8);
-impl_into_value!(Integer: u8);
-impl_into_value!(Integer: u32);
-impl_into_value!(Float: f64);
-impl_into_value!(Float: f32);
-impl_into_value!(Boolean: bool);
-impl_into_value!(Datetime: Datetime);
-impl_into_value!(Table: Table);
-
-/// Types that can be used to index a `toml::Value`
-///
-/// Currently this is implemented for `usize` to index arrays and `str` to index
-/// tables.
-///
-/// This trait is sealed and not intended for implementation outside of the
-/// `toml` crate.
-pub trait Index: Sealed {
-    #[doc(hidden)]
-    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value>;
-    #[doc(hidden)]
-    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value>;
-}
-
-/// An implementation detail that should not be implemented, this will change in
-/// the future and break code otherwise.
-#[doc(hidden)]
-pub trait Sealed {}
-impl Sealed for usize {}
-impl Sealed for str {}
-impl Sealed for String {}
-impl<'a, T: Sealed + ?Sized> Sealed for &'a T {}
-
-impl Index for usize {
-    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
-        match *val {
-            Value::Array(ref a) => a.get(*self),
-            _ => None,
-        }
-    }
-
-    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
-        match *val {
-            Value::Array(ref mut a) => a.get_mut(*self),
-            _ => None,
-        }
-    }
-}
-
-impl Index for str {
-    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
-        match *val {
-            Value::Table(ref a) => a.get(self),
-            _ => None,
-        }
-    }
-
-    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
-        match *val {
-            Value::Table(ref mut a) => a.get_mut(self),
-            _ => None,
-        }
-    }
-}
-
-impl Index for String {
-    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
-        self[..].index(val)
-    }
-
-    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
-        self[..].index_mut(val)
-    }
-}
-
-impl<'s, T: ?Sized> Index for &'s T
-where
-    T: Index,
-{
-    fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
-        (**self).index(val)
-    }
-
-    fn index_mut<'a>(&self, val: &'a mut Value) -> Option<&'a mut Value> {
-        (**self).index_mut(val)
-    }
-}
-
-impl fmt::Display for Value {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        crate::ser::to_string(self)
-            .expect("Unable to represent value as string")
-            .fmt(f)
-    }
-}
-
-impl FromStr for Value {
-    type Err = crate::de::Error;
-    fn from_str(s: &str) -> Result<Value, Self::Err> {
-        crate::from_str(s)
-    }
-}
-
-impl ser::Serialize for Value {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: ser::Serializer,
-    {
-        use serde::ser::SerializeMap;
-
-        match *self {
-            Value::String(ref s) => serializer.serialize_str(s),
-            Value::Integer(i) => serializer.serialize_i64(i),
-            Value::Float(f) => serializer.serialize_f64(f),
-            Value::Boolean(b) => serializer.serialize_bool(b),
-            Value::Datetime(ref s) => s.serialize(serializer),
-            Value::Array(ref a) => a.serialize(serializer),
-            Value::Table(ref t) => {
-                let mut map = serializer.serialize_map(Some(t.len()))?;
-                // Be sure to visit non-tables first (and also non
-                // array-of-tables) as all keys must be emitted first.
-                for (k, v) in t {
-                    if !v.is_table() && !v.is_array()
-                        || (v
-                            .as_array()
-                            .map(|a| !a.iter().any(|v| v.is_table()))
-                            .unwrap_or(false))
-                    {
-                        map.serialize_entry(k, v)?;
-                    }
-                }
-                for (k, v) in t {
-                    if v.as_array()
-                        .map(|a| a.iter().any(|v| v.is_table()))
-                        .unwrap_or(false)
-                    {
-                        map.serialize_entry(k, v)?;
-                    }
-                }
-                for (k, v) in t {
-                    if v.is_table() {
-                        map.serialize_entry(k, v)?;
-                    }
-                }
-                map.end()
-            }
-        }
-    }
-}
-
-impl<'de> de::Deserialize<'de> for Value {
-    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct ValueVisitor;
-
-        impl<'de> de::Visitor<'de> for ValueVisitor {
-            type Value = Value;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("any valid TOML value")
-            }
-
-            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
-                Ok(Value::Boolean(value))
-            }
-
-            fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
-                Ok(Value::Integer(value))
-            }
-
-            fn visit_u64<E: de::Error>(self, value: u64) -> Result<Value, E> {
-                if value <= i64::max_value() as u64 {
-                    Ok(Value::Integer(value as i64))
-                } else {
-                    Err(de::Error::custom("u64 value was too large"))
-                }
-            }
-
-            fn visit_u32<E>(self, value: u32) -> Result<Value, E> {
-                Ok(Value::Integer(value.into()))
-            }
-
-            fn visit_i32<E>(self, value: i32) -> Result<Value, E> {
-                Ok(Value::Integer(value.into()))
-            }
-
-            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
-                Ok(Value::Float(value))
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<Value, E> {
-                Ok(Value::String(value.into()))
-            }
-
-            fn visit_string<E>(self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
-            where
-                D: de::Deserializer<'de>,
-            {
-                de::Deserialize::deserialize(deserializer)
-            }
-
-            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: de::SeqAccess<'de>,
-            {
-                let mut vec = Vec::new();
-                while let Some(elem) = visitor.next_element()? {
-                    vec.push(elem);
-                }
-                Ok(Value::Array(vec))
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let mut key = String::new();
-                let datetime = visitor.next_key_seed(DatetimeOrTable { key: &mut key })?;
-                match datetime {
-                    Some(true) => {
-                        let date: DatetimeFromString = visitor.next_value()?;
-                        return Ok(Value::Datetime(date.value));
-                    }
-                    None => return Ok(Value::Table(Map::new())),
-                    Some(false) => {}
-                }
-                let mut map = Map::new();
-                map.insert(key, visitor.next_value()?);
-                while let Some(key) = visitor.next_key()? {
-                    if map.contains_key(&key) {
-                        let msg = format!("duplicate key: `{}`", key);
-                        return Err(de::Error::custom(msg));
-                    }
-                    map.insert(key, visitor.next_value()?);
-                }
-                Ok(Value::Table(map))
-            }
-        }
-
-        deserializer.deserialize_any(ValueVisitor)
-    }
-}
-
-impl<'de> de::Deserializer<'de> for Value {
-    type Error = crate::de::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, crate::de::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self {
-            Value::Boolean(v) => visitor.visit_bool(v),
-            Value::Integer(n) => visitor.visit_i64(n),
-            Value::Float(n) => visitor.visit_f64(n),
-            Value::String(v) => visitor.visit_string(v),
-            Value::Datetime(v) => visitor.visit_string(v.to_string()),
-            Value::Array(v) => {
-                let len = v.len();
-                let mut deserializer = SeqDeserializer::new(v);
-                let seq = visitor.visit_seq(&mut deserializer)?;
-                let remaining = deserializer.iter.len();
-                if remaining == 0 {
-                    Ok(seq)
-                } else {
-                    Err(de::Error::invalid_length(len, &"fewer elements in array"))
-                }
-            }
-            Value::Table(v) => {
-                let len = v.len();
-                let mut deserializer = MapDeserializer::new(v);
-                let map = visitor.visit_map(&mut deserializer)?;
-                let remaining = deserializer.iter.len();
-                if remaining == 0 {
-                    Ok(map)
-                } else {
-                    Err(de::Error::invalid_length(len, &"fewer elements in map"))
-                }
-            }
-        }
-    }
-
-    #[inline]
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, crate::de::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self {
-            Value::String(variant) => visitor.visit_enum(variant.into_deserializer()),
-            _ => Err(de::Error::invalid_type(
-                de::Unexpected::UnitVariant,
-                &"string only",
-            )),
-        }
-    }
-
-    // `None` is interpreted as a missing field so be sure to implement `Some`
-    // as a present field.
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, crate::de::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_some(self)
-    }
-
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, crate::de::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    serde::forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
-        bytes byte_buf map unit_struct tuple_struct struct
-        tuple ignored_any identifier
-    }
-}
-
-struct SeqDeserializer {
-    iter: vec::IntoIter<Value>,
-}
-
-impl SeqDeserializer {
-    fn new(vec: Vec<Value>) -> Self {
-        SeqDeserializer {
-            iter: vec.into_iter(),
-        }
-    }
-}
-
-impl<'de> de::SeqAccess<'de> for SeqDeserializer {
-    type Error = crate::de::Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, crate::de::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => seed.deserialize(value).map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapDeserializer {
-    iter: <Map<String, Value> as IntoIterator>::IntoIter,
-    value: Option<(String, Value)>,
-}
-
-impl MapDeserializer {
-    fn new(map: Map<String, Value>) -> Self {
-        MapDeserializer {
-            iter: map.into_iter(),
-            value: None,
-        }
-    }
-}
-
-impl<'de> de::MapAccess<'de> for MapDeserializer {
-    type Error = crate::de::Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, crate::de::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.value = Some((key.clone(), value));
-                seed.deserialize(Value::String(key)).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, crate::de::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let (key, res) = match self.value.take() {
-            Some((key, value)) => (key, seed.deserialize(value)),
-            None => return Err(de::Error::custom("value is missing")),
-        };
-        res.map_err(|mut error| {
-            error.add_key_context(&key);
-            error
-        })
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-impl<'de> de::IntoDeserializer<'de, crate::de::Error> for Value {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self {
-        self
-    }
-}
-
-struct Serializer;
-
-impl ser::Serializer for Serializer {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    type SerializeSeq = SerializeVec;
-    type SerializeTuple = SerializeVec;
-    type SerializeTupleStruct = SerializeVec;
-    type SerializeTupleVariant = SerializeVec;
-    type SerializeMap = SerializeMap;
-    type SerializeStruct = SerializeMap;
-    type SerializeStructVariant = ser::Impossible<Value, crate::ser::Error>;
-
-    fn serialize_bool(self, value: bool) -> Result<Value, crate::ser::Error> {
-        Ok(Value::Boolean(value))
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Value, crate::ser::Error> {
-        Ok(Value::Integer(value))
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<Value, crate::ser::Error> {
-        self.serialize_i64(value.into())
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<Value, crate::ser::Error> {
-        if value <= i64::max_value() as u64 {
-            self.serialize_i64(value as i64)
-        } else {
-            Err(ser::Error::custom("u64 value was too large"))
-        }
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<Value, crate::ser::Error> {
-        self.serialize_f64(value.into())
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<Value, crate::ser::Error> {
-        Ok(Value::Float(value))
-    }
-
-    fn serialize_char(self, value: char) -> Result<Value, crate::ser::Error> {
-        let mut s = String::new();
-        s.push(value);
-        self.serialize_str(&s)
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Value, crate::ser::Error> {
-        Ok(Value::String(value.to_owned()))
-    }
-
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value, crate::ser::Error> {
-        let vec = value.iter().map(|&b| Value::Integer(b.into())).collect();
-        Ok(Value::Array(vec))
-    }
-
-    fn serialize_unit(self) -> Result<Value, crate::ser::Error> {
-        Err(crate::ser::Error::UnsupportedType)
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, crate::ser::Error> {
-        Err(crate::ser::Error::UnsupportedType)
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Value, crate::ser::Error> {
-        self.serialize_str(_variant)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Value, crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Value, crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(crate::ser::Error::UnsupportedType)
-    }
-
-    fn serialize_none(self) -> Result<Value, crate::ser::Error> {
-        Err(crate::ser::Error::UnsupportedNone)
-    }
-
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, crate::ser::Error> {
-        Ok(SerializeVec {
-            vec: Vec::with_capacity(len.unwrap_or(0)),
-        })
-    }
-
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, crate::ser::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct, crate::ser::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant, crate::ser::Error> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, crate::ser::Error> {
-        Ok(SerializeMap {
-            map: Map::new(),
-            next_key: None,
-        })
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStruct, crate::ser::Error> {
-        self.serialize_map(Some(len))
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, crate::ser::Error> {
-        Err(crate::ser::Error::UnsupportedType)
-    }
-}
-
-struct SerializeVec {
-    vec: Vec<Value>,
-}
-
-struct SerializeMap {
-    map: Map<String, Value>,
-    next_key: Option<String>,
-}
-
-impl ser::SerializeSeq for SerializeVec {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        self.vec.push(Value::try_from(value)?);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        Ok(Value::Array(self.vec))
-    }
-}
-
-impl ser::SerializeTuple for SerializeVec {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl ser::SerializeTupleStruct for SerializeVec {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl ser::SerializeTupleVariant for SerializeVec {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl ser::SerializeMap for SerializeMap {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        match Value::try_from(key)? {
-            Value::String(s) => self.next_key = Some(s),
-            _ => return Err(crate::ser::Error::KeyNotString),
-        };
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        let key = self.next_key.take();
-        let key = key.expect("serialize_value called before serialize_key");
-        match Value::try_from(value) {
-            Ok(value) => {
-                self.map.insert(key, value);
-            }
-            Err(crate::ser::Error::UnsupportedNone) => {}
-            Err(e) => return Err(e),
-        }
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        Ok(Value::Table(self.map))
-    }
-}
-
-impl ser::SerializeStruct for SerializeMap {
-    type Ok = Value;
-    type Error = crate::ser::Error;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), crate::ser::Error>
-    where
-        T: ser::Serialize,
-    {
-        ser::SerializeMap::serialize_key(self, key)?;
-        ser::SerializeMap::serialize_value(self, value)
-    }
-
-    fn end(self) -> Result<Value, crate::ser::Error> {
-        ser::SerializeMap::end(self)
-    }
-}
-
-struct DatetimeOrTable<'a> {
-    key: &'a mut String,
-}
-
-impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> {
-    type Value = bool;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        deserializer.deserialize_any(self)
-    }
-}
-
-impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
-    type Value = bool;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str("a string key")
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<bool, E>
-    where
-        E: de::Error,
-    {
-        if s == datetime::FIELD {
-            Ok(true)
-        } else {
-            self.key.push_str(s);
-            Ok(false)
-        }
-    }
-
-    fn visit_string<E>(self, s: String) -> Result<bool, E>
-    where
-        E: de::Error,
-    {
-        if s == datetime::FIELD {
-            Ok(true)
-        } else {
-            *self.key = s;
-            Ok(false)
-        }
-    }
-}
diff --git a/vendor/toml/tests/enum_external_deserialize.rs b/vendor/toml/tests/enum_external_deserialize.rs
deleted file mode 100644
index 6d45b484..00000000
--- a/vendor/toml/tests/enum_external_deserialize.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-extern crate toml;
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct OuterStruct {
-    inner: TheEnum,
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-enum TheEnum {
-    Plain,
-    Tuple(i64, bool),
-    NewType(String),
-    Struct { value: i64 },
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct Val {
-    val: TheEnum,
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct Multi {
-    enums: Vec<TheEnum>,
-}
-
-#[test]
-fn invalid_variant_returns_error_with_good_message_string() {
-    let error = toml::from_str::<TheEnum>("\"NonExistent\"").unwrap_err();
-
-    assert_eq!(
-        error.to_string(),
-        "unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`"
-    );
-}
-
-#[test]
-fn invalid_variant_returns_error_with_good_message_inline_table() {
-    let error = toml::from_str::<TheEnum>("{ NonExistent = {} }").unwrap_err();
-    assert_eq!(
-        error.to_string(),
-        "unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`"
-    );
-}
-
-#[test]
-fn extra_field_returns_expected_empty_table_error() {
-    let error = toml::from_str::<TheEnum>("{ Plain = { extra_field = 404 } }").unwrap_err();
-
-    assert_eq!(error.to_string(), "expected empty table");
-}
-
-#[test]
-fn extra_field_returns_expected_empty_table_error_struct_variant() {
-    let error = toml::from_str::<TheEnum>("{ Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }")
-        .unwrap_err();
-
-    assert_eq!(
-        error.to_string(),
-        r#"unexpected keys in table: `["extra_0", "extra_1"]`, available keys: `["value"]`"#
-    );
-}
-
-mod enum_unit {
-    use super::*;
-
-    #[test]
-    fn from_str() {
-        assert_eq!(TheEnum::Plain, toml::from_str("\"Plain\"").unwrap());
-    }
-
-    #[test]
-    fn from_inline_table() {
-        assert_eq!(TheEnum::Plain, toml::from_str("{ Plain = {} }").unwrap());
-        assert_eq!(
-            Val {
-                val: TheEnum::Plain
-            },
-            toml::from_str("val = { Plain = {} }").unwrap()
-        );
-    }
-
-    #[test]
-    fn from_dotted_table() {
-        assert_eq!(TheEnum::Plain, toml::from_str("[Plain]\n").unwrap());
-    }
-}
-
-mod enum_tuple {
-    use super::*;
-
-    #[test]
-    fn from_inline_table() {
-        assert_eq!(
-            TheEnum::Tuple(-123, true),
-            toml::from_str("{ Tuple = { 0 = -123, 1 = true } }").unwrap()
-        );
-        assert_eq!(
-            Val {
-                val: TheEnum::Tuple(-123, true)
-            },
-            toml::from_str("val = { Tuple = { 0 = -123, 1 = true } }").unwrap()
-        );
-    }
-
-    #[test]
-    fn from_dotted_table() {
-        assert_eq!(
-            TheEnum::Tuple(-123, true),
-            toml::from_str(
-                r#"[Tuple]
-                0 = -123
-                1 = true
-                "#
-            )
-            .unwrap()
-        );
-    }
-}
-
-mod enum_newtype {
-    use super::*;
-
-    #[test]
-    fn from_inline_table() {
-        assert_eq!(
-            TheEnum::NewType("value".to_string()),
-            toml::from_str(r#"{ NewType = "value" }"#).unwrap()
-        );
-        assert_eq!(
-            Val {
-                val: TheEnum::NewType("value".to_string()),
-            },
-            toml::from_str(r#"val = { NewType = "value" }"#).unwrap()
-        );
-    }
-
-    #[test]
-    #[ignore = "Unimplemented: https://github.com/alexcrichton/toml-rs/pull/264#issuecomment-431707209"]
-    fn from_dotted_table() {
-        assert_eq!(
-            TheEnum::NewType("value".to_string()),
-            toml::from_str(r#"NewType = "value""#).unwrap()
-        );
-        assert_eq!(
-            Val {
-                val: TheEnum::NewType("value".to_string()),
-            },
-            toml::from_str(
-                r#"[val]
-                NewType = "value"
-                "#
-            )
-            .unwrap()
-        );
-    }
-}
-
-mod enum_struct {
-    use super::*;
-
-    #[test]
-    fn from_inline_table() {
-        assert_eq!(
-            TheEnum::Struct { value: -123 },
-            toml::from_str("{ Struct = { value = -123 } }").unwrap()
-        );
-        assert_eq!(
-            Val {
-                val: TheEnum::Struct { value: -123 }
-            },
-            toml::from_str("val = { Struct = { value = -123 } }").unwrap()
-        );
-    }
-
-    #[test]
-    fn from_dotted_table() {
-        assert_eq!(
-            TheEnum::Struct { value: -123 },
-            toml::from_str(
-                r#"[Struct]
-                value = -123
-                "#
-            )
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn from_nested_dotted_table() {
-        assert_eq!(
-            OuterStruct {
-                inner: TheEnum::Struct { value: -123 }
-            },
-            toml::from_str(
-                r#"[inner.Struct]
-                value = -123
-                "#
-            )
-            .unwrap()
-        );
-    }
-}
-
-mod enum_array {
-    use super::*;
-
-    #[test]
-    fn from_inline_tables() {
-        let toml_str = r#"
-            enums = [
-                { Plain = {} },
-                { Tuple = { 0 = -123, 1 = true } },
-                { NewType = "value" },
-                { Struct = { value = -123 } }
-            ]"#;
-        assert_eq!(
-            Multi {
-                enums: vec![
-                    TheEnum::Plain,
-                    TheEnum::Tuple(-123, true),
-                    TheEnum::NewType("value".to_string()),
-                    TheEnum::Struct { value: -123 },
-                ]
-            },
-            toml::from_str(toml_str).unwrap()
-        );
-    }
-
-    #[test]
-    #[ignore = "Unimplemented: https://github.com/alexcrichton/toml-rs/pull/264#issuecomment-431707209"]
-    fn from_dotted_table() {
-        let toml_str = r#"[[enums]]
-            Plain = {}
-
-            [[enums]]
-            Tuple = { 0 = -123, 1 = true }
-
-            [[enums]]
-            NewType = "value"
-
-            [[enums]]
-            Struct = { value = -123 }
-            "#;
-        assert_eq!(
-            Multi {
-                enums: vec![
-                    TheEnum::Plain,
-                    TheEnum::Tuple(-123, true),
-                    TheEnum::NewType("value".to_string()),
-                    TheEnum::Struct { value: -123 },
-                ]
-            },
-            toml::from_str(toml_str).unwrap()
-        );
-    }
-}
diff --git a/vendor/unicode-xid/.cargo-checksum.json b/vendor/unicode-xid/.cargo-checksum.json
deleted file mode 100644
index fa8daf47..00000000
--- a/vendor/unicode-xid/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"COPYRIGHT":"23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d","Cargo.toml":"49c1612c2c7e8032afc9ed76331020a1886d11dc9f538400d96efa5359925a2c","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0","README.md":"8fde6fcab0ea13c3abffd8a042f286078a7d88b524dd59db3f26889eb470a5a4","benches/xid.rs":"a2986ce1df5d93bff51e73dc234bffb341d4fe5d749247296f02396dde16a72b","src/lib.rs":"3cdd204115af45e9ece70db737d711e1798eac40eaa6cc4e8280bb3342e1408e","src/tables.rs":"895c4e1199b7987fbf058a4dbd2b1145fa212136d2fc75fd5ac49059192796af","src/tests.rs":"b866f890acd631e667635785c34b1723709f10a9515ca525b41de8a062c7b204","tests/exhaustive_tests.rs":"ec91e9124d61e5b3e2fbbbf37a2fd30d6c7a8fa22639d6720b416d9ebc1007c5"},"package":"8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"}
\ No newline at end of file
diff --git a/vendor/unicode-xid/COPYRIGHT b/vendor/unicode-xid/COPYRIGHT
deleted file mode 100644
index b286ec16..00000000
--- a/vendor/unicode-xid/COPYRIGHT
+++ /dev/null
@@ -1,7 +0,0 @@
-Licensed under the Apache License, Version 2.0
-<LICENSE-APACHE or
-http://www.apache.org/licenses/LICENSE-2.0> or the MIT
-license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
-at your option. All files in the project carrying such
-notice may not be copied, modified, or distributed except
-according to those terms.
diff --git a/vendor/unicode-xid/Cargo.toml b/vendor/unicode-xid/Cargo.toml
deleted file mode 100644
index c80b0aad..00000000
--- a/vendor/unicode-xid/Cargo.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "unicode-xid"
-version = "0.2.2"
-authors = ["erick.tryzelaar <erick.tryzelaar@gmail.com>", "kwantam <kwantam@gmail.com>", "Manish Goregaokar <manishsmail@gmail.com>"]
-exclude = ["/scripts/*", "/.travis.yml"]
-description = "Determine whether characters have the XID_Start\nor XID_Continue properties according to\nUnicode Standard Annex #31.\n"
-homepage = "https://github.com/unicode-rs/unicode-xid"
-documentation = "https://unicode-rs.github.io/unicode-xid"
-readme = "README.md"
-keywords = ["text", "unicode", "xid"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/unicode-rs/unicode-xid"
-
-[[bench]]
-name = "xid"
-harness = false
-[dev-dependencies.criterion]
-version = "0.3"
-
-[features]
-bench = []
-default = []
-no_std = []
-[badges.travis-ci]
-repository = "unicode-rs/unicode-xid"
diff --git a/vendor/unicode-xid/LICENSE-APACHE b/vendor/unicode-xid/LICENSE-APACHE
deleted file mode 100644
index 16fe87b0..00000000
--- a/vendor/unicode-xid/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/unicode-xid/LICENSE-MIT b/vendor/unicode-xid/LICENSE-MIT
deleted file mode 100644
index e69282e3..00000000
--- a/vendor/unicode-xid/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2015 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/unicode-xid/README.md b/vendor/unicode-xid/README.md
deleted file mode 100644
index 5910b40d..00000000
--- a/vendor/unicode-xid/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# unicode-xid
-
-Determine if a `char` is a valid identifier for a parser and/or lexer according to
-[Unicode Standard Annex #31](http://www.unicode.org/reports/tr31/) rules.
-
-[![Build Status](https://travis-ci.org/unicode-rs/unicode-xid.svg)](https://travis-ci.org/unicode-rs/unicode-xid)
-
-[Documentation](https://unicode-rs.github.io/unicode-xid/unicode_xid/index.html)
-
-```rust
-extern crate unicode_xid;
-
-use unicode_xid::UnicodeXID;
-
-fn main() {
-    let ch = 'a';
-    println!("Is {} a valid start of an identifier? {}", ch, UnicodeXID::is_xid_start(ch));
-}
-```
-
-# features
-
-unicode-xid supports a `no_std` feature. This eliminates dependence
-on std, and instead uses equivalent functions from core.
-
-
-# changelog
-
-## 0.2.2
-
-- Add an ASCII fast-path
-
-## 0.2.1
-
-- Update to Unicode 13.0.0
-- Speed up lookup
-
-## 0.2.0
-
-- Update to Unicode 12.1.0.
-
-## 0.1.0
-
-- Initial release.
diff --git a/vendor/unicode-xid/benches/xid.rs b/vendor/unicode-xid/benches/xid.rs
deleted file mode 100644
index a565c36e..00000000
--- a/vendor/unicode-xid/benches/xid.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-extern crate criterion;
-extern crate unicode_xid;
-
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use unicode_xid::UnicodeXID;
-
-fn bench_unicode_xid(c: &mut Criterion) {
-    let unicode_chars = chars(1..0x3000);
-    let ascii_chars = chars(1..0x80);
-
-    let mut group = c.benchmark_group("UnicodeXID");
-    group.throughput(Throughput::Bytes(unicode_chars.len() as u64));
-    group.bench_with_input(
-        BenchmarkId::new("is_xid_start", "unicode"),
-        &unicode_chars,
-        |b, chars| b.iter(|| chars.iter().copied().map(UnicodeXID::is_xid_start).last()),
-    );
-    group.throughput(Throughput::Bytes(ascii_chars.len() as u64));
-    group.bench_with_input(
-        BenchmarkId::new("is_xid_start", "ascii"),
-        &ascii_chars,
-        |b, chars| b.iter(|| chars.iter().copied().map(UnicodeXID::is_xid_start).last()),
-    );
-    group.throughput(Throughput::Bytes(unicode_chars.len() as u64));
-    group.bench_with_input(
-        BenchmarkId::new("is_xid_continue", "unicode"),
-        &unicode_chars,
-        |b, chars| {
-            b.iter(|| {
-                chars
-                    .iter()
-                    .copied()
-                    .map(UnicodeXID::is_xid_continue)
-                    .last()
-            })
-        },
-    );
-    group.throughput(Throughput::Bytes(ascii_chars.len() as u64));
-    group.bench_with_input(
-        BenchmarkId::new("is_xid_continue", "ascii"),
-        &ascii_chars,
-        |b, chars| {
-            b.iter(|| {
-                chars
-                    .iter()
-                    .copied()
-                    .map(UnicodeXID::is_xid_continue)
-                    .last()
-            })
-        },
-    );
-    group.finish();
-}
-
-fn chars(range: std::ops::Range<u32>) -> Vec<char> {
-    range.filter_map(|i| std::char::from_u32(i)).collect()
-}
-
-criterion_group!(benches, bench_unicode_xid);
-criterion_main!(benches);
diff --git a/vendor/unicode-xid/src/lib.rs b/vendor/unicode-xid/src/lib.rs
deleted file mode 100644
index af7015e5..00000000
--- a/vendor/unicode-xid/src/lib.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Determine if a `char` is a valid identifier for a parser and/or lexer according to
-//! [Unicode Standard Annex #31](http://www.unicode.org/reports/tr31/) rules.
-//!
-//! ```rust
-//! extern crate unicode_xid;
-//!
-//! use unicode_xid::UnicodeXID;
-//!
-//! fn main() {
-//!     let ch = 'a';
-//!     println!("Is {} a valid start of an identifier? {}", ch, UnicodeXID::is_xid_start(ch));
-//! }
-//! ```
-//!
-//! # features
-//!
-//! unicode-xid supports a `no_std` feature. This eliminates dependence
-//! on std, and instead uses equivalent functions from core.
-//!
-
-#![forbid(unsafe_code)]
-#![deny(missing_docs)]
-#![doc(
-    html_logo_url = "https://unicode-rs.github.io/unicode-rs_sm.png",
-    html_favicon_url = "https://unicode-rs.github.io/unicode-rs_sm.png"
-)]
-#![no_std]
-#![cfg_attr(feature = "bench", feature(test, unicode_internals))]
-
-#[cfg(test)]
-#[macro_use]
-extern crate std;
-
-#[cfg(feature = "bench")]
-extern crate test;
-
-use tables::derived_property;
-pub use tables::UNICODE_VERSION;
-
-mod tables;
-
-#[cfg(test)]
-mod tests;
-
-/// Methods for determining if a character is a valid identifier character.
-pub trait UnicodeXID {
-    /// Returns whether the specified character satisfies the 'XID_Start'
-    /// Unicode property.
-    ///
-    /// 'XID_Start' is a Unicode Derived Property specified in
-    /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
-    /// mostly similar to ID_Start but modified for closure under NFKx.
-    fn is_xid_start(self) -> bool;
-
-    /// Returns whether the specified `char` satisfies the 'XID_Continue'
-    /// Unicode property.
-    ///
-    /// 'XID_Continue' is a Unicode Derived Property specified in
-    /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
-    /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
-    fn is_xid_continue(self) -> bool;
-}
-
-impl UnicodeXID for char {
-    #[inline]
-    fn is_xid_start(self) -> bool {
-        // Fast-path for ascii idents
-        ('a' <= self && self <= 'z')
-            || ('A' <= self && self <= 'Z')
-            || (self > '\x7f' && derived_property::XID_Start(self))
-    }
-
-    #[inline]
-    fn is_xid_continue(self) -> bool {
-        // Fast-path for ascii idents
-        ('a' <= self && self <= 'z')
-            || ('A' <= self && self <= 'Z')
-            || ('0' <= self && self <= '9')
-            || self == '_'
-            || (self > '\x7f' && derived_property::XID_Continue(self))
-    }
-}
diff --git a/vendor/unicode-xid/src/tables.rs b/vendor/unicode-xid/src/tables.rs
deleted file mode 100644
index b7212a3e..00000000
--- a/vendor/unicode-xid/src/tables.rs
+++ /dev/null
@@ -1,1419 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
-
-#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
-
-/// The version of [Unicode](http://www.unicode.org/)
-/// that this version of unicode-xid is based on.
-pub const UNICODE_VERSION: (u64, u64, u64) = (13, 0, 0);
-
-fn bsearch_range_table(c: char, r: &[(char, char)]) -> bool {
-    use core::cmp::Ordering::{Equal, Greater, Less};
-
-    r.binary_search_by(|&(lo, hi)| {
-        // Because ASCII ranges are at the start of the tables, a search for an
-        // ASCII char will involve more `Greater` results (i.e. the `(lo,hi)`
-        // table entry is greater than `c`) than `Less` results. And given that
-        // ASCII chars are so common, it makes sense to favor them. Therefore,
-        // the `Greater` case is tested for before the `Less` case.
-        if lo > c {
-            Greater
-        } else if hi < c {
-            Less
-        } else {
-            Equal
-        }
-    })
-    .is_ok()
-}
-
-pub mod derived_property {
-    pub const XID_Continue_table: &[(char, char)] = &[
-        ('\u{30}', '\u{39}'),
-        ('\u{41}', '\u{5a}'),
-        ('\u{5f}', '\u{5f}'),
-        ('\u{61}', '\u{7a}'),
-        ('\u{aa}', '\u{aa}'),
-        ('\u{b5}', '\u{b5}'),
-        ('\u{b7}', '\u{b7}'),
-        ('\u{ba}', '\u{ba}'),
-        ('\u{c0}', '\u{d6}'),
-        ('\u{d8}', '\u{f6}'),
-        ('\u{f8}', '\u{2c1}'),
-        ('\u{2c6}', '\u{2d1}'),
-        ('\u{2e0}', '\u{2e4}'),
-        ('\u{2ec}', '\u{2ec}'),
-        ('\u{2ee}', '\u{2ee}'),
-        ('\u{300}', '\u{374}'),
-        ('\u{376}', '\u{377}'),
-        ('\u{37b}', '\u{37d}'),
-        ('\u{37f}', '\u{37f}'),
-        ('\u{386}', '\u{38a}'),
-        ('\u{38c}', '\u{38c}'),
-        ('\u{38e}', '\u{3a1}'),
-        ('\u{3a3}', '\u{3f5}'),
-        ('\u{3f7}', '\u{481}'),
-        ('\u{483}', '\u{487}'),
-        ('\u{48a}', '\u{52f}'),
-        ('\u{531}', '\u{556}'),
-        ('\u{559}', '\u{559}'),
-        ('\u{560}', '\u{588}'),
-        ('\u{591}', '\u{5bd}'),
-        ('\u{5bf}', '\u{5bf}'),
-        ('\u{5c1}', '\u{5c2}'),
-        ('\u{5c4}', '\u{5c5}'),
-        ('\u{5c7}', '\u{5c7}'),
-        ('\u{5d0}', '\u{5ea}'),
-        ('\u{5ef}', '\u{5f2}'),
-        ('\u{610}', '\u{61a}'),
-        ('\u{620}', '\u{669}'),
-        ('\u{66e}', '\u{6d3}'),
-        ('\u{6d5}', '\u{6dc}'),
-        ('\u{6df}', '\u{6e8}'),
-        ('\u{6ea}', '\u{6fc}'),
-        ('\u{6ff}', '\u{6ff}'),
-        ('\u{710}', '\u{74a}'),
-        ('\u{74d}', '\u{7b1}'),
-        ('\u{7c0}', '\u{7f5}'),
-        ('\u{7fa}', '\u{7fa}'),
-        ('\u{7fd}', '\u{7fd}'),
-        ('\u{800}', '\u{82d}'),
-        ('\u{840}', '\u{85b}'),
-        ('\u{860}', '\u{86a}'),
-        ('\u{8a0}', '\u{8b4}'),
-        ('\u{8b6}', '\u{8c7}'),
-        ('\u{8d3}', '\u{8e1}'),
-        ('\u{8e3}', '\u{963}'),
-        ('\u{966}', '\u{96f}'),
-        ('\u{971}', '\u{983}'),
-        ('\u{985}', '\u{98c}'),
-        ('\u{98f}', '\u{990}'),
-        ('\u{993}', '\u{9a8}'),
-        ('\u{9aa}', '\u{9b0}'),
-        ('\u{9b2}', '\u{9b2}'),
-        ('\u{9b6}', '\u{9b9}'),
-        ('\u{9bc}', '\u{9c4}'),
-        ('\u{9c7}', '\u{9c8}'),
-        ('\u{9cb}', '\u{9ce}'),
-        ('\u{9d7}', '\u{9d7}'),
-        ('\u{9dc}', '\u{9dd}'),
-        ('\u{9df}', '\u{9e3}'),
-        ('\u{9e6}', '\u{9f1}'),
-        ('\u{9fc}', '\u{9fc}'),
-        ('\u{9fe}', '\u{9fe}'),
-        ('\u{a01}', '\u{a03}'),
-        ('\u{a05}', '\u{a0a}'),
-        ('\u{a0f}', '\u{a10}'),
-        ('\u{a13}', '\u{a28}'),
-        ('\u{a2a}', '\u{a30}'),
-        ('\u{a32}', '\u{a33}'),
-        ('\u{a35}', '\u{a36}'),
-        ('\u{a38}', '\u{a39}'),
-        ('\u{a3c}', '\u{a3c}'),
-        ('\u{a3e}', '\u{a42}'),
-        ('\u{a47}', '\u{a48}'),
-        ('\u{a4b}', '\u{a4d}'),
-        ('\u{a51}', '\u{a51}'),
-        ('\u{a59}', '\u{a5c}'),
-        ('\u{a5e}', '\u{a5e}'),
-        ('\u{a66}', '\u{a75}'),
-        ('\u{a81}', '\u{a83}'),
-        ('\u{a85}', '\u{a8d}'),
-        ('\u{a8f}', '\u{a91}'),
-        ('\u{a93}', '\u{aa8}'),
-        ('\u{aaa}', '\u{ab0}'),
-        ('\u{ab2}', '\u{ab3}'),
-        ('\u{ab5}', '\u{ab9}'),
-        ('\u{abc}', '\u{ac5}'),
-        ('\u{ac7}', '\u{ac9}'),
-        ('\u{acb}', '\u{acd}'),
-        ('\u{ad0}', '\u{ad0}'),
-        ('\u{ae0}', '\u{ae3}'),
-        ('\u{ae6}', '\u{aef}'),
-        ('\u{af9}', '\u{aff}'),
-        ('\u{b01}', '\u{b03}'),
-        ('\u{b05}', '\u{b0c}'),
-        ('\u{b0f}', '\u{b10}'),
-        ('\u{b13}', '\u{b28}'),
-        ('\u{b2a}', '\u{b30}'),
-        ('\u{b32}', '\u{b33}'),
-        ('\u{b35}', '\u{b39}'),
-        ('\u{b3c}', '\u{b44}'),
-        ('\u{b47}', '\u{b48}'),
-        ('\u{b4b}', '\u{b4d}'),
-        ('\u{b55}', '\u{b57}'),
-        ('\u{b5c}', '\u{b5d}'),
-        ('\u{b5f}', '\u{b63}'),
-        ('\u{b66}', '\u{b6f}'),
-        ('\u{b71}', '\u{b71}'),
-        ('\u{b82}', '\u{b83}'),
-        ('\u{b85}', '\u{b8a}'),
-        ('\u{b8e}', '\u{b90}'),
-        ('\u{b92}', '\u{b95}'),
-        ('\u{b99}', '\u{b9a}'),
-        ('\u{b9c}', '\u{b9c}'),
-        ('\u{b9e}', '\u{b9f}'),
-        ('\u{ba3}', '\u{ba4}'),
-        ('\u{ba8}', '\u{baa}'),
-        ('\u{bae}', '\u{bb9}'),
-        ('\u{bbe}', '\u{bc2}'),
-        ('\u{bc6}', '\u{bc8}'),
-        ('\u{bca}', '\u{bcd}'),
-        ('\u{bd0}', '\u{bd0}'),
-        ('\u{bd7}', '\u{bd7}'),
-        ('\u{be6}', '\u{bef}'),
-        ('\u{c00}', '\u{c0c}'),
-        ('\u{c0e}', '\u{c10}'),
-        ('\u{c12}', '\u{c28}'),
-        ('\u{c2a}', '\u{c39}'),
-        ('\u{c3d}', '\u{c44}'),
-        ('\u{c46}', '\u{c48}'),
-        ('\u{c4a}', '\u{c4d}'),
-        ('\u{c55}', '\u{c56}'),
-        ('\u{c58}', '\u{c5a}'),
-        ('\u{c60}', '\u{c63}'),
-        ('\u{c66}', '\u{c6f}'),
-        ('\u{c80}', '\u{c83}'),
-        ('\u{c85}', '\u{c8c}'),
-        ('\u{c8e}', '\u{c90}'),
-        ('\u{c92}', '\u{ca8}'),
-        ('\u{caa}', '\u{cb3}'),
-        ('\u{cb5}', '\u{cb9}'),
-        ('\u{cbc}', '\u{cc4}'),
-        ('\u{cc6}', '\u{cc8}'),
-        ('\u{cca}', '\u{ccd}'),
-        ('\u{cd5}', '\u{cd6}'),
-        ('\u{cde}', '\u{cde}'),
-        ('\u{ce0}', '\u{ce3}'),
-        ('\u{ce6}', '\u{cef}'),
-        ('\u{cf1}', '\u{cf2}'),
-        ('\u{d00}', '\u{d0c}'),
-        ('\u{d0e}', '\u{d10}'),
-        ('\u{d12}', '\u{d44}'),
-        ('\u{d46}', '\u{d48}'),
-        ('\u{d4a}', '\u{d4e}'),
-        ('\u{d54}', '\u{d57}'),
-        ('\u{d5f}', '\u{d63}'),
-        ('\u{d66}', '\u{d6f}'),
-        ('\u{d7a}', '\u{d7f}'),
-        ('\u{d81}', '\u{d83}'),
-        ('\u{d85}', '\u{d96}'),
-        ('\u{d9a}', '\u{db1}'),
-        ('\u{db3}', '\u{dbb}'),
-        ('\u{dbd}', '\u{dbd}'),
-        ('\u{dc0}', '\u{dc6}'),
-        ('\u{dca}', '\u{dca}'),
-        ('\u{dcf}', '\u{dd4}'),
-        ('\u{dd6}', '\u{dd6}'),
-        ('\u{dd8}', '\u{ddf}'),
-        ('\u{de6}', '\u{def}'),
-        ('\u{df2}', '\u{df3}'),
-        ('\u{e01}', '\u{e3a}'),
-        ('\u{e40}', '\u{e4e}'),
-        ('\u{e50}', '\u{e59}'),
-        ('\u{e81}', '\u{e82}'),
-        ('\u{e84}', '\u{e84}'),
-        ('\u{e86}', '\u{e8a}'),
-        ('\u{e8c}', '\u{ea3}'),
-        ('\u{ea5}', '\u{ea5}'),
-        ('\u{ea7}', '\u{ebd}'),
-        ('\u{ec0}', '\u{ec4}'),
-        ('\u{ec6}', '\u{ec6}'),
-        ('\u{ec8}', '\u{ecd}'),
-        ('\u{ed0}', '\u{ed9}'),
-        ('\u{edc}', '\u{edf}'),
-        ('\u{f00}', '\u{f00}'),
-        ('\u{f18}', '\u{f19}'),
-        ('\u{f20}', '\u{f29}'),
-        ('\u{f35}', '\u{f35}'),
-        ('\u{f37}', '\u{f37}'),
-        ('\u{f39}', '\u{f39}'),
-        ('\u{f3e}', '\u{f47}'),
-        ('\u{f49}', '\u{f6c}'),
-        ('\u{f71}', '\u{f84}'),
-        ('\u{f86}', '\u{f97}'),
-        ('\u{f99}', '\u{fbc}'),
-        ('\u{fc6}', '\u{fc6}'),
-        ('\u{1000}', '\u{1049}'),
-        ('\u{1050}', '\u{109d}'),
-        ('\u{10a0}', '\u{10c5}'),
-        ('\u{10c7}', '\u{10c7}'),
-        ('\u{10cd}', '\u{10cd}'),
-        ('\u{10d0}', '\u{10fa}'),
-        ('\u{10fc}', '\u{1248}'),
-        ('\u{124a}', '\u{124d}'),
-        ('\u{1250}', '\u{1256}'),
-        ('\u{1258}', '\u{1258}'),
-        ('\u{125a}', '\u{125d}'),
-        ('\u{1260}', '\u{1288}'),
-        ('\u{128a}', '\u{128d}'),
-        ('\u{1290}', '\u{12b0}'),
-        ('\u{12b2}', '\u{12b5}'),
-        ('\u{12b8}', '\u{12be}'),
-        ('\u{12c0}', '\u{12c0}'),
-        ('\u{12c2}', '\u{12c5}'),
-        ('\u{12c8}', '\u{12d6}'),
-        ('\u{12d8}', '\u{1310}'),
-        ('\u{1312}', '\u{1315}'),
-        ('\u{1318}', '\u{135a}'),
-        ('\u{135d}', '\u{135f}'),
-        ('\u{1369}', '\u{1371}'),
-        ('\u{1380}', '\u{138f}'),
-        ('\u{13a0}', '\u{13f5}'),
-        ('\u{13f8}', '\u{13fd}'),
-        ('\u{1401}', '\u{166c}'),
-        ('\u{166f}', '\u{167f}'),
-        ('\u{1681}', '\u{169a}'),
-        ('\u{16a0}', '\u{16ea}'),
-        ('\u{16ee}', '\u{16f8}'),
-        ('\u{1700}', '\u{170c}'),
-        ('\u{170e}', '\u{1714}'),
-        ('\u{1720}', '\u{1734}'),
-        ('\u{1740}', '\u{1753}'),
-        ('\u{1760}', '\u{176c}'),
-        ('\u{176e}', '\u{1770}'),
-        ('\u{1772}', '\u{1773}'),
-        ('\u{1780}', '\u{17d3}'),
-        ('\u{17d7}', '\u{17d7}'),
-        ('\u{17dc}', '\u{17dd}'),
-        ('\u{17e0}', '\u{17e9}'),
-        ('\u{180b}', '\u{180d}'),
-        ('\u{1810}', '\u{1819}'),
-        ('\u{1820}', '\u{1878}'),
-        ('\u{1880}', '\u{18aa}'),
-        ('\u{18b0}', '\u{18f5}'),
-        ('\u{1900}', '\u{191e}'),
-        ('\u{1920}', '\u{192b}'),
-        ('\u{1930}', '\u{193b}'),
-        ('\u{1946}', '\u{196d}'),
-        ('\u{1970}', '\u{1974}'),
-        ('\u{1980}', '\u{19ab}'),
-        ('\u{19b0}', '\u{19c9}'),
-        ('\u{19d0}', '\u{19da}'),
-        ('\u{1a00}', '\u{1a1b}'),
-        ('\u{1a20}', '\u{1a5e}'),
-        ('\u{1a60}', '\u{1a7c}'),
-        ('\u{1a7f}', '\u{1a89}'),
-        ('\u{1a90}', '\u{1a99}'),
-        ('\u{1aa7}', '\u{1aa7}'),
-        ('\u{1ab0}', '\u{1abd}'),
-        ('\u{1abf}', '\u{1ac0}'),
-        ('\u{1b00}', '\u{1b4b}'),
-        ('\u{1b50}', '\u{1b59}'),
-        ('\u{1b6b}', '\u{1b73}'),
-        ('\u{1b80}', '\u{1bf3}'),
-        ('\u{1c00}', '\u{1c37}'),
-        ('\u{1c40}', '\u{1c49}'),
-        ('\u{1c4d}', '\u{1c7d}'),
-        ('\u{1c80}', '\u{1c88}'),
-        ('\u{1c90}', '\u{1cba}'),
-        ('\u{1cbd}', '\u{1cbf}'),
-        ('\u{1cd0}', '\u{1cd2}'),
-        ('\u{1cd4}', '\u{1cfa}'),
-        ('\u{1d00}', '\u{1df9}'),
-        ('\u{1dfb}', '\u{1f15}'),
-        ('\u{1f18}', '\u{1f1d}'),
-        ('\u{1f20}', '\u{1f45}'),
-        ('\u{1f48}', '\u{1f4d}'),
-        ('\u{1f50}', '\u{1f57}'),
-        ('\u{1f59}', '\u{1f59}'),
-        ('\u{1f5b}', '\u{1f5b}'),
-        ('\u{1f5d}', '\u{1f5d}'),
-        ('\u{1f5f}', '\u{1f7d}'),
-        ('\u{1f80}', '\u{1fb4}'),
-        ('\u{1fb6}', '\u{1fbc}'),
-        ('\u{1fbe}', '\u{1fbe}'),
-        ('\u{1fc2}', '\u{1fc4}'),
-        ('\u{1fc6}', '\u{1fcc}'),
-        ('\u{1fd0}', '\u{1fd3}'),
-        ('\u{1fd6}', '\u{1fdb}'),
-        ('\u{1fe0}', '\u{1fec}'),
-        ('\u{1ff2}', '\u{1ff4}'),
-        ('\u{1ff6}', '\u{1ffc}'),
-        ('\u{203f}', '\u{2040}'),
-        ('\u{2054}', '\u{2054}'),
-        ('\u{2071}', '\u{2071}'),
-        ('\u{207f}', '\u{207f}'),
-        ('\u{2090}', '\u{209c}'),
-        ('\u{20d0}', '\u{20dc}'),
-        ('\u{20e1}', '\u{20e1}'),
-        ('\u{20e5}', '\u{20f0}'),
-        ('\u{2102}', '\u{2102}'),
-        ('\u{2107}', '\u{2107}'),
-        ('\u{210a}', '\u{2113}'),
-        ('\u{2115}', '\u{2115}'),
-        ('\u{2118}', '\u{211d}'),
-        ('\u{2124}', '\u{2124}'),
-        ('\u{2126}', '\u{2126}'),
-        ('\u{2128}', '\u{2128}'),
-        ('\u{212a}', '\u{2139}'),
-        ('\u{213c}', '\u{213f}'),
-        ('\u{2145}', '\u{2149}'),
-        ('\u{214e}', '\u{214e}'),
-        ('\u{2160}', '\u{2188}'),
-        ('\u{2c00}', '\u{2c2e}'),
-        ('\u{2c30}', '\u{2c5e}'),
-        ('\u{2c60}', '\u{2ce4}'),
-        ('\u{2ceb}', '\u{2cf3}'),
-        ('\u{2d00}', '\u{2d25}'),
-        ('\u{2d27}', '\u{2d27}'),
-        ('\u{2d2d}', '\u{2d2d}'),
-        ('\u{2d30}', '\u{2d67}'),
-        ('\u{2d6f}', '\u{2d6f}'),
-        ('\u{2d7f}', '\u{2d96}'),
-        ('\u{2da0}', '\u{2da6}'),
-        ('\u{2da8}', '\u{2dae}'),
-        ('\u{2db0}', '\u{2db6}'),
-        ('\u{2db8}', '\u{2dbe}'),
-        ('\u{2dc0}', '\u{2dc6}'),
-        ('\u{2dc8}', '\u{2dce}'),
-        ('\u{2dd0}', '\u{2dd6}'),
-        ('\u{2dd8}', '\u{2dde}'),
-        ('\u{2de0}', '\u{2dff}'),
-        ('\u{3005}', '\u{3007}'),
-        ('\u{3021}', '\u{302f}'),
-        ('\u{3031}', '\u{3035}'),
-        ('\u{3038}', '\u{303c}'),
-        ('\u{3041}', '\u{3096}'),
-        ('\u{3099}', '\u{309a}'),
-        ('\u{309d}', '\u{309f}'),
-        ('\u{30a1}', '\u{30fa}'),
-        ('\u{30fc}', '\u{30ff}'),
-        ('\u{3105}', '\u{312f}'),
-        ('\u{3131}', '\u{318e}'),
-        ('\u{31a0}', '\u{31bf}'),
-        ('\u{31f0}', '\u{31ff}'),
-        ('\u{3400}', '\u{4dbf}'),
-        ('\u{4e00}', '\u{9ffc}'),
-        ('\u{a000}', '\u{a48c}'),
-        ('\u{a4d0}', '\u{a4fd}'),
-        ('\u{a500}', '\u{a60c}'),
-        ('\u{a610}', '\u{a62b}'),
-        ('\u{a640}', '\u{a66f}'),
-        ('\u{a674}', '\u{a67d}'),
-        ('\u{a67f}', '\u{a6f1}'),
-        ('\u{a717}', '\u{a71f}'),
-        ('\u{a722}', '\u{a788}'),
-        ('\u{a78b}', '\u{a7bf}'),
-        ('\u{a7c2}', '\u{a7ca}'),
-        ('\u{a7f5}', '\u{a827}'),
-        ('\u{a82c}', '\u{a82c}'),
-        ('\u{a840}', '\u{a873}'),
-        ('\u{a880}', '\u{a8c5}'),
-        ('\u{a8d0}', '\u{a8d9}'),
-        ('\u{a8e0}', '\u{a8f7}'),
-        ('\u{a8fb}', '\u{a8fb}'),
-        ('\u{a8fd}', '\u{a92d}'),
-        ('\u{a930}', '\u{a953}'),
-        ('\u{a960}', '\u{a97c}'),
-        ('\u{a980}', '\u{a9c0}'),
-        ('\u{a9cf}', '\u{a9d9}'),
-        ('\u{a9e0}', '\u{a9fe}'),
-        ('\u{aa00}', '\u{aa36}'),
-        ('\u{aa40}', '\u{aa4d}'),
-        ('\u{aa50}', '\u{aa59}'),
-        ('\u{aa60}', '\u{aa76}'),
-        ('\u{aa7a}', '\u{aac2}'),
-        ('\u{aadb}', '\u{aadd}'),
-        ('\u{aae0}', '\u{aaef}'),
-        ('\u{aaf2}', '\u{aaf6}'),
-        ('\u{ab01}', '\u{ab06}'),
-        ('\u{ab09}', '\u{ab0e}'),
-        ('\u{ab11}', '\u{ab16}'),
-        ('\u{ab20}', '\u{ab26}'),
-        ('\u{ab28}', '\u{ab2e}'),
-        ('\u{ab30}', '\u{ab5a}'),
-        ('\u{ab5c}', '\u{ab69}'),
-        ('\u{ab70}', '\u{abea}'),
-        ('\u{abec}', '\u{abed}'),
-        ('\u{abf0}', '\u{abf9}'),
-        ('\u{ac00}', '\u{d7a3}'),
-        ('\u{d7b0}', '\u{d7c6}'),
-        ('\u{d7cb}', '\u{d7fb}'),
-        ('\u{f900}', '\u{fa6d}'),
-        ('\u{fa70}', '\u{fad9}'),
-        ('\u{fb00}', '\u{fb06}'),
-        ('\u{fb13}', '\u{fb17}'),
-        ('\u{fb1d}', '\u{fb28}'),
-        ('\u{fb2a}', '\u{fb36}'),
-        ('\u{fb38}', '\u{fb3c}'),
-        ('\u{fb3e}', '\u{fb3e}'),
-        ('\u{fb40}', '\u{fb41}'),
-        ('\u{fb43}', '\u{fb44}'),
-        ('\u{fb46}', '\u{fbb1}'),
-        ('\u{fbd3}', '\u{fc5d}'),
-        ('\u{fc64}', '\u{fd3d}'),
-        ('\u{fd50}', '\u{fd8f}'),
-        ('\u{fd92}', '\u{fdc7}'),
-        ('\u{fdf0}', '\u{fdf9}'),
-        ('\u{fe00}', '\u{fe0f}'),
-        ('\u{fe20}', '\u{fe2f}'),
-        ('\u{fe33}', '\u{fe34}'),
-        ('\u{fe4d}', '\u{fe4f}'),
-        ('\u{fe71}', '\u{fe71}'),
-        ('\u{fe73}', '\u{fe73}'),
-        ('\u{fe77}', '\u{fe77}'),
-        ('\u{fe79}', '\u{fe79}'),
-        ('\u{fe7b}', '\u{fe7b}'),
-        ('\u{fe7d}', '\u{fe7d}'),
-        ('\u{fe7f}', '\u{fefc}'),
-        ('\u{ff10}', '\u{ff19}'),
-        ('\u{ff21}', '\u{ff3a}'),
-        ('\u{ff3f}', '\u{ff3f}'),
-        ('\u{ff41}', '\u{ff5a}'),
-        ('\u{ff66}', '\u{ffbe}'),
-        ('\u{ffc2}', '\u{ffc7}'),
-        ('\u{ffca}', '\u{ffcf}'),
-        ('\u{ffd2}', '\u{ffd7}'),
-        ('\u{ffda}', '\u{ffdc}'),
-        ('\u{10000}', '\u{1000b}'),
-        ('\u{1000d}', '\u{10026}'),
-        ('\u{10028}', '\u{1003a}'),
-        ('\u{1003c}', '\u{1003d}'),
-        ('\u{1003f}', '\u{1004d}'),
-        ('\u{10050}', '\u{1005d}'),
-        ('\u{10080}', '\u{100fa}'),
-        ('\u{10140}', '\u{10174}'),
-        ('\u{101fd}', '\u{101fd}'),
-        ('\u{10280}', '\u{1029c}'),
-        ('\u{102a0}', '\u{102d0}'),
-        ('\u{102e0}', '\u{102e0}'),
-        ('\u{10300}', '\u{1031f}'),
-        ('\u{1032d}', '\u{1034a}'),
-        ('\u{10350}', '\u{1037a}'),
-        ('\u{10380}', '\u{1039d}'),
-        ('\u{103a0}', '\u{103c3}'),
-        ('\u{103c8}', '\u{103cf}'),
-        ('\u{103d1}', '\u{103d5}'),
-        ('\u{10400}', '\u{1049d}'),
-        ('\u{104a0}', '\u{104a9}'),
-        ('\u{104b0}', '\u{104d3}'),
-        ('\u{104d8}', '\u{104fb}'),
-        ('\u{10500}', '\u{10527}'),
-        ('\u{10530}', '\u{10563}'),
-        ('\u{10600}', '\u{10736}'),
-        ('\u{10740}', '\u{10755}'),
-        ('\u{10760}', '\u{10767}'),
-        ('\u{10800}', '\u{10805}'),
-        ('\u{10808}', '\u{10808}'),
-        ('\u{1080a}', '\u{10835}'),
-        ('\u{10837}', '\u{10838}'),
-        ('\u{1083c}', '\u{1083c}'),
-        ('\u{1083f}', '\u{10855}'),
-        ('\u{10860}', '\u{10876}'),
-        ('\u{10880}', '\u{1089e}'),
-        ('\u{108e0}', '\u{108f2}'),
-        ('\u{108f4}', '\u{108f5}'),
-        ('\u{10900}', '\u{10915}'),
-        ('\u{10920}', '\u{10939}'),
-        ('\u{10980}', '\u{109b7}'),
-        ('\u{109be}', '\u{109bf}'),
-        ('\u{10a00}', '\u{10a03}'),
-        ('\u{10a05}', '\u{10a06}'),
-        ('\u{10a0c}', '\u{10a13}'),
-        ('\u{10a15}', '\u{10a17}'),
-        ('\u{10a19}', '\u{10a35}'),
-        ('\u{10a38}', '\u{10a3a}'),
-        ('\u{10a3f}', '\u{10a3f}'),
-        ('\u{10a60}', '\u{10a7c}'),
-        ('\u{10a80}', '\u{10a9c}'),
-        ('\u{10ac0}', '\u{10ac7}'),
-        ('\u{10ac9}', '\u{10ae6}'),
-        ('\u{10b00}', '\u{10b35}'),
-        ('\u{10b40}', '\u{10b55}'),
-        ('\u{10b60}', '\u{10b72}'),
-        ('\u{10b80}', '\u{10b91}'),
-        ('\u{10c00}', '\u{10c48}'),
-        ('\u{10c80}', '\u{10cb2}'),
-        ('\u{10cc0}', '\u{10cf2}'),
-        ('\u{10d00}', '\u{10d27}'),
-        ('\u{10d30}', '\u{10d39}'),
-        ('\u{10e80}', '\u{10ea9}'),
-        ('\u{10eab}', '\u{10eac}'),
-        ('\u{10eb0}', '\u{10eb1}'),
-        ('\u{10f00}', '\u{10f1c}'),
-        ('\u{10f27}', '\u{10f27}'),
-        ('\u{10f30}', '\u{10f50}'),
-        ('\u{10fb0}', '\u{10fc4}'),
-        ('\u{10fe0}', '\u{10ff6}'),
-        ('\u{11000}', '\u{11046}'),
-        ('\u{11066}', '\u{1106f}'),
-        ('\u{1107f}', '\u{110ba}'),
-        ('\u{110d0}', '\u{110e8}'),
-        ('\u{110f0}', '\u{110f9}'),
-        ('\u{11100}', '\u{11134}'),
-        ('\u{11136}', '\u{1113f}'),
-        ('\u{11144}', '\u{11147}'),
-        ('\u{11150}', '\u{11173}'),
-        ('\u{11176}', '\u{11176}'),
-        ('\u{11180}', '\u{111c4}'),
-        ('\u{111c9}', '\u{111cc}'),
-        ('\u{111ce}', '\u{111da}'),
-        ('\u{111dc}', '\u{111dc}'),
-        ('\u{11200}', '\u{11211}'),
-        ('\u{11213}', '\u{11237}'),
-        ('\u{1123e}', '\u{1123e}'),
-        ('\u{11280}', '\u{11286}'),
-        ('\u{11288}', '\u{11288}'),
-        ('\u{1128a}', '\u{1128d}'),
-        ('\u{1128f}', '\u{1129d}'),
-        ('\u{1129f}', '\u{112a8}'),
-        ('\u{112b0}', '\u{112ea}'),
-        ('\u{112f0}', '\u{112f9}'),
-        ('\u{11300}', '\u{11303}'),
-        ('\u{11305}', '\u{1130c}'),
-        ('\u{1130f}', '\u{11310}'),
-        ('\u{11313}', '\u{11328}'),
-        ('\u{1132a}', '\u{11330}'),
-        ('\u{11332}', '\u{11333}'),
-        ('\u{11335}', '\u{11339}'),
-        ('\u{1133b}', '\u{11344}'),
-        ('\u{11347}', '\u{11348}'),
-        ('\u{1134b}', '\u{1134d}'),
-        ('\u{11350}', '\u{11350}'),
-        ('\u{11357}', '\u{11357}'),
-        ('\u{1135d}', '\u{11363}'),
-        ('\u{11366}', '\u{1136c}'),
-        ('\u{11370}', '\u{11374}'),
-        ('\u{11400}', '\u{1144a}'),
-        ('\u{11450}', '\u{11459}'),
-        ('\u{1145e}', '\u{11461}'),
-        ('\u{11480}', '\u{114c5}'),
-        ('\u{114c7}', '\u{114c7}'),
-        ('\u{114d0}', '\u{114d9}'),
-        ('\u{11580}', '\u{115b5}'),
-        ('\u{115b8}', '\u{115c0}'),
-        ('\u{115d8}', '\u{115dd}'),
-        ('\u{11600}', '\u{11640}'),
-        ('\u{11644}', '\u{11644}'),
-        ('\u{11650}', '\u{11659}'),
-        ('\u{11680}', '\u{116b8}'),
-        ('\u{116c0}', '\u{116c9}'),
-        ('\u{11700}', '\u{1171a}'),
-        ('\u{1171d}', '\u{1172b}'),
-        ('\u{11730}', '\u{11739}'),
-        ('\u{11800}', '\u{1183a}'),
-        ('\u{118a0}', '\u{118e9}'),
-        ('\u{118ff}', '\u{11906}'),
-        ('\u{11909}', '\u{11909}'),
-        ('\u{1190c}', '\u{11913}'),
-        ('\u{11915}', '\u{11916}'),
-        ('\u{11918}', '\u{11935}'),
-        ('\u{11937}', '\u{11938}'),
-        ('\u{1193b}', '\u{11943}'),
-        ('\u{11950}', '\u{11959}'),
-        ('\u{119a0}', '\u{119a7}'),
-        ('\u{119aa}', '\u{119d7}'),
-        ('\u{119da}', '\u{119e1}'),
-        ('\u{119e3}', '\u{119e4}'),
-        ('\u{11a00}', '\u{11a3e}'),
-        ('\u{11a47}', '\u{11a47}'),
-        ('\u{11a50}', '\u{11a99}'),
-        ('\u{11a9d}', '\u{11a9d}'),
-        ('\u{11ac0}', '\u{11af8}'),
-        ('\u{11c00}', '\u{11c08}'),
-        ('\u{11c0a}', '\u{11c36}'),
-        ('\u{11c38}', '\u{11c40}'),
-        ('\u{11c50}', '\u{11c59}'),
-        ('\u{11c72}', '\u{11c8f}'),
-        ('\u{11c92}', '\u{11ca7}'),
-        ('\u{11ca9}', '\u{11cb6}'),
-        ('\u{11d00}', '\u{11d06}'),
-        ('\u{11d08}', '\u{11d09}'),
-        ('\u{11d0b}', '\u{11d36}'),
-        ('\u{11d3a}', '\u{11d3a}'),
-        ('\u{11d3c}', '\u{11d3d}'),
-        ('\u{11d3f}', '\u{11d47}'),
-        ('\u{11d50}', '\u{11d59}'),
-        ('\u{11d60}', '\u{11d65}'),
-        ('\u{11d67}', '\u{11d68}'),
-        ('\u{11d6a}', '\u{11d8e}'),
-        ('\u{11d90}', '\u{11d91}'),
-        ('\u{11d93}', '\u{11d98}'),
-        ('\u{11da0}', '\u{11da9}'),
-        ('\u{11ee0}', '\u{11ef6}'),
-        ('\u{11fb0}', '\u{11fb0}'),
-        ('\u{12000}', '\u{12399}'),
-        ('\u{12400}', '\u{1246e}'),
-        ('\u{12480}', '\u{12543}'),
-        ('\u{13000}', '\u{1342e}'),
-        ('\u{14400}', '\u{14646}'),
-        ('\u{16800}', '\u{16a38}'),
-        ('\u{16a40}', '\u{16a5e}'),
-        ('\u{16a60}', '\u{16a69}'),
-        ('\u{16ad0}', '\u{16aed}'),
-        ('\u{16af0}', '\u{16af4}'),
-        ('\u{16b00}', '\u{16b36}'),
-        ('\u{16b40}', '\u{16b43}'),
-        ('\u{16b50}', '\u{16b59}'),
-        ('\u{16b63}', '\u{16b77}'),
-        ('\u{16b7d}', '\u{16b8f}'),
-        ('\u{16e40}', '\u{16e7f}'),
-        ('\u{16f00}', '\u{16f4a}'),
-        ('\u{16f4f}', '\u{16f87}'),
-        ('\u{16f8f}', '\u{16f9f}'),
-        ('\u{16fe0}', '\u{16fe1}'),
-        ('\u{16fe3}', '\u{16fe4}'),
-        ('\u{16ff0}', '\u{16ff1}'),
-        ('\u{17000}', '\u{187f7}'),
-        ('\u{18800}', '\u{18cd5}'),
-        ('\u{18d00}', '\u{18d08}'),
-        ('\u{1b000}', '\u{1b11e}'),
-        ('\u{1b150}', '\u{1b152}'),
-        ('\u{1b164}', '\u{1b167}'),
-        ('\u{1b170}', '\u{1b2fb}'),
-        ('\u{1bc00}', '\u{1bc6a}'),
-        ('\u{1bc70}', '\u{1bc7c}'),
-        ('\u{1bc80}', '\u{1bc88}'),
-        ('\u{1bc90}', '\u{1bc99}'),
-        ('\u{1bc9d}', '\u{1bc9e}'),
-        ('\u{1d165}', '\u{1d169}'),
-        ('\u{1d16d}', '\u{1d172}'),
-        ('\u{1d17b}', '\u{1d182}'),
-        ('\u{1d185}', '\u{1d18b}'),
-        ('\u{1d1aa}', '\u{1d1ad}'),
-        ('\u{1d242}', '\u{1d244}'),
-        ('\u{1d400}', '\u{1d454}'),
-        ('\u{1d456}', '\u{1d49c}'),
-        ('\u{1d49e}', '\u{1d49f}'),
-        ('\u{1d4a2}', '\u{1d4a2}'),
-        ('\u{1d4a5}', '\u{1d4a6}'),
-        ('\u{1d4a9}', '\u{1d4ac}'),
-        ('\u{1d4ae}', '\u{1d4b9}'),
-        ('\u{1d4bb}', '\u{1d4bb}'),
-        ('\u{1d4bd}', '\u{1d4c3}'),
-        ('\u{1d4c5}', '\u{1d505}'),
-        ('\u{1d507}', '\u{1d50a}'),
-        ('\u{1d50d}', '\u{1d514}'),
-        ('\u{1d516}', '\u{1d51c}'),
-        ('\u{1d51e}', '\u{1d539}'),
-        ('\u{1d53b}', '\u{1d53e}'),
-        ('\u{1d540}', '\u{1d544}'),
-        ('\u{1d546}', '\u{1d546}'),
-        ('\u{1d54a}', '\u{1d550}'),
-        ('\u{1d552}', '\u{1d6a5}'),
-        ('\u{1d6a8}', '\u{1d6c0}'),
-        ('\u{1d6c2}', '\u{1d6da}'),
-        ('\u{1d6dc}', '\u{1d6fa}'),
-        ('\u{1d6fc}', '\u{1d714}'),
-        ('\u{1d716}', '\u{1d734}'),
-        ('\u{1d736}', '\u{1d74e}'),
-        ('\u{1d750}', '\u{1d76e}'),
-        ('\u{1d770}', '\u{1d788}'),
-        ('\u{1d78a}', '\u{1d7a8}'),
-        ('\u{1d7aa}', '\u{1d7c2}'),
-        ('\u{1d7c4}', '\u{1d7cb}'),
-        ('\u{1d7ce}', '\u{1d7ff}'),
-        ('\u{1da00}', '\u{1da36}'),
-        ('\u{1da3b}', '\u{1da6c}'),
-        ('\u{1da75}', '\u{1da75}'),
-        ('\u{1da84}', '\u{1da84}'),
-        ('\u{1da9b}', '\u{1da9f}'),
-        ('\u{1daa1}', '\u{1daaf}'),
-        ('\u{1e000}', '\u{1e006}'),
-        ('\u{1e008}', '\u{1e018}'),
-        ('\u{1e01b}', '\u{1e021}'),
-        ('\u{1e023}', '\u{1e024}'),
-        ('\u{1e026}', '\u{1e02a}'),
-        ('\u{1e100}', '\u{1e12c}'),
-        ('\u{1e130}', '\u{1e13d}'),
-        ('\u{1e140}', '\u{1e149}'),
-        ('\u{1e14e}', '\u{1e14e}'),
-        ('\u{1e2c0}', '\u{1e2f9}'),
-        ('\u{1e800}', '\u{1e8c4}'),
-        ('\u{1e8d0}', '\u{1e8d6}'),
-        ('\u{1e900}', '\u{1e94b}'),
-        ('\u{1e950}', '\u{1e959}'),
-        ('\u{1ee00}', '\u{1ee03}'),
-        ('\u{1ee05}', '\u{1ee1f}'),
-        ('\u{1ee21}', '\u{1ee22}'),
-        ('\u{1ee24}', '\u{1ee24}'),
-        ('\u{1ee27}', '\u{1ee27}'),
-        ('\u{1ee29}', '\u{1ee32}'),
-        ('\u{1ee34}', '\u{1ee37}'),
-        ('\u{1ee39}', '\u{1ee39}'),
-        ('\u{1ee3b}', '\u{1ee3b}'),
-        ('\u{1ee42}', '\u{1ee42}'),
-        ('\u{1ee47}', '\u{1ee47}'),
-        ('\u{1ee49}', '\u{1ee49}'),
-        ('\u{1ee4b}', '\u{1ee4b}'),
-        ('\u{1ee4d}', '\u{1ee4f}'),
-        ('\u{1ee51}', '\u{1ee52}'),
-        ('\u{1ee54}', '\u{1ee54}'),
-        ('\u{1ee57}', '\u{1ee57}'),
-        ('\u{1ee59}', '\u{1ee59}'),
-        ('\u{1ee5b}', '\u{1ee5b}'),
-        ('\u{1ee5d}', '\u{1ee5d}'),
-        ('\u{1ee5f}', '\u{1ee5f}'),
-        ('\u{1ee61}', '\u{1ee62}'),
-        ('\u{1ee64}', '\u{1ee64}'),
-        ('\u{1ee67}', '\u{1ee6a}'),
-        ('\u{1ee6c}', '\u{1ee72}'),
-        ('\u{1ee74}', '\u{1ee77}'),
-        ('\u{1ee79}', '\u{1ee7c}'),
-        ('\u{1ee7e}', '\u{1ee7e}'),
-        ('\u{1ee80}', '\u{1ee89}'),
-        ('\u{1ee8b}', '\u{1ee9b}'),
-        ('\u{1eea1}', '\u{1eea3}'),
-        ('\u{1eea5}', '\u{1eea9}'),
-        ('\u{1eeab}', '\u{1eebb}'),
-        ('\u{1fbf0}', '\u{1fbf9}'),
-        ('\u{20000}', '\u{2a6dd}'),
-        ('\u{2a700}', '\u{2b734}'),
-        ('\u{2b740}', '\u{2b81d}'),
-        ('\u{2b820}', '\u{2cea1}'),
-        ('\u{2ceb0}', '\u{2ebe0}'),
-        ('\u{2f800}', '\u{2fa1d}'),
-        ('\u{30000}', '\u{3134a}'),
-        ('\u{e0100}', '\u{e01ef}'),
-    ];
-
-    pub fn XID_Continue(c: char) -> bool {
-        super::bsearch_range_table(c, XID_Continue_table)
-    }
-
-    pub const XID_Start_table: &[(char, char)] = &[
-        ('\u{41}', '\u{5a}'),
-        ('\u{61}', '\u{7a}'),
-        ('\u{aa}', '\u{aa}'),
-        ('\u{b5}', '\u{b5}'),
-        ('\u{ba}', '\u{ba}'),
-        ('\u{c0}', '\u{d6}'),
-        ('\u{d8}', '\u{f6}'),
-        ('\u{f8}', '\u{2c1}'),
-        ('\u{2c6}', '\u{2d1}'),
-        ('\u{2e0}', '\u{2e4}'),
-        ('\u{2ec}', '\u{2ec}'),
-        ('\u{2ee}', '\u{2ee}'),
-        ('\u{370}', '\u{374}'),
-        ('\u{376}', '\u{377}'),
-        ('\u{37b}', '\u{37d}'),
-        ('\u{37f}', '\u{37f}'),
-        ('\u{386}', '\u{386}'),
-        ('\u{388}', '\u{38a}'),
-        ('\u{38c}', '\u{38c}'),
-        ('\u{38e}', '\u{3a1}'),
-        ('\u{3a3}', '\u{3f5}'),
-        ('\u{3f7}', '\u{481}'),
-        ('\u{48a}', '\u{52f}'),
-        ('\u{531}', '\u{556}'),
-        ('\u{559}', '\u{559}'),
-        ('\u{560}', '\u{588}'),
-        ('\u{5d0}', '\u{5ea}'),
-        ('\u{5ef}', '\u{5f2}'),
-        ('\u{620}', '\u{64a}'),
-        ('\u{66e}', '\u{66f}'),
-        ('\u{671}', '\u{6d3}'),
-        ('\u{6d5}', '\u{6d5}'),
-        ('\u{6e5}', '\u{6e6}'),
-        ('\u{6ee}', '\u{6ef}'),
-        ('\u{6fa}', '\u{6fc}'),
-        ('\u{6ff}', '\u{6ff}'),
-        ('\u{710}', '\u{710}'),
-        ('\u{712}', '\u{72f}'),
-        ('\u{74d}', '\u{7a5}'),
-        ('\u{7b1}', '\u{7b1}'),
-        ('\u{7ca}', '\u{7ea}'),
-        ('\u{7f4}', '\u{7f5}'),
-        ('\u{7fa}', '\u{7fa}'),
-        ('\u{800}', '\u{815}'),
-        ('\u{81a}', '\u{81a}'),
-        ('\u{824}', '\u{824}'),
-        ('\u{828}', '\u{828}'),
-        ('\u{840}', '\u{858}'),
-        ('\u{860}', '\u{86a}'),
-        ('\u{8a0}', '\u{8b4}'),
-        ('\u{8b6}', '\u{8c7}'),
-        ('\u{904}', '\u{939}'),
-        ('\u{93d}', '\u{93d}'),
-        ('\u{950}', '\u{950}'),
-        ('\u{958}', '\u{961}'),
-        ('\u{971}', '\u{980}'),
-        ('\u{985}', '\u{98c}'),
-        ('\u{98f}', '\u{990}'),
-        ('\u{993}', '\u{9a8}'),
-        ('\u{9aa}', '\u{9b0}'),
-        ('\u{9b2}', '\u{9b2}'),
-        ('\u{9b6}', '\u{9b9}'),
-        ('\u{9bd}', '\u{9bd}'),
-        ('\u{9ce}', '\u{9ce}'),
-        ('\u{9dc}', '\u{9dd}'),
-        ('\u{9df}', '\u{9e1}'),
-        ('\u{9f0}', '\u{9f1}'),
-        ('\u{9fc}', '\u{9fc}'),
-        ('\u{a05}', '\u{a0a}'),
-        ('\u{a0f}', '\u{a10}'),
-        ('\u{a13}', '\u{a28}'),
-        ('\u{a2a}', '\u{a30}'),
-        ('\u{a32}', '\u{a33}'),
-        ('\u{a35}', '\u{a36}'),
-        ('\u{a38}', '\u{a39}'),
-        ('\u{a59}', '\u{a5c}'),
-        ('\u{a5e}', '\u{a5e}'),
-        ('\u{a72}', '\u{a74}'),
-        ('\u{a85}', '\u{a8d}'),
-        ('\u{a8f}', '\u{a91}'),
-        ('\u{a93}', '\u{aa8}'),
-        ('\u{aaa}', '\u{ab0}'),
-        ('\u{ab2}', '\u{ab3}'),
-        ('\u{ab5}', '\u{ab9}'),
-        ('\u{abd}', '\u{abd}'),
-        ('\u{ad0}', '\u{ad0}'),
-        ('\u{ae0}', '\u{ae1}'),
-        ('\u{af9}', '\u{af9}'),
-        ('\u{b05}', '\u{b0c}'),
-        ('\u{b0f}', '\u{b10}'),
-        ('\u{b13}', '\u{b28}'),
-        ('\u{b2a}', '\u{b30}'),
-        ('\u{b32}', '\u{b33}'),
-        ('\u{b35}', '\u{b39}'),
-        ('\u{b3d}', '\u{b3d}'),
-        ('\u{b5c}', '\u{b5d}'),
-        ('\u{b5f}', '\u{b61}'),
-        ('\u{b71}', '\u{b71}'),
-        ('\u{b83}', '\u{b83}'),
-        ('\u{b85}', '\u{b8a}'),
-        ('\u{b8e}', '\u{b90}'),
-        ('\u{b92}', '\u{b95}'),
-        ('\u{b99}', '\u{b9a}'),
-        ('\u{b9c}', '\u{b9c}'),
-        ('\u{b9e}', '\u{b9f}'),
-        ('\u{ba3}', '\u{ba4}'),
-        ('\u{ba8}', '\u{baa}'),
-        ('\u{bae}', '\u{bb9}'),
-        ('\u{bd0}', '\u{bd0}'),
-        ('\u{c05}', '\u{c0c}'),
-        ('\u{c0e}', '\u{c10}'),
-        ('\u{c12}', '\u{c28}'),
-        ('\u{c2a}', '\u{c39}'),
-        ('\u{c3d}', '\u{c3d}'),
-        ('\u{c58}', '\u{c5a}'),
-        ('\u{c60}', '\u{c61}'),
-        ('\u{c80}', '\u{c80}'),
-        ('\u{c85}', '\u{c8c}'),
-        ('\u{c8e}', '\u{c90}'),
-        ('\u{c92}', '\u{ca8}'),
-        ('\u{caa}', '\u{cb3}'),
-        ('\u{cb5}', '\u{cb9}'),
-        ('\u{cbd}', '\u{cbd}'),
-        ('\u{cde}', '\u{cde}'),
-        ('\u{ce0}', '\u{ce1}'),
-        ('\u{cf1}', '\u{cf2}'),
-        ('\u{d04}', '\u{d0c}'),
-        ('\u{d0e}', '\u{d10}'),
-        ('\u{d12}', '\u{d3a}'),
-        ('\u{d3d}', '\u{d3d}'),
-        ('\u{d4e}', '\u{d4e}'),
-        ('\u{d54}', '\u{d56}'),
-        ('\u{d5f}', '\u{d61}'),
-        ('\u{d7a}', '\u{d7f}'),
-        ('\u{d85}', '\u{d96}'),
-        ('\u{d9a}', '\u{db1}'),
-        ('\u{db3}', '\u{dbb}'),
-        ('\u{dbd}', '\u{dbd}'),
-        ('\u{dc0}', '\u{dc6}'),
-        ('\u{e01}', '\u{e30}'),
-        ('\u{e32}', '\u{e32}'),
-        ('\u{e40}', '\u{e46}'),
-        ('\u{e81}', '\u{e82}'),
-        ('\u{e84}', '\u{e84}'),
-        ('\u{e86}', '\u{e8a}'),
-        ('\u{e8c}', '\u{ea3}'),
-        ('\u{ea5}', '\u{ea5}'),
-        ('\u{ea7}', '\u{eb0}'),
-        ('\u{eb2}', '\u{eb2}'),
-        ('\u{ebd}', '\u{ebd}'),
-        ('\u{ec0}', '\u{ec4}'),
-        ('\u{ec6}', '\u{ec6}'),
-        ('\u{edc}', '\u{edf}'),
-        ('\u{f00}', '\u{f00}'),
-        ('\u{f40}', '\u{f47}'),
-        ('\u{f49}', '\u{f6c}'),
-        ('\u{f88}', '\u{f8c}'),
-        ('\u{1000}', '\u{102a}'),
-        ('\u{103f}', '\u{103f}'),
-        ('\u{1050}', '\u{1055}'),
-        ('\u{105a}', '\u{105d}'),
-        ('\u{1061}', '\u{1061}'),
-        ('\u{1065}', '\u{1066}'),
-        ('\u{106e}', '\u{1070}'),
-        ('\u{1075}', '\u{1081}'),
-        ('\u{108e}', '\u{108e}'),
-        ('\u{10a0}', '\u{10c5}'),
-        ('\u{10c7}', '\u{10c7}'),
-        ('\u{10cd}', '\u{10cd}'),
-        ('\u{10d0}', '\u{10fa}'),
-        ('\u{10fc}', '\u{1248}'),
-        ('\u{124a}', '\u{124d}'),
-        ('\u{1250}', '\u{1256}'),
-        ('\u{1258}', '\u{1258}'),
-        ('\u{125a}', '\u{125d}'),
-        ('\u{1260}', '\u{1288}'),
-        ('\u{128a}', '\u{128d}'),
-        ('\u{1290}', '\u{12b0}'),
-        ('\u{12b2}', '\u{12b5}'),
-        ('\u{12b8}', '\u{12be}'),
-        ('\u{12c0}', '\u{12c0}'),
-        ('\u{12c2}', '\u{12c5}'),
-        ('\u{12c8}', '\u{12d6}'),
-        ('\u{12d8}', '\u{1310}'),
-        ('\u{1312}', '\u{1315}'),
-        ('\u{1318}', '\u{135a}'),
-        ('\u{1380}', '\u{138f}'),
-        ('\u{13a0}', '\u{13f5}'),
-        ('\u{13f8}', '\u{13fd}'),
-        ('\u{1401}', '\u{166c}'),
-        ('\u{166f}', '\u{167f}'),
-        ('\u{1681}', '\u{169a}'),
-        ('\u{16a0}', '\u{16ea}'),
-        ('\u{16ee}', '\u{16f8}'),
-        ('\u{1700}', '\u{170c}'),
-        ('\u{170e}', '\u{1711}'),
-        ('\u{1720}', '\u{1731}'),
-        ('\u{1740}', '\u{1751}'),
-        ('\u{1760}', '\u{176c}'),
-        ('\u{176e}', '\u{1770}'),
-        ('\u{1780}', '\u{17b3}'),
-        ('\u{17d7}', '\u{17d7}'),
-        ('\u{17dc}', '\u{17dc}'),
-        ('\u{1820}', '\u{1878}'),
-        ('\u{1880}', '\u{18a8}'),
-        ('\u{18aa}', '\u{18aa}'),
-        ('\u{18b0}', '\u{18f5}'),
-        ('\u{1900}', '\u{191e}'),
-        ('\u{1950}', '\u{196d}'),
-        ('\u{1970}', '\u{1974}'),
-        ('\u{1980}', '\u{19ab}'),
-        ('\u{19b0}', '\u{19c9}'),
-        ('\u{1a00}', '\u{1a16}'),
-        ('\u{1a20}', '\u{1a54}'),
-        ('\u{1aa7}', '\u{1aa7}'),
-        ('\u{1b05}', '\u{1b33}'),
-        ('\u{1b45}', '\u{1b4b}'),
-        ('\u{1b83}', '\u{1ba0}'),
-        ('\u{1bae}', '\u{1baf}'),
-        ('\u{1bba}', '\u{1be5}'),
-        ('\u{1c00}', '\u{1c23}'),
-        ('\u{1c4d}', '\u{1c4f}'),
-        ('\u{1c5a}', '\u{1c7d}'),
-        ('\u{1c80}', '\u{1c88}'),
-        ('\u{1c90}', '\u{1cba}'),
-        ('\u{1cbd}', '\u{1cbf}'),
-        ('\u{1ce9}', '\u{1cec}'),
-        ('\u{1cee}', '\u{1cf3}'),
-        ('\u{1cf5}', '\u{1cf6}'),
-        ('\u{1cfa}', '\u{1cfa}'),
-        ('\u{1d00}', '\u{1dbf}'),
-        ('\u{1e00}', '\u{1f15}'),
-        ('\u{1f18}', '\u{1f1d}'),
-        ('\u{1f20}', '\u{1f45}'),
-        ('\u{1f48}', '\u{1f4d}'),
-        ('\u{1f50}', '\u{1f57}'),
-        ('\u{1f59}', '\u{1f59}'),
-        ('\u{1f5b}', '\u{1f5b}'),
-        ('\u{1f5d}', '\u{1f5d}'),
-        ('\u{1f5f}', '\u{1f7d}'),
-        ('\u{1f80}', '\u{1fb4}'),
-        ('\u{1fb6}', '\u{1fbc}'),
-        ('\u{1fbe}', '\u{1fbe}'),
-        ('\u{1fc2}', '\u{1fc4}'),
-        ('\u{1fc6}', '\u{1fcc}'),
-        ('\u{1fd0}', '\u{1fd3}'),
-        ('\u{1fd6}', '\u{1fdb}'),
-        ('\u{1fe0}', '\u{1fec}'),
-        ('\u{1ff2}', '\u{1ff4}'),
-        ('\u{1ff6}', '\u{1ffc}'),
-        ('\u{2071}', '\u{2071}'),
-        ('\u{207f}', '\u{207f}'),
-        ('\u{2090}', '\u{209c}'),
-        ('\u{2102}', '\u{2102}'),
-        ('\u{2107}', '\u{2107}'),
-        ('\u{210a}', '\u{2113}'),
-        ('\u{2115}', '\u{2115}'),
-        ('\u{2118}', '\u{211d}'),
-        ('\u{2124}', '\u{2124}'),
-        ('\u{2126}', '\u{2126}'),
-        ('\u{2128}', '\u{2128}'),
-        ('\u{212a}', '\u{2139}'),
-        ('\u{213c}', '\u{213f}'),
-        ('\u{2145}', '\u{2149}'),
-        ('\u{214e}', '\u{214e}'),
-        ('\u{2160}', '\u{2188}'),
-        ('\u{2c00}', '\u{2c2e}'),
-        ('\u{2c30}', '\u{2c5e}'),
-        ('\u{2c60}', '\u{2ce4}'),
-        ('\u{2ceb}', '\u{2cee}'),
-        ('\u{2cf2}', '\u{2cf3}'),
-        ('\u{2d00}', '\u{2d25}'),
-        ('\u{2d27}', '\u{2d27}'),
-        ('\u{2d2d}', '\u{2d2d}'),
-        ('\u{2d30}', '\u{2d67}'),
-        ('\u{2d6f}', '\u{2d6f}'),
-        ('\u{2d80}', '\u{2d96}'),
-        ('\u{2da0}', '\u{2da6}'),
-        ('\u{2da8}', '\u{2dae}'),
-        ('\u{2db0}', '\u{2db6}'),
-        ('\u{2db8}', '\u{2dbe}'),
-        ('\u{2dc0}', '\u{2dc6}'),
-        ('\u{2dc8}', '\u{2dce}'),
-        ('\u{2dd0}', '\u{2dd6}'),
-        ('\u{2dd8}', '\u{2dde}'),
-        ('\u{3005}', '\u{3007}'),
-        ('\u{3021}', '\u{3029}'),
-        ('\u{3031}', '\u{3035}'),
-        ('\u{3038}', '\u{303c}'),
-        ('\u{3041}', '\u{3096}'),
-        ('\u{309d}', '\u{309f}'),
-        ('\u{30a1}', '\u{30fa}'),
-        ('\u{30fc}', '\u{30ff}'),
-        ('\u{3105}', '\u{312f}'),
-        ('\u{3131}', '\u{318e}'),
-        ('\u{31a0}', '\u{31bf}'),
-        ('\u{31f0}', '\u{31ff}'),
-        ('\u{3400}', '\u{4dbf}'),
-        ('\u{4e00}', '\u{9ffc}'),
-        ('\u{a000}', '\u{a48c}'),
-        ('\u{a4d0}', '\u{a4fd}'),
-        ('\u{a500}', '\u{a60c}'),
-        ('\u{a610}', '\u{a61f}'),
-        ('\u{a62a}', '\u{a62b}'),
-        ('\u{a640}', '\u{a66e}'),
-        ('\u{a67f}', '\u{a69d}'),
-        ('\u{a6a0}', '\u{a6ef}'),
-        ('\u{a717}', '\u{a71f}'),
-        ('\u{a722}', '\u{a788}'),
-        ('\u{a78b}', '\u{a7bf}'),
-        ('\u{a7c2}', '\u{a7ca}'),
-        ('\u{a7f5}', '\u{a801}'),
-        ('\u{a803}', '\u{a805}'),
-        ('\u{a807}', '\u{a80a}'),
-        ('\u{a80c}', '\u{a822}'),
-        ('\u{a840}', '\u{a873}'),
-        ('\u{a882}', '\u{a8b3}'),
-        ('\u{a8f2}', '\u{a8f7}'),
-        ('\u{a8fb}', '\u{a8fb}'),
-        ('\u{a8fd}', '\u{a8fe}'),
-        ('\u{a90a}', '\u{a925}'),
-        ('\u{a930}', '\u{a946}'),
-        ('\u{a960}', '\u{a97c}'),
-        ('\u{a984}', '\u{a9b2}'),
-        ('\u{a9cf}', '\u{a9cf}'),
-        ('\u{a9e0}', '\u{a9e4}'),
-        ('\u{a9e6}', '\u{a9ef}'),
-        ('\u{a9fa}', '\u{a9fe}'),
-        ('\u{aa00}', '\u{aa28}'),
-        ('\u{aa40}', '\u{aa42}'),
-        ('\u{aa44}', '\u{aa4b}'),
-        ('\u{aa60}', '\u{aa76}'),
-        ('\u{aa7a}', '\u{aa7a}'),
-        ('\u{aa7e}', '\u{aaaf}'),
-        ('\u{aab1}', '\u{aab1}'),
-        ('\u{aab5}', '\u{aab6}'),
-        ('\u{aab9}', '\u{aabd}'),
-        ('\u{aac0}', '\u{aac0}'),
-        ('\u{aac2}', '\u{aac2}'),
-        ('\u{aadb}', '\u{aadd}'),
-        ('\u{aae0}', '\u{aaea}'),
-        ('\u{aaf2}', '\u{aaf4}'),
-        ('\u{ab01}', '\u{ab06}'),
-        ('\u{ab09}', '\u{ab0e}'),
-        ('\u{ab11}', '\u{ab16}'),
-        ('\u{ab20}', '\u{ab26}'),
-        ('\u{ab28}', '\u{ab2e}'),
-        ('\u{ab30}', '\u{ab5a}'),
-        ('\u{ab5c}', '\u{ab69}'),
-        ('\u{ab70}', '\u{abe2}'),
-        ('\u{ac00}', '\u{d7a3}'),
-        ('\u{d7b0}', '\u{d7c6}'),
-        ('\u{d7cb}', '\u{d7fb}'),
-        ('\u{f900}', '\u{fa6d}'),
-        ('\u{fa70}', '\u{fad9}'),
-        ('\u{fb00}', '\u{fb06}'),
-        ('\u{fb13}', '\u{fb17}'),
-        ('\u{fb1d}', '\u{fb1d}'),
-        ('\u{fb1f}', '\u{fb28}'),
-        ('\u{fb2a}', '\u{fb36}'),
-        ('\u{fb38}', '\u{fb3c}'),
-        ('\u{fb3e}', '\u{fb3e}'),
-        ('\u{fb40}', '\u{fb41}'),
-        ('\u{fb43}', '\u{fb44}'),
-        ('\u{fb46}', '\u{fbb1}'),
-        ('\u{fbd3}', '\u{fc5d}'),
-        ('\u{fc64}', '\u{fd3d}'),
-        ('\u{fd50}', '\u{fd8f}'),
-        ('\u{fd92}', '\u{fdc7}'),
-        ('\u{fdf0}', '\u{fdf9}'),
-        ('\u{fe71}', '\u{fe71}'),
-        ('\u{fe73}', '\u{fe73}'),
-        ('\u{fe77}', '\u{fe77}'),
-        ('\u{fe79}', '\u{fe79}'),
-        ('\u{fe7b}', '\u{fe7b}'),
-        ('\u{fe7d}', '\u{fe7d}'),
-        ('\u{fe7f}', '\u{fefc}'),
-        ('\u{ff21}', '\u{ff3a}'),
-        ('\u{ff41}', '\u{ff5a}'),
-        ('\u{ff66}', '\u{ff9d}'),
-        ('\u{ffa0}', '\u{ffbe}'),
-        ('\u{ffc2}', '\u{ffc7}'),
-        ('\u{ffca}', '\u{ffcf}'),
-        ('\u{ffd2}', '\u{ffd7}'),
-        ('\u{ffda}', '\u{ffdc}'),
-        ('\u{10000}', '\u{1000b}'),
-        ('\u{1000d}', '\u{10026}'),
-        ('\u{10028}', '\u{1003a}'),
-        ('\u{1003c}', '\u{1003d}'),
-        ('\u{1003f}', '\u{1004d}'),
-        ('\u{10050}', '\u{1005d}'),
-        ('\u{10080}', '\u{100fa}'),
-        ('\u{10140}', '\u{10174}'),
-        ('\u{10280}', '\u{1029c}'),
-        ('\u{102a0}', '\u{102d0}'),
-        ('\u{10300}', '\u{1031f}'),
-        ('\u{1032d}', '\u{1034a}'),
-        ('\u{10350}', '\u{10375}'),
-        ('\u{10380}', '\u{1039d}'),
-        ('\u{103a0}', '\u{103c3}'),
-        ('\u{103c8}', '\u{103cf}'),
-        ('\u{103d1}', '\u{103d5}'),
-        ('\u{10400}', '\u{1049d}'),
-        ('\u{104b0}', '\u{104d3}'),
-        ('\u{104d8}', '\u{104fb}'),
-        ('\u{10500}', '\u{10527}'),
-        ('\u{10530}', '\u{10563}'),
-        ('\u{10600}', '\u{10736}'),
-        ('\u{10740}', '\u{10755}'),
-        ('\u{10760}', '\u{10767}'),
-        ('\u{10800}', '\u{10805}'),
-        ('\u{10808}', '\u{10808}'),
-        ('\u{1080a}', '\u{10835}'),
-        ('\u{10837}', '\u{10838}'),
-        ('\u{1083c}', '\u{1083c}'),
-        ('\u{1083f}', '\u{10855}'),
-        ('\u{10860}', '\u{10876}'),
-        ('\u{10880}', '\u{1089e}'),
-        ('\u{108e0}', '\u{108f2}'),
-        ('\u{108f4}', '\u{108f5}'),
-        ('\u{10900}', '\u{10915}'),
-        ('\u{10920}', '\u{10939}'),
-        ('\u{10980}', '\u{109b7}'),
-        ('\u{109be}', '\u{109bf}'),
-        ('\u{10a00}', '\u{10a00}'),
-        ('\u{10a10}', '\u{10a13}'),
-        ('\u{10a15}', '\u{10a17}'),
-        ('\u{10a19}', '\u{10a35}'),
-        ('\u{10a60}', '\u{10a7c}'),
-        ('\u{10a80}', '\u{10a9c}'),
-        ('\u{10ac0}', '\u{10ac7}'),
-        ('\u{10ac9}', '\u{10ae4}'),
-        ('\u{10b00}', '\u{10b35}'),
-        ('\u{10b40}', '\u{10b55}'),
-        ('\u{10b60}', '\u{10b72}'),
-        ('\u{10b80}', '\u{10b91}'),
-        ('\u{10c00}', '\u{10c48}'),
-        ('\u{10c80}', '\u{10cb2}'),
-        ('\u{10cc0}', '\u{10cf2}'),
-        ('\u{10d00}', '\u{10d23}'),
-        ('\u{10e80}', '\u{10ea9}'),
-        ('\u{10eb0}', '\u{10eb1}'),
-        ('\u{10f00}', '\u{10f1c}'),
-        ('\u{10f27}', '\u{10f27}'),
-        ('\u{10f30}', '\u{10f45}'),
-        ('\u{10fb0}', '\u{10fc4}'),
-        ('\u{10fe0}', '\u{10ff6}'),
-        ('\u{11003}', '\u{11037}'),
-        ('\u{11083}', '\u{110af}'),
-        ('\u{110d0}', '\u{110e8}'),
-        ('\u{11103}', '\u{11126}'),
-        ('\u{11144}', '\u{11144}'),
-        ('\u{11147}', '\u{11147}'),
-        ('\u{11150}', '\u{11172}'),
-        ('\u{11176}', '\u{11176}'),
-        ('\u{11183}', '\u{111b2}'),
-        ('\u{111c1}', '\u{111c4}'),
-        ('\u{111da}', '\u{111da}'),
-        ('\u{111dc}', '\u{111dc}'),
-        ('\u{11200}', '\u{11211}'),
-        ('\u{11213}', '\u{1122b}'),
-        ('\u{11280}', '\u{11286}'),
-        ('\u{11288}', '\u{11288}'),
-        ('\u{1128a}', '\u{1128d}'),
-        ('\u{1128f}', '\u{1129d}'),
-        ('\u{1129f}', '\u{112a8}'),
-        ('\u{112b0}', '\u{112de}'),
-        ('\u{11305}', '\u{1130c}'),
-        ('\u{1130f}', '\u{11310}'),
-        ('\u{11313}', '\u{11328}'),
-        ('\u{1132a}', '\u{11330}'),
-        ('\u{11332}', '\u{11333}'),
-        ('\u{11335}', '\u{11339}'),
-        ('\u{1133d}', '\u{1133d}'),
-        ('\u{11350}', '\u{11350}'),
-        ('\u{1135d}', '\u{11361}'),
-        ('\u{11400}', '\u{11434}'),
-        ('\u{11447}', '\u{1144a}'),
-        ('\u{1145f}', '\u{11461}'),
-        ('\u{11480}', '\u{114af}'),
-        ('\u{114c4}', '\u{114c5}'),
-        ('\u{114c7}', '\u{114c7}'),
-        ('\u{11580}', '\u{115ae}'),
-        ('\u{115d8}', '\u{115db}'),
-        ('\u{11600}', '\u{1162f}'),
-        ('\u{11644}', '\u{11644}'),
-        ('\u{11680}', '\u{116aa}'),
-        ('\u{116b8}', '\u{116b8}'),
-        ('\u{11700}', '\u{1171a}'),
-        ('\u{11800}', '\u{1182b}'),
-        ('\u{118a0}', '\u{118df}'),
-        ('\u{118ff}', '\u{11906}'),
-        ('\u{11909}', '\u{11909}'),
-        ('\u{1190c}', '\u{11913}'),
-        ('\u{11915}', '\u{11916}'),
-        ('\u{11918}', '\u{1192f}'),
-        ('\u{1193f}', '\u{1193f}'),
-        ('\u{11941}', '\u{11941}'),
-        ('\u{119a0}', '\u{119a7}'),
-        ('\u{119aa}', '\u{119d0}'),
-        ('\u{119e1}', '\u{119e1}'),
-        ('\u{119e3}', '\u{119e3}'),
-        ('\u{11a00}', '\u{11a00}'),
-        ('\u{11a0b}', '\u{11a32}'),
-        ('\u{11a3a}', '\u{11a3a}'),
-        ('\u{11a50}', '\u{11a50}'),
-        ('\u{11a5c}', '\u{11a89}'),
-        ('\u{11a9d}', '\u{11a9d}'),
-        ('\u{11ac0}', '\u{11af8}'),
-        ('\u{11c00}', '\u{11c08}'),
-        ('\u{11c0a}', '\u{11c2e}'),
-        ('\u{11c40}', '\u{11c40}'),
-        ('\u{11c72}', '\u{11c8f}'),
-        ('\u{11d00}', '\u{11d06}'),
-        ('\u{11d08}', '\u{11d09}'),
-        ('\u{11d0b}', '\u{11d30}'),
-        ('\u{11d46}', '\u{11d46}'),
-        ('\u{11d60}', '\u{11d65}'),
-        ('\u{11d67}', '\u{11d68}'),
-        ('\u{11d6a}', '\u{11d89}'),
-        ('\u{11d98}', '\u{11d98}'),
-        ('\u{11ee0}', '\u{11ef2}'),
-        ('\u{11fb0}', '\u{11fb0}'),
-        ('\u{12000}', '\u{12399}'),
-        ('\u{12400}', '\u{1246e}'),
-        ('\u{12480}', '\u{12543}'),
-        ('\u{13000}', '\u{1342e}'),
-        ('\u{14400}', '\u{14646}'),
-        ('\u{16800}', '\u{16a38}'),
-        ('\u{16a40}', '\u{16a5e}'),
-        ('\u{16ad0}', '\u{16aed}'),
-        ('\u{16b00}', '\u{16b2f}'),
-        ('\u{16b40}', '\u{16b43}'),
-        ('\u{16b63}', '\u{16b77}'),
-        ('\u{16b7d}', '\u{16b8f}'),
-        ('\u{16e40}', '\u{16e7f}'),
-        ('\u{16f00}', '\u{16f4a}'),
-        ('\u{16f50}', '\u{16f50}'),
-        ('\u{16f93}', '\u{16f9f}'),
-        ('\u{16fe0}', '\u{16fe1}'),
-        ('\u{16fe3}', '\u{16fe3}'),
-        ('\u{17000}', '\u{187f7}'),
-        ('\u{18800}', '\u{18cd5}'),
-        ('\u{18d00}', '\u{18d08}'),
-        ('\u{1b000}', '\u{1b11e}'),
-        ('\u{1b150}', '\u{1b152}'),
-        ('\u{1b164}', '\u{1b167}'),
-        ('\u{1b170}', '\u{1b2fb}'),
-        ('\u{1bc00}', '\u{1bc6a}'),
-        ('\u{1bc70}', '\u{1bc7c}'),
-        ('\u{1bc80}', '\u{1bc88}'),
-        ('\u{1bc90}', '\u{1bc99}'),
-        ('\u{1d400}', '\u{1d454}'),
-        ('\u{1d456}', '\u{1d49c}'),
-        ('\u{1d49e}', '\u{1d49f}'),
-        ('\u{1d4a2}', '\u{1d4a2}'),
-        ('\u{1d4a5}', '\u{1d4a6}'),
-        ('\u{1d4a9}', '\u{1d4ac}'),
-        ('\u{1d4ae}', '\u{1d4b9}'),
-        ('\u{1d4bb}', '\u{1d4bb}'),
-        ('\u{1d4bd}', '\u{1d4c3}'),
-        ('\u{1d4c5}', '\u{1d505}'),
-        ('\u{1d507}', '\u{1d50a}'),
-        ('\u{1d50d}', '\u{1d514}'),
-        ('\u{1d516}', '\u{1d51c}'),
-        ('\u{1d51e}', '\u{1d539}'),
-        ('\u{1d53b}', '\u{1d53e}'),
-        ('\u{1d540}', '\u{1d544}'),
-        ('\u{1d546}', '\u{1d546}'),
-        ('\u{1d54a}', '\u{1d550}'),
-        ('\u{1d552}', '\u{1d6a5}'),
-        ('\u{1d6a8}', '\u{1d6c0}'),
-        ('\u{1d6c2}', '\u{1d6da}'),
-        ('\u{1d6dc}', '\u{1d6fa}'),
-        ('\u{1d6fc}', '\u{1d714}'),
-        ('\u{1d716}', '\u{1d734}'),
-        ('\u{1d736}', '\u{1d74e}'),
-        ('\u{1d750}', '\u{1d76e}'),
-        ('\u{1d770}', '\u{1d788}'),
-        ('\u{1d78a}', '\u{1d7a8}'),
-        ('\u{1d7aa}', '\u{1d7c2}'),
-        ('\u{1d7c4}', '\u{1d7cb}'),
-        ('\u{1e100}', '\u{1e12c}'),
-        ('\u{1e137}', '\u{1e13d}'),
-        ('\u{1e14e}', '\u{1e14e}'),
-        ('\u{1e2c0}', '\u{1e2eb}'),
-        ('\u{1e800}', '\u{1e8c4}'),
-        ('\u{1e900}', '\u{1e943}'),
-        ('\u{1e94b}', '\u{1e94b}'),
-        ('\u{1ee00}', '\u{1ee03}'),
-        ('\u{1ee05}', '\u{1ee1f}'),
-        ('\u{1ee21}', '\u{1ee22}'),
-        ('\u{1ee24}', '\u{1ee24}'),
-        ('\u{1ee27}', '\u{1ee27}'),
-        ('\u{1ee29}', '\u{1ee32}'),
-        ('\u{1ee34}', '\u{1ee37}'),
-        ('\u{1ee39}', '\u{1ee39}'),
-        ('\u{1ee3b}', '\u{1ee3b}'),
-        ('\u{1ee42}', '\u{1ee42}'),
-        ('\u{1ee47}', '\u{1ee47}'),
-        ('\u{1ee49}', '\u{1ee49}'),
-        ('\u{1ee4b}', '\u{1ee4b}'),
-        ('\u{1ee4d}', '\u{1ee4f}'),
-        ('\u{1ee51}', '\u{1ee52}'),
-        ('\u{1ee54}', '\u{1ee54}'),
-        ('\u{1ee57}', '\u{1ee57}'),
-        ('\u{1ee59}', '\u{1ee59}'),
-        ('\u{1ee5b}', '\u{1ee5b}'),
-        ('\u{1ee5d}', '\u{1ee5d}'),
-        ('\u{1ee5f}', '\u{1ee5f}'),
-        ('\u{1ee61}', '\u{1ee62}'),
-        ('\u{1ee64}', '\u{1ee64}'),
-        ('\u{1ee67}', '\u{1ee6a}'),
-        ('\u{1ee6c}', '\u{1ee72}'),
-        ('\u{1ee74}', '\u{1ee77}'),
-        ('\u{1ee79}', '\u{1ee7c}'),
-        ('\u{1ee7e}', '\u{1ee7e}'),
-        ('\u{1ee80}', '\u{1ee89}'),
-        ('\u{1ee8b}', '\u{1ee9b}'),
-        ('\u{1eea1}', '\u{1eea3}'),
-        ('\u{1eea5}', '\u{1eea9}'),
-        ('\u{1eeab}', '\u{1eebb}'),
-        ('\u{20000}', '\u{2a6dd}'),
-        ('\u{2a700}', '\u{2b734}'),
-        ('\u{2b740}', '\u{2b81d}'),
-        ('\u{2b820}', '\u{2cea1}'),
-        ('\u{2ceb0}', '\u{2ebe0}'),
-        ('\u{2f800}', '\u{2fa1d}'),
-        ('\u{30000}', '\u{3134a}'),
-    ];
-
-    pub fn XID_Start(c: char) -> bool {
-        super::bsearch_range_table(c, XID_Start_table)
-    }
-}
diff --git a/vendor/unicode-xid/src/tests.rs b/vendor/unicode-xid/src/tests.rs
deleted file mode 100644
index 97539eaa..00000000
--- a/vendor/unicode-xid/src/tests.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[cfg(feature = "bench")]
-use std::iter;
-#[cfg(feature = "bench")]
-use std::prelude::v1::*;
-#[cfg(feature = "bench")]
-use test::Bencher;
-
-#[cfg(feature = "bench")]
-use UnicodeXID;
-
-#[cfg(feature = "bench")]
-#[bench]
-fn cargo_is_xid_start(b: &mut Bencher) {
-    let string = iter::repeat('a').take(4096).collect::<String>();
-
-    b.bytes = string.len() as u64;
-    b.iter(|| string.chars().all(super::UnicodeXID::is_xid_start));
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn stdlib_is_xid_start(b: &mut Bencher) {
-    let string = iter::repeat('a').take(4096).collect::<String>();
-
-    b.bytes = string.len() as u64;
-    b.iter(|| string.chars().all(char::is_xid_start));
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn cargo_xid_continue(b: &mut Bencher) {
-    let string = iter::repeat('a').take(4096).collect::<String>();
-
-    b.bytes = string.len() as u64;
-    b.iter(|| string.chars().all(super::UnicodeXID::is_xid_continue));
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn stdlib_xid_continue(b: &mut Bencher) {
-    let string = iter::repeat('a').take(4096).collect::<String>();
-
-    b.bytes = string.len() as u64;
-    b.iter(|| string.chars().all(char::is_xid_continue));
-}
-
-#[test]
-fn test_is_xid_start() {
-    let chars = ['A', 'Z', 'a', 'z', '\u{1000d}', '\u{10026}'];
-
-    for ch in &chars {
-        assert!(super::UnicodeXID::is_xid_start(*ch), "{}", ch);
-    }
-}
-
-#[test]
-fn test_is_not_xid_start() {
-    let chars = [
-        '\x00', '\x01', '0', '9', ' ', '[', '<', '{', '(', '\u{02c2}', '\u{ffff}',
-    ];
-
-    for ch in &chars {
-        assert!(!super::UnicodeXID::is_xid_start(*ch), "{}", ch);
-    }
-}
-
-#[test]
-fn test_is_xid_continue() {
-    let chars = ['0', '9', 'A', 'Z', 'a', 'z', '_', '\u{1000d}', '\u{10026}'];
-
-    for ch in &chars {
-        assert!(super::UnicodeXID::is_xid_continue(*ch), "{}", ch);
-    }
-}
-
-#[test]
-fn test_is_not_xid_continue() {
-    let chars = [
-        '\x00', '\x01', ' ', '[', '<', '{', '(', '\u{02c2}', '\u{ffff}',
-    ];
-
-    for &ch in &chars {
-        assert!(!super::UnicodeXID::is_xid_continue(ch), "{}", ch);
-    }
-}
diff --git a/vendor/unicode-xid/tests/exhaustive_tests.rs b/vendor/unicode-xid/tests/exhaustive_tests.rs
deleted file mode 100644
index 9baac203..00000000
--- a/vendor/unicode-xid/tests/exhaustive_tests.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-extern crate unicode_xid;
-use unicode_xid::UnicodeXID;
-/// A `char` in Rust is a Unicode Scalar Value
-///
-/// See: http://www.unicode.org/glossary/#unicode_scalar_value
-fn all_valid_chars() -> impl Iterator<Item = char> {
-    (0u32..=0xD7FF).chain(0xE000u32..=0x10FFFF).map(|u| {
-        core::convert::TryFrom::try_from(u)
-            .expect("The selected range should be infallible if the docs match impl")
-    })
-}
-
-#[test]
-fn all_valid_chars_do_not_panic_for_is_xid_start() {
-    for c in all_valid_chars() {
-        let _ = UnicodeXID::is_xid_start(c);
-    }
-}
-
-#[test]
-fn all_valid_chars_do_not_panic_for_is_xid_continue() {
-    for c in all_valid_chars() {
-        let _ = UnicodeXID::is_xid_continue(c);
-    }
-}

From 01369d49e61eaa58b8d1fa221839670bd2347203 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Tue, 27 Feb 2024 21:43:56 -0500
Subject: [PATCH 24/74] chore: Add autobuild.toml files for lccc and xlang
 directories

---
 .cargo/config.toml   |  3 ++-
 Cargo.lock           |  9 ++-------
 autobuild.toml       |  7 +++++--
 lccc/autobuild.toml  | 10 ++++++++++
 xlang/autobuild.toml | 36 ++++++++++++++++++++++++++++++++++++
 5 files changed, 55 insertions(+), 10 deletions(-)
 create mode 100644 lccc/autobuild.toml
 create mode 100644 xlang/autobuild.toml

diff --git a/.cargo/config.toml b/.cargo/config.toml
index 15070ded..e6975437 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -2,6 +2,7 @@
 autobuild = ["run", "--package","autobuild","--release","--"]
 configure = "autobuild configure"
 build-lccc = "autobuild build"
+clean-lccc = "autobuild clean"
 run-lccc = "run --bin lccc -- --intree"
 run-lccc-release = "run --release --bin lccc -- --intree"
 
@@ -12,4 +13,4 @@ AUTOBUILD_DIR={relative=true, value="autobuild"}
 # replace-with = "vendored-sources"
 
 [source.vendored-sources]
-directory = "vendor"
\ No newline at end of file
+directory = "vendor"
diff --git a/Cargo.lock b/Cargo.lock
index 75371f8c..fc37e84b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,7 +19,7 @@ version = "0.1.0"
 dependencies = [
  "cfg-match",
  "install-dirs 0.3.2",
- "lccc-siphash 0.1.0 (git+https://github.com/lccc-project/lccc-siphash)",
+ "lccc-siphash",
  "libc",
  "serde",
  "serde_derive",
@@ -280,11 +280,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "15d185e10c787c464fc66c65e04e5ece989e1b654ab177bdad844248e9df71fc"
 
-[[package]]
-name = "lccc-siphash"
-version = "0.1.0"
-source = "git+https://github.com/lccc-project/lccc-siphash#3c969014d6e5f7a14819202d476b3c9d711d5f77"
-
 [[package]]
 name = "lcrustc"
 version = "0.1.0"
@@ -698,7 +693,7 @@ name = "xlang_interface"
 version = "0.1.0"
 dependencies = [
  "lazy_static",
- "lccc-siphash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lccc-siphash",
  "xlang_abi",
  "xlang_host",
  "xlang_targets",
diff --git a/autobuild.toml b/autobuild.toml
index 1b0a7049..0a1ca22f 100644
--- a/autobuild.toml
+++ b/autobuild.toml
@@ -19,10 +19,12 @@ type="rustc"
 target="{build}"
 
 
-[target.groups.frontends]
+[target.groups.languages]
+optional=true
 members=["rust","c"]
 
 [target.groups.backends]
+optional=true
 path-specifier="codegen-{}"
 members=["clever","x86","w65"]
 
@@ -30,11 +32,12 @@ members=["clever","x86","w65"]
 subdir="xlang"
 
 [target.lccc]
+deps=["xlang"]
 subdir="lccc"
 
 
 [stages.host]
-build=["xlang","frontends","backends","lccc"]
+build=["xlang","languages","backends","lccc"]
 
 
 [stages]
diff --git a/lccc/autobuild.toml b/lccc/autobuild.toml
new file mode 100644
index 00000000..349b5711
--- /dev/null
+++ b/lccc/autobuild.toml
@@ -0,0 +1,10 @@
+
+[target.liblccc]
+deps=["xlang:xlang", "xlang:xlang_interface"]
+src="src/lib.rs"
+crate-type="rlib"
+
+[target.lccc]
+deps=["liblccc"]
+src="src/main.rs"
+crate-type="bin"
\ No newline at end of file
diff --git a/xlang/autobuild.toml b/xlang/autobuild.toml
new file mode 100644
index 00000000..a6ed5e41
--- /dev/null
+++ b/xlang/autobuild.toml
@@ -0,0 +1,36 @@
+
+[targets.xlang_host]
+src="xlang_host/src/lib.rs"
+
+
+[target.xlang_abi]
+deps=["xlang_host"]
+src="xlang_abi/src/lib.rs"
+
+[target.xlang_targets]
+deps=["xlang_abi"]
+src="xlang_targets/src/lib.rs"
+
+[target.xlang_struct]
+deps=["xlang_abi", "xlang_targets", "vendor:bitflags-1.3", "vendor:fake-enum-0.1.4"]
+src="xlang_struct/src/lib.rs"
+
+[target.xlang-interface]
+deps=["xlang_abi"]
+src="xlang_interface/src/lib.rs"
+
+[target.xlang-interface.library]
+library-type="dynamic"
+soname="0.1"
+
+[target.xlang]
+deps=["xlang_abi", "xlang_host", "xlang_struct", "xlang_targets"]
+src="src/lib.rs"
+
+[target.xlang_backend]
+deps=["xlang"]
+src="xlang_backend/src/lib.rs"
+
+[target.xlang_frontend]
+deps=["xlang"]
+src="xlang_frontend/src/lib.rs"
\ No newline at end of file

From 72d77712425529e0d9eaa99e07a7d744f879cb96 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Tue, 27 Feb 2024 21:45:55 -0500
Subject: [PATCH 25/74] chore: Update autobuild submodule

---
 autobuild | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autobuild b/autobuild
index fb101710..40f588a1 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit fb101710b7e09b79a2cd1ca62494204b4342b181
+Subproject commit 40f588a140328db6e91631ebc232c599be8de97d

From dea73d4bb35116826b74592c7e49b79700419566 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Tue, 27 Feb 2024 21:47:31 -0500
Subject: [PATCH 26/74] feat(xir): Lex XIR files

---
 autobuild                          |    2 +-
 rust/src/sema/intrin_defs.rs       |    9 +
 xir/Cargo.toml                     |    4 +-
 xir/src/lexer.rs                   |  290 ++---
 xir/src/lib.rs                     |   19 +-
 xir/src/parser.rs                  | 1676 ----------------------------
 xlang/xlang_abi/src/io.rs          |    2 +-
 xlang/xlang_abi/src/ops.rs         |   38 +
 xlang/xlang_abi/src/string.rs      |   49 +
 xlang/xlang_abi/src/traits.rs      |    2 +-
 xlang/xlang_backend/src/ssa.rs     |    1 -
 xlang/xlang_frontend/Cargo.toml    |    3 +-
 xlang/xlang_frontend/src/iter.rs   |  117 +-
 xlang/xlang_frontend/src/lexer.rs  |  662 +++++++++++
 xlang/xlang_frontend/src/lib.rs    |    2 +
 xlang/xlang_frontend/src/span.rs   |   39 +-
 xlang/xlang_frontend/src/symbol.rs |   14 +-
 xlang/xlang_host/src/lib.rs        |    4 +-
 xlang/xlang_host/src/sync.rs       |    1 +
 xlang/xlang_host/src/sync/sys.rs   |    1 +
 20 files changed, 1096 insertions(+), 1839 deletions(-)
 create mode 100644 xlang/xlang_frontend/src/lexer.rs
 create mode 100644 xlang/xlang_host/src/sync.rs
 create mode 100644 xlang/xlang_host/src/sync/sys.rs

diff --git a/autobuild b/autobuild
index 40f588a1..6e7bfbad 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit 40f588a140328db6e91631ebc232c599be8de97d
+Subproject commit 6e7bfbad6e62a90790507611e8a7d8b26e26d7d3
diff --git a/rust/src/sema/intrin_defs.rs b/rust/src/sema/intrin_defs.rs
index e44527b7..e0a1a01a 100644
--- a/rust/src/sema/intrin_defs.rs
+++ b/rust/src/sema/intrin_defs.rs
@@ -27,4 +27,13 @@ def_intrinsics! {
 
     intrin __builtin_likely(bool) -> bool;
     intrin __builtin_unlikely(bool) -> bool;
+
+
+    intrin __builtin_fadd_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fsub_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fmul_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fdiv_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_frem_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_ffma_fast<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fneg_fast<type>(Var<0>) -> Var<0>;
 }
diff --git a/xir/Cargo.toml b/xir/Cargo.toml
index 5745e242..ecb69670 100644
--- a/xir/Cargo.toml
+++ b/xir/Cargo.toml
@@ -10,9 +10,7 @@ license = "BSD-2-Clause-Patent"
 xlang = {path="../xlang"}
 xlang_struct = {path="../xlang/xlang_struct"}
 unicode-xid = "0.2.2"
-target-tuples = "0.5"
-peekmore = "1.0.0"
-binary-io = "0.1.0"
+xlang_frontend = {path="../xlang/xlang_frontend"}
 
 [lib]
 crate-type = ["cdylib"]
diff --git a/xir/src/lexer.rs b/xir/src/lexer.rs
index b37a31dc..aabf5354 100644
--- a/xir/src/lexer.rs
+++ b/xir/src/lexer.rs
@@ -1,144 +1,184 @@
-use std::iter::Peekable;
+#![allow(dead_code)]
 
-use xlang::abi::{string::String, vec::Vec};
+use std::convert::Infallible;
 
-use unicode_xid::UnicodeXID;
+use xlang::abi::string::String;
+use xlang_frontend::span::{NoHygiene, Speekable};
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum Token {
-    Ident(String),
-    StringLiteral(String),
-    IntLiteral(u128),
-    Sigil(char),
-    Group(Group),
-}
+pub use xlang_frontend::lexer::{
+    is_ident_part_unicode, is_ident_start_unicode, parse_escape, DefaultTy, Error, HexEscape,
+    Lexer, Result, UnicodeEscapeRust,
+};
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub enum Group {
-    Parenthesis(Vec<Token>),
-    Bracket(Vec<Token>),
-    Braces(Vec<Token>),
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum GroupType {
+    Paren,
+    Bracket,
+    Brace,
+    Angle,
 }
 
-fn lex_group<I: Iterator<Item = char>>(stream: &mut Peekable<I>, term_char: char) -> Vec<Token> {
-    stream.next();
-    let mut ret = Vec::new();
-    loop {
-        let v = stream.peek().unwrap();
-        match v {
-            ']' | ')' | '}' if *v == term_char => {
-                stream.next();
-                break;
-            }
-            ']' | ')' | '}' => panic!("Unmatched group end token {}", v),
-            _ => match lex_one(stream) {
-                Some(tok) => ret.push(tok),
-                None => {
-                    if let Some('}' | ')' | ']') = stream.peek() {
-                        stream.next();
-                        break;
-                    }
-                }
-            },
-        }
+pub struct XirLexer;
+
+impl Lexer for XirLexer {
+    type Hygiene = NoHygiene;
+
+    type IdentTy = DefaultTy;
+
+    type StrTy = DefaultTy;
+
+    type CharTy = DefaultTy;
+
+    type OtherTy = Infallible;
+
+    type GroupType = GroupType;
+
+    type OtherLex = Infallible;
+
+    fn is_ident_start(&self, c: char) -> bool {
+        is_ident_start_unicode(c) || c == '_' || c == '$'
     }
 
-    ret
-}
+    fn is_ident_part(&self, c: char) -> bool {
+        is_ident_part_unicode(c) || c == '_' || c == '$' || c == '.'
+    }
 
-fn lex_one<I: Iterator<Item = char>>(stream: &mut Peekable<I>) -> Option<Token> {
-    match stream.peek()? {
-        '(' => Some(Token::Group(Group::Parenthesis(lex_group(stream, ')')))),
-        '{' => Some(Token::Group(Group::Braces(lex_group(stream, '}')))),
-        '[' => Some(Token::Group(Group::Bracket(lex_group(stream, ']')))),
-        c if (*c == '$' || *c == '_' || c.is_xid_start()) => {
-            let mut id = String::new();
-            id.push(stream.next().unwrap());
-
-            while stream
-                .peek()
-                .map_or(false, |c| (*c == '$' || *c == '_' || c.is_xid_continue()))
-            {
-                id.push(stream.next().unwrap());
-            }
-            Some(Token::Ident(id))
-        }
-        '!' | '@' | '#' | '%' | '^' | '&' | '*' | '<' | '>' | '=' | '+' | '-' | ';' | ':' | ','
-        | '.' => Some(Token::Sigil(stream.next().unwrap())),
-
-        '0' => {
-            // We can toss away the zero, just remember that it exists
-            stream.next();
-            match stream.peek() {
-                Some('x') => {
-                    stream.next();
-                    let mut lit = 0u128;
-                    while let Some('0'..='9' | 'A'..='F' | 'a'..='f') = stream.peek() {
-                        lit <<= 4;
-                        let c = stream.next().unwrap();
-                        match c {
-                            '0'..='9' => lit |= u128::from(c as u32) - 0x30,
-                            'A'..='F' => lit |= u128::from(c as u32) - 0x31,
-                            'a'..='f' => lit |= u128::from(c as u32) - 0x51,
-                            _ => unreachable!(),
-                        }
-                    }
-                    Some(Token::IntLiteral(lit))
-                }
-                Some('0'..='9') => {
-                    let mut lit = 0u128;
-                    while let Some('0'..='9' | 'A'..='F' | 'a'..='f') = stream.peek() {
-                        lit *= 10;
-                        let c = stream.next().unwrap();
-                        lit += u128::from(c as u32) - 0x30;
-                    }
-                    Some(Token::IntLiteral(lit))
-                }
-                _ => Some(Token::IntLiteral(0)),
-            }
+    fn ident_type(&self, _: &str) -> Self::IdentTy {
+        DefaultTy
+    }
+
+    fn is_num_sep(&self, _: char) -> bool {
+        false
+    }
+
+    fn is_num_prefix_frag(&self, c: &str) -> bool {
+        c == "0"
+    }
+
+    fn is_num_prefix(&self, c: &str) -> Option<u32> {
+        match c {
+            "0x" => Some(16),
+            _ => None,
         }
-        '1'..='9' => {
-            let mut lit = 0u128;
-            while let Some('0'..='9' | 'A'..='F' | 'a'..='f') = stream.peek() {
-                lit *= 10;
-                let c = stream.next().unwrap();
-                lit += u128::from(c as u32) - 0x30;
+    }
+
+    fn check_valid_num<I: Iterator<Item = char>>(
+        &self,
+        c: &str,
+        it: &mut xlang_frontend::iter::PeekMoreIterator<Speekable<I>>,
+    ) -> Result<()> {
+        if c == "0x" {
+            match it.next() {
+                Some((pos, c)) => Err(Error::UnrecognizedChar(c, pos)),
+                None => Err(Error::UnexpectedEof(it.last_pos())),
             }
-            Some(Token::IntLiteral(lit))
+        } else {
+            Ok(())
         }
-        '"' => {
-            let mut string = String::new();
-            stream.next();
-            loop {
-                match stream.peek().unwrap() {
-                    '\\' => {
-                        string.push(stream.next().unwrap());
-                        string.push(stream.next().unwrap());
-                    }
-                    '\"' => {
-                        stream.next().unwrap();
-                        break Some(Token::StringLiteral(string));
-                    }
-                    _ => string.push(stream.next().unwrap()),
-                }
-            }
+    }
+
+    fn is_float_in_radix(&self, _: u32) -> bool {
+        false
+    }
+
+    fn is_float_exp_char(&self, _: char, _: u32) -> bool {
+        false
+    }
+
+    fn is_group_start(&self, c: char) -> Option<(Self::GroupType, char)> {
+        match c {
+            '{' => Some((GroupType::Brace, '}')),
+            '[' => Some((GroupType::Bracket, ']')),
+            '<' => Some((GroupType::Angle, '>')),
+            '(' => Some((GroupType::Paren, ')')),
+            _ => None,
         }
-        c if c.is_whitespace() => {
-            while stream.peek().copied().map_or(false, char::is_whitespace) {
-                stream.next();
+    }
+
+    fn next_token_start<I: Iterator<Item = char>>(
+        &self,
+        it: &mut xlang_frontend::iter::PeekMoreIterator<Speekable<I>>,
+    ) -> Result<Option<(char, xlang_frontend::span::Pos)>> {
+        let (pos, c) = loop {
+            match it.next() {
+                Some((pos, c)) => match c {
+                    c if c.is_ascii_whitespace() => continue,
+                    '/' => match it.peek() {
+                        Some((_, '/')) => {
+                            it.next();
+                            while let Some((_, c)) = it.next() {
+                                if c == '\n' {
+                                    break;
+                                }
+                            }
+                        }
+                        Some((_, '*')) => {
+                            it.next();
+                            loop {
+                                match it.next() {
+                                    Some((_, c)) if c == '*' => match it.next() {
+                                        Some((_, c)) if c == '/' => break,
+                                        Some(_) => {}
+                                        None => return Err(Error::UnexpectedEof(it.last_pos())),
+                                    },
+                                    Some(_) => {}
+                                    None => return Err(Error::UnexpectedEof(it.last_pos())),
+                                }
+                            }
+                        }
+                        _ => break (pos, '/'),
+                    },
+                    c => break (pos, c),
+                },
+                None => return Ok(None),
             }
-            lex_one(stream)
+        };
+
+        Ok(Some((c, pos)))
+    }
+
+    fn punct_list(&self) -> &[&str] {
+        &["->", "::", ":", "#", "@"]
+    }
+
+    fn check_valid_punct<I: Iterator<Item = char>>(
+        &self,
+        c: &str,
+        it: &mut xlang_frontend::iter::PeekMoreIterator<Speekable<I>>,
+    ) -> Result<()> {
+        match c {
+            "->" | "::" | ":" | "#" | "@" => Ok(()),
+            _ => match it.next() {
+                Some((pos, c)) => Err(Error::UnrecognizedChar(c, pos)),
+                None => Err(Error::UnexpectedEof(it.last_pos())),
+            },
         }
-        ')' | ']' | '}' => None,
-        c => panic!("unknown character {}", c),
     }
-}
 
-pub fn lex<'a, I: Iterator<Item = char> + 'a>(stream: I) -> impl Iterator<Item = Token> + 'a {
-    let mut stream = stream.peekable();
-    if stream.peek() == Some(&'\u{FFFE}') {
-        // If there's a BOM, eat it
-        stream.next();
+    fn default_str_type(&self) -> Self::StrTy {
+        DefaultTy
+    }
+
+    fn default_char_type(&self) -> Self::CharTy {
+        DefaultTy
+    }
+
+    fn check_escape<I: Iterator<Item = char>>(
+        &self,
+        it: &mut xlang_frontend::iter::PeekMoreIterator<Speekable<I>>,
+    ) -> Result<String> {
+        parse_escape(
+            it,
+            (
+                'n',
+                't',
+                '0',
+                'r',
+                HexEscape('x', 2),
+                UnicodeEscapeRust('u', 1..=6),
+            ),
+        )
     }
-    core::iter::from_fn(move || lex_one(&mut stream))
 }
+
+pub use xlang_frontend::lexer::lex_file;
diff --git a/xir/src/lib.rs b/xir/src/lib.rs
index 251cb662..c7ea5a35 100644
--- a/xir/src/lib.rs
+++ b/xir/src/lib.rs
@@ -8,6 +8,8 @@ use xlang::ir;
 use xlang::plugin::{Error, XLangFrontend, XLangPlugin};
 use xlang::targets::properties::TargetProperties;
 
+mod lexer;
+
 struct XirFrontend {
     filename: Option<String>,
     target: Option<&'static TargetProperties<'static>>,
@@ -33,8 +35,21 @@ impl XLangFrontend for XirFrontend {
     }
 
     #[allow(clippy::cast_lossless)]
-    fn read_source(&mut self, _: DynMut<dyn Read>) -> io::Result<()> {
-        todo!()
+    fn read_source(&mut self, it: DynMut<dyn Read>) -> io::Result<()> {
+        use xlang::abi::io::IntoChars;
+        let filename = self
+            .filename
+            .take()
+            .unwrap_or_else(|| String::from("<unset file name>"));
+
+        let chars = it.into_chars();
+
+        let lexer = lexer::XirLexer;
+
+        let toks = lexer::lex_file(&lexer, chars, filename).unwrap();
+        println!("{:?}", toks);
+
+        xlang::abi::result::Ok(())
     }
 }
 
diff --git a/xir/src/parser.rs b/xir/src/parser.rs
index 1f206a2c..8b137891 100644
--- a/xir/src/parser.rs
+++ b/xir/src/parser.rs
@@ -1,1677 +1 @@
-#![allow(dead_code)]
 
-use std::convert::{TryFrom, TryInto};
-
-use peekmore::{PeekMore as _, PeekMoreIterator};
-
-use xlang::abi::string::FromUtf8Error;
-use xlang::{abi::string::String, abi::vec::Vec, prelude::v1::Pair};
-
-use xlang_struct::{
-    AccessClass, AggregateCtor, AggregateDefinition, AggregateField, AggregateFieldSpecifier,
-    AggregateKind, AnnotatedElement, AsmConstraint, AsmExpr, AsmOptions, AsmOutput, BinaryOp,
-    Block, BlockItem, BranchCondition, CharFlags, ConversionStrength, Expr, File, FnType,
-    FunctionBody, FunctionDeclaration, HashSwitch, LinearSwitch, Linkage, MemberDeclaration,
-    OverflowBehaviour, Path, PathComponent, PointerAliasingRule, PointerDeclarationType,
-    PointerKind, PointerType, ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Scope,
-    ScopeMember, StackItem, StringEncoding, Switch, Type, UnaryOp, ValidRangeType, Value,
-    Visibility,
-};
-
-use crate::lexer::{Group, Token};
-
-pub fn parse_function_type<I: Iterator<Item = Token>>(stream: &mut PeekMoreIterator<I>) -> FnType {
-    match stream.next().unwrap() {
-        Token::Ident(id) if id == "function" => match stream.next().unwrap() {
-            Token::Group(Group::Parenthesis(tok)) => {
-                let mut params = Vec::new();
-                let mut peekable = tok.into_iter().peekmore();
-                let mut variadic = false;
-                loop {
-                    match peekable.peek() {
-                        Some(Token::Sigil('.')) => {
-                            peekable.next();
-                            match peekable.next().unwrap() {
-                                Token::Sigil('.') => {}
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-                            match peekable.next().unwrap() {
-                                Token::Sigil('.') => {}
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-
-                            if let Some(tok) = peekable.next() {
-                                panic!("Unexpected token {:?}", tok);
-                            }
-                            variadic = true;
-                            break;
-                        }
-                        Some(_) => {
-                            params.push(parse_type(&mut peekable).unwrap());
-                        }
-                        None => break,
-                    }
-
-                    match peekable.next() {
-                        Some(Token::Sigil(',')) => continue,
-                        Some(tok) => panic!("Unexpected token {:?}", tok),
-                        None => break,
-                    }
-                }
-                drop(peekable);
-                match stream.peek() {
-                    Some(Token::Sigil('-')) => {
-                        stream.next();
-                        match stream.next().unwrap() {
-                            Token::Sigil('>') => FnType {
-                                ret: parse_type(stream).unwrap(),
-                                params,
-                                tag: "".into(),
-                                variadic,
-                            },
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                    _ => FnType {
-                        ret: Type::Null,
-                        params,
-                        tag: "".into(),
-                        variadic,
-                    },
-                }
-            }
-            tok => panic!("Unexpected Token {:?}", tok),
-        },
-        Token::Ident(id) if id == "extern" => todo!("extern"),
-        tok => panic!("Unexpected token {:?}", tok),
-    }
-}
-
-#[allow(clippy::cognitive_complexity)] // TODO: refactor
-#[allow(clippy::too_many_lines)] // TODO: refactor
-pub fn parse_type<I: Iterator<Item = Token>>(stream: &mut PeekMoreIterator<I>) -> Option<Type> {
-    match stream.peek() {
-        Some(Token::Group(Group::Parenthesis(_))) => {
-            let group = if let Some(Token::Group(Group::Parenthesis(inner))) = stream.next() {
-                inner
-            } else {
-                unreachable!()
-            };
-            let mut inner = group.into_iter().peekmore();
-            Some(parse_type(&mut inner).unwrap())
-        }
-        Some(Token::Ident(id)) => match &**id {
-            "function" | "extern" => Some(Type::FnType(xlang::abi::boxed::Box::new(
-                parse_function_type(stream),
-            ))),
-            "void" => {
-                stream.next();
-                match stream.next() {
-                    Some(Token::Group(Group::Parenthesis(v))) if v.is_empty() => Some(Type::Void),
-                    Some(tok) => panic!("Unexpected token {:?}", tok),
-                    None => panic!("Unexpected EOF"),
-                }
-            }
-            "uint" | "int" => {
-                let signed = id == "int";
-                stream.next().unwrap();
-                let mut min = None;
-                let mut max = None;
-                let mut header = ScalarTypeHeader {
-                    bitsize: 0,
-                    ..ScalarTypeHeader::default()
-                };
-                loop {
-                    match stream.next() {
-                        Some(Token::Ident(s)) if s == "nonzero" => {
-                            header.validity |= ScalarValidity::NONZERO;
-                        }
-                        Some(Token::Ident(s)) if s == "min" => {
-                            if let Some(Token::Group(Group::Parenthesis(toks))) = stream.next() {
-                                match &*toks {
-                                    [Token::IntLiteral(n)] => {
-                                        min = Some(i128::try_from(*n).expect(
-                                            "oversized integer literals currently unsupported",
-                                        ));
-                                    }
-                                    [Token::Sigil('-'), Token::IntLiteral(n)] => {
-                                        min = Some(
-                                            -i128::try_from(*n)
-                                                .expect("integer literal too far negative"),
-                                        );
-                                    }
-                                    toks => panic!("Unexpected tokens: {:?}", toks),
-                                }
-                            } else {
-                                panic!("Unexpected Token");
-                            }
-                        }
-                        Some(Token::Ident(s)) if s == "max" => {
-                            if let Some(Token::Group(Group::Parenthesis(toks))) = stream.next() {
-                                match &*toks {
-                                    [Token::IntLiteral(n)] => {
-                                        max = Some(i128::try_from(*n).expect(
-                                            "oversized integer literals currently unsupported",
-                                        ));
-                                    }
-                                    [Token::Sigil('-'), Token::IntLiteral(n)] => {
-                                        max = Some(
-                                            -i128::try_from(*n)
-                                                .expect("integer literal too far negative"),
-                                        );
-                                    }
-                                    toks => panic!("Unexpected tokens: {:?}", toks),
-                                }
-                            } else {
-                                panic!("Unexpected Token");
-                            }
-                        }
-                        Some(Token::Ident(s)) if s == "vector" => {
-                            if let Some(Token::Group(Group::Parenthesis(toks))) = stream.next() {
-                                match &*toks {
-                                    [Token::IntLiteral(n)] => {
-                                        header.vectorsize =
-                                            Some(TryFrom::try_from(*n).unwrap()).into();
-                                    }
-                                    toks => panic!("Unexpected tokens: {:?}", toks),
-                                }
-                            } else {
-                                panic!("Unexpected Token");
-                            }
-                        }
-                        Some(Token::Group(Group::Parenthesis(toks))) => match &*toks {
-                            [Token::IntLiteral(n)] => {
-                                header.bitsize = TryFrom::try_from(*n).unwrap();
-                                break Some(Type::Scalar(ScalarType {
-                                    header,
-                                    kind: ScalarTypeKind::Integer {
-                                        signed,
-                                        min: min.into(),
-                                        max: max.into(),
-                                    },
-                                }));
-                            }
-                            toks => panic!("Unexpected tokens: {:?}", toks),
-                        },
-                        Some(tok) => panic!("Unexpected token: {:?}", tok),
-                        None => panic!("Unexpected end of input"),
-                    }
-                }
-            }
-            "char" | "schar" => {
-                let mut flags = CharFlags::empty();
-                if id == "schar" {
-                    flags |= CharFlags::SIGNED;
-                }
-                stream.next().unwrap();
-                let mut header = ScalarTypeHeader {
-                    bitsize: 0,
-                    ..ScalarTypeHeader::default()
-                };
-                loop {
-                    match stream.next() {
-                        Some(Token::Ident(s)) if s == "unicode" => {
-                            break Some(Type::Scalar(ScalarType {
-                                header,
-                                kind: ScalarTypeKind::Char { flags },
-                            }))
-                        }
-                        Some(Token::Ident(s)) if s == "vector" => {
-                            if let Some(Token::Group(Group::Parenthesis(toks))) = stream.next() {
-                                match &*toks {
-                                    [Token::IntLiteral(n)] => {
-                                        header.vectorsize =
-                                            Some(TryFrom::try_from(*n).unwrap()).into();
-                                    }
-                                    toks => panic!("Unexpected tokens: {:?}", toks),
-                                }
-                            } else {
-                                panic!("Unexpected Token");
-                            }
-                        }
-                        Some(Token::Group(Group::Parenthesis(toks))) => match &*toks {
-                            [Token::IntLiteral(n)] => {
-                                header.bitsize = TryFrom::try_from(*n).unwrap();
-                                break Some(Type::Scalar(ScalarType {
-                                    header,
-                                    kind: ScalarTypeKind::Char { flags },
-                                }));
-                            }
-                            toks => panic!("Unexpected tokens: {:?}", toks),
-                        },
-                        Some(tok) => panic!("Unexpected token: {:?}", tok),
-                        None => panic!("Unexpected end of input"),
-                    }
-                }
-            }
-            "struct " => {
-                stream.next();
-                let defn = parse_aggregate_body(stream, AggregateKind::Struct).unwrap();
-                Some(Type::Aggregate(defn))
-            }
-            "union" => {
-                stream.next();
-                let defn = parse_aggregate_body(stream, AggregateKind::Union).unwrap();
-                Some(Type::Aggregate(defn))
-            }
-            "product" => {
-                stream.next();
-                match stream.next().unwrap() {
-                    Token::Group(Group::Parenthesis(inner)) => {
-                        let mut tys = Vec::new();
-                        let mut it = inner.into_iter().peekmore();
-
-                        loop {
-                            if let Some(ty) = parse_type(&mut it) {
-                                tys.push(ty);
-                            } else {
-                                break;
-                            }
-
-                            match it.next() {
-                                Some(Token::Sigil(',')) => continue,
-                                None => break,
-                                Some(tok) => panic!("Unexpected token {:?}", tok),
-                            }
-                        }
-
-                        Some(Type::Product(tys))
-                    }
-                    tok => panic!("Unexpected token {:?}", tok),
-                }
-            }
-            _ => Some(Type::Named(parse_path(stream))),
-        },
-        Some(Token::Sigil('*')) => {
-            stream.next();
-            let mut alias = PointerAliasingRule::default();
-            let valid_range = Pair::<ValidRangeType, u64>::default();
-            let mut decl = PointerDeclarationType::default();
-            let mut kind = PointerKind::default();
-            let addr_space = 0;
-            loop {
-                match stream.peek().unwrap() {
-                    Token::Ident(id) if id == "const" => decl |= PointerDeclarationType::CONST,
-                    Token::Ident(id) if id == "volatile" => {
-                        decl |= PointerDeclarationType::VOLATILE;
-                    }
-                    Token::Ident(id) if id == "ref" => decl |= PointerDeclarationType::REF,
-                    Token::Ident(id) if id == "nonnull" => alias |= PointerAliasingRule::NONNULL,
-                    Token::Ident(id) if id == "invalid" => alias |= PointerAliasingRule::INVALID,
-                    Token::Ident(id) if id == "null_or_invalid" => {
-                        alias |= PointerAliasingRule::NULL_OR_INVALID;
-                    }
-                    Token::Ident(id) if id == "unique" => alias |= PointerAliasingRule::UNIQUE,
-                    Token::Ident(id) if id == "read_only" => {
-                        alias |= PointerAliasingRule::READ_ONLY;
-                    }
-                    Token::Ident(id) if id == "read_shallow" => {
-                        alias |= PointerAliasingRule::READ_SHALLOW;
-                    }
-                    Token::Ident(id) if id == "near" => {
-                        kind = PointerKind::Near;
-                    }
-                    Token::Ident(id) if id == "far" => {
-                        kind = PointerKind::Far;
-                    }
-                    Token::Ident(id) if id == "dereferenceable" => todo!("*dereferenceable"),
-                    Token::Ident(id) if id == "dereference_write" => todo!("*dereference_write"),
-                    Token::Ident(id) if id == "write_only" => todo!("*write_only"),
-                    Token::Ident(id) if id == "null_or_dereferenceable" => {
-                        todo!("*null_or_dereferenceable")
-                    }
-                    Token::Ident(id) if id == "null_or_dereference_write" => {
-                        todo!("*null_or_dereference_write")
-                    }
-                    Token::Ident(id) if id == "null_or_write_only" => todo!("*null_or_write_only"),
-                    _ => {
-                        break Some(Type::Pointer(PointerType {
-                            alias,
-                            valid_range,
-                            decl,
-                            kind,
-                            addr_space,
-                            inner: xlang::abi::boxed::Box::new(parse_type(stream).unwrap()),
-                        }))
-                    }
-                }
-                stream.next();
-            }
-        }
-        Some(_) => Some(Type::Named(parse_path(stream))),
-        None => None,
-    }
-}
-
-pub fn parse_attr_list<I: Iterator<Item = Token>>(
-    _it: &mut PeekMoreIterator<I>,
-) -> AnnotatedElement {
-    todo!()
-}
-
-pub fn parse_path<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> Path {
-    let mut path = Vec::new();
-    if it.peek() == Some(&Token::Sigil(':')) {
-        it.next();
-        path.push(PathComponent::Root);
-        assert_eq!(it.next(), Some(Token::Sigil(':')));
-    }
-    loop {
-        match it.next().unwrap() {
-            Token::Sigil('#') => match it.next().unwrap() {
-                Token::StringLiteral(s) => path.push(PathComponent::SpecialComponent(s)),
-                tok => panic!("Unexpected token {:?}", tok),
-            },
-            Token::Ident(id) => path.push(PathComponent::Text(id)),
-            Token::Sigil('%') => todo!("Dependant name"),
-            Token::Sigil('<') => todo!("Generics"),
-            tok => panic!("Unexpected token {:?}", tok),
-        }
-
-        if it.peek() == Some(&Token::Sigil(':')) {
-            it.next();
-            assert_eq!(it.next(), Some(Token::Sigil(':')));
-        } else {
-            break Path { components: path };
-        }
-    }
-}
-
-pub fn parse_aggregate_body<I: Iterator<Item = Token>>(
-    it: &mut PeekMoreIterator<I>,
-    kind: AggregateKind,
-) -> Option<AggregateDefinition> {
-    match it.next().unwrap() {
-        Token::Sigil(';') => None,
-        Token::Group(Group::Braces(tokens)) => {
-            let mut it = tokens.into_iter().peekmore();
-
-            let mut fields = Vec::new();
-            'a: loop {
-                let mut specifiers = AggregateFieldSpecifier::empty();
-
-                loop {
-                    match it.peek() {
-                        Some(Token::Ident(id)) if id == "mutable" => {
-                            specifiers |= AggregateFieldSpecifier::MUTABLE;
-                            it.next();
-                        }
-                        None => break 'a,
-                        _ => break,
-                    }
-                }
-
-                let name = match it.next() {
-                    Some(Token::Ident(id)) => id,
-                    Some(Token::Group(Group::Parenthesis(group))) => match &*group {
-                        [Token::Ident(id)] => id.clone(),
-                        rest => panic!("Unexpected tokens in group {:?}", rest),
-                    },
-                    None => panic!("Unexpected EOF"),
-                    Some(tok) => panic!("Unexpected token {:?}", tok),
-                };
-
-                match it.next().unwrap() {
-                    Token::Sigil(':') => {}
-                    tok => panic!("Unexpected token {:?}", tok),
-                }
-
-                let ty = parse_type(&mut it).unwrap();
-                fields.push(AggregateField {
-                    annotations: AnnotatedElement::default(),
-                    specifiers,
-                    name,
-                    ty,
-                    bitfield_width: Value::Empty,
-                });
-                match it.next() {
-                    Some(Token::Sigil(',')) => continue,
-                    None => break,
-                    Some(tok) => panic!("Unexpected token {:?}", tok),
-                }
-            }
-
-            Some(AggregateDefinition {
-                annotations: AnnotatedElement::default(),
-                kind,
-                fields,
-            })
-        }
-        tok => panic!("Unexpected token {:?}", tok),
-    }
-}
-
-pub fn parse_function_decl<I: Iterator<Item = Token>>(
-    it: &mut PeekMoreIterator<I>,
-    linkage: Linkage,
-) -> ScopeMember {
-    match it.next().unwrap() {
-        Token::Group(Group::Parenthesis(toks)) => {
-            let mut params = Vec::new();
-            let mut peekable = toks.into_iter().peekmore();
-            let mut variadic = false;
-            loop {
-                match peekable.peek() {
-                    Some(Token::Sigil('.')) => {
-                        peekable.next();
-                        match peekable.next().unwrap() {
-                            Token::Sigil('.') => {}
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                        match peekable.next().unwrap() {
-                            Token::Sigil('.') => {}
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-
-                        if let Some(tok) = peekable.next() {
-                            panic!("Unexpected token {:?}", tok);
-                        }
-                        variadic = true;
-                        break;
-                    }
-                    Some(_) => {
-                        params.push(parse_type(&mut peekable).unwrap());
-                    }
-                    None => break,
-                }
-
-                match peekable.next() {
-                    Some(Token::Sigil(',')) => continue,
-                    Some(tok) => panic!("Unexpected token {:?}", tok),
-                    None => break,
-                }
-            }
-            drop(peekable);
-
-            let ret = match it.peek().unwrap() {
-                Token::Sigil('-') => {
-                    it.next();
-                    assert_eq!(it.next(), Some(Token::Sigil('>')));
-                    parse_type(it).unwrap()
-                }
-
-                _ => Type::Void,
-            };
-
-            match it.next().unwrap() {
-                Token::Sigil(';') => ScopeMember {
-                    member_decl: MemberDeclaration::Function(FunctionDeclaration {
-                        ty: xlang_struct::FnType {
-                            ret,
-                            params,
-                            tag: "".into(),
-                            variadic,
-                        },
-                        body: xlang::abi::option::None,
-                        linkage,
-                    }),
-                    ..ScopeMember::default()
-                },
-                Token::Group(Group::Braces(toks)) => {
-                    let mut peekable = toks.into_iter().peekmore();
-                    let mut locals = Vec::new();
-                    loop {
-                        match peekable.peek() {
-                            Some(Token::Ident(id)) if id == "declare" => {
-                                peekable.next();
-                                match peekable.next().unwrap() {
-                                    Token::Ident(id) if id.starts_with('_') => {
-                                        // Assume there's increasing indecies for now
-                                    }
-                                    tok => panic!("Unrecognized token {:?}", tok),
-                                }
-                                match peekable.next().unwrap() {
-                                    Token::Sigil(':') => {}
-                                    tok => panic!("Unrecognized token {:?}", tok),
-                                }
-                                locals.push(parse_type(&mut peekable).unwrap());
-                                match peekable.next().unwrap() {
-                                    Token::Sigil(';') => {}
-                                    tok => panic!("Unrecognized token {:?}", tok),
-                                }
-                            }
-                            _ => break,
-                        }
-                    }
-                    ScopeMember {
-                        member_decl: MemberDeclaration::Function(FunctionDeclaration {
-                            ty: xlang_struct::FnType {
-                                ret,
-                                params,
-                                tag: "".into(),
-                                variadic,
-                            },
-                            body: xlang::abi::option::Some(FunctionBody {
-                                locals,
-                                block: parse_block(&mut peekable),
-                            }),
-                            linkage,
-                        }),
-                        ..ScopeMember::default()
-                    }
-                }
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        tok => panic!("Unexpceted token {:?}", tok),
-    }
-}
-
-#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // TODO: refactor
-pub fn parse_scope_member<I: Iterator<Item = Token>>(
-    it: &mut PeekMoreIterator<I>,
-) -> Option<(Path, ScopeMember)> {
-    match it.peek()? {
-        Token::Ident(id) if id == "public" => {
-            it.next();
-            let mut mem = parse_scope_member(it).unwrap();
-            mem.1.vis = Visibility::Public;
-            Some(mem)
-        }
-        Token::Ident(id) if id == "root" => {
-            it.next();
-            let mut mem = parse_scope_member(it).unwrap();
-            mem.1.vis = Visibility::Origin;
-            Some(mem)
-        }
-        Token::Ident(id) if id == "module" => {
-            it.next();
-            let mut mem = parse_scope_member(it).unwrap();
-            mem.1.vis = Visibility::Module;
-            Some(mem)
-        }
-        Token::Ident(id) if id == "private" => {
-            it.next();
-            let mut mem = parse_scope_member(it).unwrap();
-            mem.1.vis = Visibility::Private;
-            Some(mem)
-        }
-        Token::Ident(id) if id == "generic" => {
-            todo!("generic declaration")
-        }
-        Token::Sigil('#') => {
-            it.next();
-            let attrs = parse_attr_list(it);
-            let mut mem = parse_scope_member(it).unwrap();
-            mem.1.annotations = attrs;
-            Some(mem)
-        }
-        Token::Ident(id)
-            if id == "external" || id == "internal" || id == "const" || id == "weak" =>
-        {
-            let linkage = match &**id {
-                "external" => Linkage::External,
-                "internal" => Linkage::Internal,
-                "const" => Linkage::Constant,
-                "weak" => Linkage::Weak,
-                _ => unreachable!(),
-            };
-
-            it.next();
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "function" => {
-                    it.next();
-                    let name = parse_path(it);
-
-                    Some((name, parse_function_decl(it, linkage)))
-                }
-                Token::Ident(id) if id == "static" => todo!(),
-                tok => panic!("expected static or function, got {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "function" => {
-            let linkage = Linkage::External;
-            it.next();
-            let name = parse_path(it);
-
-            Some((name, parse_function_decl(it, linkage)))
-        }
-        Token::Ident(id) if id == "static" => {
-            it.next();
-            let _name = parse_path(it);
-            todo!()
-        }
-        Token::Ident(id) if id == "struct" => {
-            it.next();
-            let name = parse_path(it);
-
-            let aggr = parse_aggregate_body(it, AggregateKind::Struct);
-            if let Some(aggr) = aggr {
-                Some((
-                    name,
-                    ScopeMember {
-                        member_decl: MemberDeclaration::AggregateDefinition(aggr),
-                        ..ScopeMember::default()
-                    },
-                ))
-            } else {
-                Some((
-                    name,
-                    ScopeMember {
-                        member_decl: MemberDeclaration::OpaqueAggregate(AggregateKind::Struct),
-                        ..ScopeMember::default()
-                    },
-                ))
-            }
-        }
-        tok => panic!("unexpected token {:?}", tok),
-    }
-}
-
-pub fn parse_stack_items<I: Iterator<Item = Token>>(it: I) -> Vec<StackItem> {
-    let mut peekable = it.peekmore();
-    let mut ret = Vec::new();
-    loop {
-        match peekable.peek() {
-            Some(Token::Ident(id)) if id == "lvalue" => {
-                peekable.next();
-                ret.push(StackItem {
-                    ty: parse_type(&mut peekable).unwrap(),
-                    kind: xlang_struct::StackValueKind::LValue,
-                });
-            }
-            Some(_) => {
-                ret.push(StackItem {
-                    ty: parse_type(&mut peekable).unwrap(),
-                    kind: xlang_struct::StackValueKind::RValue,
-                });
-            }
-            None => break ret,
-        }
-        match peekable.next() {
-            Some(Token::Sigil(',')) => continue,
-            None => break ret,
-            Some(tok) => panic!("Unexpected token {:?}", tok),
-        }
-    }
-}
-
-pub fn parse_block<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> Block {
-    let mut items = Vec::new();
-    loop {
-        match it.peek() {
-            None => break Block { items },
-            Some(Token::Ident(id)) if id == "target" => {
-                it.next();
-                let target: u32 = match it.next().unwrap() {
-                    Token::Sigil('@') => match it.next().unwrap() {
-                        Token::IntLiteral(branch) => branch.try_into().unwrap(),
-                        tok => panic!("Unexpected token {:?}", tok),
-                    },
-                    tok => panic!("Unexpected token {:?}", tok),
-                };
-
-                match it.next().unwrap() {
-                    Token::Group(Group::Bracket(group)) => items.push(BlockItem::Target {
-                        num: target,
-                        stack: parse_stack_items(group.into_iter()),
-                    }),
-                    tok => panic!("Unexpected token {:?}", tok),
-                }
-            }
-            Some(_) => items.push(BlockItem::Expr(parse_expr(it))),
-        }
-    }
-}
-
-fn literal_to_xir_bytes(s: &str) -> Result<String, Vec<u8>> {
-    let mut buf = Vec::with_capacity(s.len());
-    let mut has_hex_escapes = false;
-
-    let mut chars = s.chars();
-
-    while let Some(c) = chars.next() {
-        if c == '\\' {
-            match chars.next().unwrap() {
-                'n' => buf.push(b'\n'),
-                'r' => buf.push(b'\r'),
-                't' => buf.push(b'\t'),
-                'x' => {
-                    has_hex_escapes = true;
-                    let a1 = chars.next().unwrap();
-                    let a2 = chars.next().unwrap();
-                    assert!(a1.is_ascii_hexdigit() && a2.is_ascii_hexdigit());
-                    let val = (a1.to_digit(16).unwrap() << 4) | (a2.to_digit(16).unwrap());
-                    buf.push(val.try_into().unwrap());
-                }
-                'u' => {
-                    todo!("Unicode escapes")
-                }
-                '\\' => buf.push(b'\\'),
-                '"' => buf.push(b'"'),
-                '\'' => buf.push(b'\''),
-                c => panic!("Invalid escape sequence \\{}", c),
-            }
-        } else {
-            buf.extend_from_slice(c.encode_utf8(&mut [0u8; 4]).as_bytes());
-        }
-    }
-
-    if has_hex_escapes {
-        // Validate the UTF-8
-        String::from_utf8(buf).map_err(FromUtf8Error::into_bytes)
-    } else {
-        // Else, we have to use unsafe
-        // SAFETY:
-        // The bytes have come from a string, and are UTF-8 validated
-        // As no hex escapes are included, arbitrary bytes couldn't have found there way in
-        Ok(unsafe { String::from_utf8_unchecked(buf) })
-    }
-}
-
-#[allow(clippy::cognitive_complexity)] // TODO: refactor
-#[allow(clippy::match_wild_err_arm)] // TODO: find a better solution
-#[allow(clippy::too_many_lines)] // TODO: refactor
-pub fn parse_const<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> Value {
-    match it.peek().unwrap() {
-        Token::Ident(id) if id == "undef" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "uninit" => Value::Uninitialized(parse_type(it).unwrap()),
-                Token::Ident(id) if id == "invalid" => Value::Invalid(parse_type(it).unwrap()),
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "global_address" => {
-            it.next();
-            Value::GlobalAddress {
-                ty: Type::Null,
-                item: parse_path(it),
-            }
-        }
-        Token::Ident(id) if id == "label_address" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::Sigil('@') => {}
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-
-            match it.next().unwrap() {
-                Token::IntLiteral(n) => Value::LabelAddress(n.try_into().unwrap()),
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        _ => {
-            let ty = parse_type(it).unwrap();
-            match it.next().unwrap() {
-                Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                    Ok(utf8) => Value::String {
-                        encoding: StringEncoding::Utf8,
-                        utf8,
-                        ty,
-                    },
-                    Err(content) => Value::ByteString { content },
-                },
-                Token::Ident(id) if id == "utf8" => match it.next().unwrap() {
-                    Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                        Ok(utf8) => Value::String {
-                            encoding: StringEncoding::Utf8,
-                            utf8,
-                            ty,
-                        },
-                        Err(_) => panic!("Required unicode string for encoding {}", id),
-                    },
-                    tok => panic!("Unexpected Token {:?}", tok),
-                },
-                Token::Ident(id) if id == "utf16le" => match it.next().unwrap() {
-                    Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                        Ok(utf8) => Value::String {
-                            encoding: StringEncoding::Utf16LE,
-                            utf8,
-                            ty,
-                        },
-                        Err(_) => panic!("Required unicode string for encoding {}", id),
-                    },
-                    tok => panic!("Unexpected Token {:?}", tok),
-                },
-                Token::Ident(id) if id == "utf16be" => match it.next().unwrap() {
-                    Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                        Ok(utf8) => Value::String {
-                            encoding: StringEncoding::Utf16BE,
-                            utf8,
-                            ty,
-                        },
-                        Err(_) => panic!("Required unicode string for encoding {}", id),
-                    },
-                    tok => panic!("Unexpected Token {:?}", tok),
-                },
-                Token::Ident(id) if id == "utf32le" => match it.next().unwrap() {
-                    Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                        Ok(utf8) => Value::String {
-                            encoding: StringEncoding::Utf32LE,
-                            utf8,
-                            ty,
-                        },
-                        Err(_) => panic!("Required unicode string for encoding {}", id),
-                    },
-                    tok => panic!("Unexpected Token {:?}", tok),
-                },
-                Token::Ident(id) if id == "utf32be" => match it.next().unwrap() {
-                    Token::StringLiteral(utf8) => match literal_to_xir_bytes(&utf8) {
-                        Ok(utf8) => Value::String {
-                            encoding: StringEncoding::Utf32BE,
-                            utf8,
-                            ty,
-                        },
-                        Err(_) => panic!("Required unicode string for encoding {}", id),
-                    },
-                    tok => panic!("Unexpected Token {:?}", tok),
-                },
-                Token::IntLiteral(i) => match ty {
-                    Type::Scalar(ty) => Value::Integer { ty, val: i },
-                    ty => panic!("Unexpected type {:?} expected a scalar type", ty),
-                },
-                Token::Sigil('-') => match it.next().unwrap() {
-                    Token::IntLiteral(i) => match ty {
-                        Type::Scalar(ty) => Value::Integer {
-                            ty,
-                            val: i.wrapping_neg(),
-                        },
-                        ty => panic!("Unexpected type {:?} expected a scalar type", ty),
-                    },
-                    tok => panic!("Unexpected token {:?}", tok),
-                },
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-    }
-}
-
-pub fn parse_access_class<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> AccessClass {
-    let mut acc = AccessClass::Normal;
-    loop {
-        match it.peek() {
-            Some(Token::Ident(id)) if id == "atomic" => {
-                if acc & AccessClass::ATOMIC_MASK != AccessClass::Normal {
-                    panic!("Invalid access class, at most one atomic mode may be present");
-                }
-                it.next();
-                match it.next().unwrap() {
-                    Token::Ident(id) if id == "relaxed" => {
-                        acc |= AccessClass::AtomicRelaxed;
-                    }
-                    Token::Ident(id) if id == "release" => {
-                        acc |= AccessClass::AtomicRelease;
-                    }
-                    Token::Ident(id) if id == "acquire" => {
-                        acc |= AccessClass::AtomicAcquire;
-                    }
-                    Token::Ident(id) if id == "acq_rel" => {
-                        acc |= AccessClass::AtomicAcqRel;
-                    }
-                    Token::Ident(id) if id == "seq_cst" => {
-                        acc |= AccessClass::AtomicSeqCst;
-                    }
-                    tok => panic!("Unexpected token {:?}", tok),
-                }
-            }
-            Some(Token::Ident(id)) if id == "freeze" => {
-                it.next();
-                acc |= AccessClass::Freeze;
-            }
-            Some(Token::Ident(id)) if id == "volatile" => {
-                acc |= AccessClass::Volatile;
-                it.next();
-            }
-            Some(Token::Ident(id)) if id == "nontemporal" => {
-                it.next();
-                acc |= AccessClass::Nontemporal;
-            }
-            _ => break acc,
-        }
-    }
-}
-
-#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
-pub fn parse_expr<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> Expr {
-    match it.peek().unwrap() {
-        Token::Ident(id) if id == "const" => {
-            it.next();
-            Expr::Const(parse_const(it))
-        }
-        Token::Ident(id) if id == "call" => {
-            it.next();
-            Expr::CallFunction(parse_function_type(it))
-        }
-        Token::Ident(id) if id == "pop" => {
-            it.next();
-            match it.peek() {
-                Some(Token::IntLiteral(i)) => {
-                    let val = *i;
-                    it.next();
-                    Expr::Pop(val.try_into().unwrap())
-                }
-                _ => Expr::Pop(1),
-            }
-        }
-        Token::Ident(id) if id == "exit" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::IntLiteral(values) => Expr::Exit {
-                    values: values.try_into().unwrap(),
-                },
-                tok => panic!("Unexpected Token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "branch" => {
-            it.next();
-            let cond = match it.next().unwrap() {
-                Token::Ident(id) if id == "always" => BranchCondition::Always,
-                Token::Ident(id) if id == "never" => BranchCondition::Never,
-                Token::Ident(id) if id == "equal" => BranchCondition::Equal,
-                Token::Ident(id) if id == "not_equal" => BranchCondition::NotEqual,
-                Token::Ident(id) if id == "less" => BranchCondition::Less,
-                Token::Ident(id) if id == "greater" => BranchCondition::Greater,
-                Token::Ident(id) if id == "less_equal" => BranchCondition::LessEqual,
-                Token::Ident(id) if id == "greater_equal" => BranchCondition::GreaterEqual,
-                Token::Ident(id) if id == "indirect" => return Expr::BranchIndirect,
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-            match it.next().unwrap() {
-                Token::Sigil('@') => match it.next().unwrap() {
-                    Token::IntLiteral(target) => Expr::Branch {
-                        cond,
-                        target: target.try_into().unwrap(),
-                    },
-                    tok => panic!("Unexpected token {:?}", tok),
-                },
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "dup" => {
-            it.next();
-            let n = match it.peek() {
-                Some(Token::IntLiteral(n)) => {
-                    let n = u32::try_from(*n).unwrap();
-                    it.next();
-                    n
-                }
-                _ => 1,
-            };
-            Expr::Dup(n)
-        }
-        Token::Ident(id) if id == "pivot" => {
-            it.next();
-            let n = match it.next().unwrap() {
-                Token::IntLiteral(n) => u32::try_from(n).unwrap(),
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-            let m = match it.peek() {
-                Some(Token::IntLiteral(n)) => {
-                    let n = u32::try_from(*n).unwrap();
-                    it.next();
-                    n
-                }
-                _ => n,
-            };
-            Expr::Pivot(n, m)
-        }
-        Token::Ident(id)
-            if id == "add"
-                || id == "sub"
-                || id == "mul"
-                || id == "div"
-                || id == "mod"
-                || id == "lsh"
-                || id == "rsh"
-                || id == "bxor"
-                || id == "bor"
-                || id == "band"
-                || id == "cmp"
-                || id == "cmp_lt"
-                || id == "cmp_gt"
-                || id == "cmp_eq"
-                || id == "cmp_ne"
-                || id == "cmp_le"
-                || id == "cmp_ge"
-                || id == "cmp_int" =>
-        {
-            let op = match it.next().unwrap() {
-                Token::Ident(id) if id == "add" => BinaryOp::Add,
-                Token::Ident(id) if id == "sub" => BinaryOp::Sub,
-                Token::Ident(id) if id == "mul" => BinaryOp::Mul,
-                Token::Ident(id) if id == "div" => BinaryOp::Div,
-                Token::Ident(id) if id == "mod" => BinaryOp::Mod,
-                Token::Ident(id) if id == "lsh" => BinaryOp::Lsh,
-                Token::Ident(id) if id == "rsh" => BinaryOp::Rsh,
-                Token::Ident(id) if id == "band" => BinaryOp::BitAnd,
-                Token::Ident(id) if id == "bor" => BinaryOp::BitOr,
-                Token::Ident(id) if id == "bxor" => BinaryOp::BitXor,
-                Token::Ident(id) if id == "cmp" => BinaryOp::Cmp,
-                Token::Ident(id) if id == "cmp_int" => BinaryOp::CmpInt,
-                Token::Ident(id) if id == "cmp_lt" => BinaryOp::CmpLt,
-                Token::Ident(id) if id == "cmp_gt" => BinaryOp::CmpGt,
-                Token::Ident(id) if id == "cmp_eq" => BinaryOp::CmpEq,
-                Token::Ident(id) if id == "cmp_ne" => BinaryOp::CmpNe,
-                Token::Ident(id) if id == "cmp_le" => BinaryOp::CmpLe,
-                Token::Ident(id) if id == "cmp_ge" => BinaryOp::CmpGe,
-                _ => unreachable!(),
-            };
-            let overflow = match it.peek() {
-                Some(Token::Ident(id)) if id == "trap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                Some(Token::Ident(id)) if id == "wrap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                Some(Token::Ident(id)) if id == "checked" => {
-                    it.next();
-                    OverflowBehaviour::Checked
-                }
-                Some(Token::Ident(id)) if id == "unchecked" => {
-                    it.next();
-                    OverflowBehaviour::Unchecked
-                }
-                _ => OverflowBehaviour::Wrap,
-            };
-            Expr::BinaryOp(op, overflow)
-        }
-        Token::Ident(id) if id == "not" || id == "neg" || id == "bnot" => {
-            let op = match it.next().unwrap() {
-                Token::Ident(id) if id == "not" => UnaryOp::LogicNot,
-                Token::Ident(id) if id == "bnot" => UnaryOp::BitNot,
-                Token::Ident(id) if id == "neg" => UnaryOp::Minus,
-                _ => unreachable!(),
-            };
-            let overflow = match it.peek() {
-                Some(Token::Ident(id)) if id == "trap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                Some(Token::Ident(id)) if id == "wrap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                Some(Token::Ident(id)) if id == "checked" => {
-                    it.next();
-                    OverflowBehaviour::Checked
-                }
-                Some(Token::Ident(id)) if id == "unchecked" => {
-                    it.next();
-                    OverflowBehaviour::Unchecked
-                }
-                _ => OverflowBehaviour::Wrap,
-            };
-
-            Expr::UnaryOp(op, overflow)
-        }
-        Token::Ident(id) if id == "local" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::Ident(id) if id.starts_with('_') => {
-                    let n = id[1..].parse::<u32>().unwrap();
-                    Expr::Local(n)
-                }
-                tok => panic!("Unexpected Token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "assign" => {
-            it.next();
-            let acc = parse_access_class(it);
-            Expr::Assign(acc)
-        }
-        Token::Ident(id) if id == "as_rvalue" => {
-            it.next();
-            let acc = parse_access_class(it);
-            Expr::AsRValue(acc)
-        }
-        Token::Ident(id) if id == "switch" => {
-            it.next();
-
-            let switch = match it.next().unwrap() {
-                Token::Ident(id) if id == "hash" => {
-                    let mut cases = Vec::new();
-                    let mut default = None;
-                    loop {
-                        match it.peek().unwrap() {
-                            Token::Ident(id) if id == "case" => {
-                                it.next();
-                                let val = parse_const(it);
-
-                                match it.next().unwrap() {
-                                    Token::Sigil(':') => {}
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-                                match it.next().unwrap() {
-                                    Token::Sigil('@') => {}
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-
-                                let targ = match it.next().unwrap() {
-                                    Token::IntLiteral(n) => u32::try_from(n).unwrap(),
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                };
-                                cases.push(Pair(val, targ));
-                            }
-                            Token::Ident(id) if id == "default" => {
-                                it.next();
-
-                                match it.next().unwrap() {
-                                    Token::Sigil(':') => {}
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-                                match it.next().unwrap() {
-                                    Token::Sigil('@') => {}
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-
-                                match it.next().unwrap() {
-                                    Token::IntLiteral(n) => {
-                                        default = Some(u32::try_from(n).unwrap());
-                                    }
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-                            }
-                            _ => {
-                                break Switch::Hash(HashSwitch {
-                                    cases,
-                                    default: default.unwrap(),
-                                })
-                            }
-                        }
-                    }
-                }
-                Token::Ident(id) if id == "linear" => {
-                    let ty = parse_type(it).unwrap();
-                    let min = match it.peek().unwrap() {
-                        Token::Ident(id) if id == "min" => {
-                            it.next();
-                            match it.next().unwrap() {
-                                Token::IntLiteral(n) => n,
-                                Token::Sigil('-') => match it.next().unwrap() {
-                                    Token::IntLiteral(n) => n.wrapping_neg(),
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                },
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-                        }
-                        _ => 0,
-                    };
-                    let scale = match it.peek().unwrap() {
-                        Token::Ident(id) if id == "min" => {
-                            it.next();
-                            match it.next().unwrap() {
-                                Token::IntLiteral(n) => u32::try_from(n).unwrap(),
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-                        }
-                        _ => 1,
-                    };
-                    let default = match it.peek().unwrap() {
-                        Token::Ident(id) if id == "default" => {
-                            it.next();
-
-                            match it.next().unwrap() {
-                                Token::Sigil('@') => {}
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-
-                            match it.next().unwrap() {
-                                Token::IntLiteral(n) => u32::try_from(n).unwrap(),
-                                tok => panic!("Unexpected token {:?}", tok),
-                            }
-                        }
-                        tok => panic!("Unexpected token {:?}", tok),
-                    };
-
-                    let mut cases = Vec::new();
-
-                    loop {
-                        match it.peek().unwrap() {
-                            Token::Sigil('@') => {
-                                it.next();
-                                match it.next().unwrap() {
-                                    Token::IntLiteral(n) => cases.push(u32::try_from(n).unwrap()),
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                }
-                            }
-                            _ => {
-                                break Switch::Linear(LinearSwitch {
-                                    ty,
-                                    min,
-                                    scale,
-                                    default,
-                                    cases,
-                                })
-                            }
-                        }
-                    }
-                }
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "end" => {}
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "switch" => Expr::Switch(switch),
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "convert" => {
-            it.next();
-            let str = match it.next().unwrap() {
-                Token::Ident(id) if id == "weak" => ConversionStrength::Weak,
-                Token::Ident(id) if id == "strong" => ConversionStrength::Strong,
-                Token::Ident(id) if id == "reinterpret" => ConversionStrength::Reinterpret,
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-            Expr::Convert(str, parse_type(it).unwrap())
-        }
-        Token::Ident(id) if id == "aggregate" => {
-            it.next();
-            let ty = parse_type(it).unwrap();
-            let mut fields = Vec::new();
-            match it.next().unwrap() {
-                Token::Group(Group::Braces(inner)) => {
-                    let mut it = inner.into_iter().peekmore();
-                    loop {
-                        match it.next() {
-                            Some(Token::Ident(id)) => fields.push(id),
-                            Some(Token::IntLiteral(lit)) => {
-                                fields.push(xlang::abi::format!("{}", lit));
-                            } // because product types
-                            None => break,
-                            Some(tok) => panic!("Unexpected token {:?}", tok),
-                        }
-                        match it.next() {
-                            Some(Token::Sigil(',')) => continue,
-                            None => break,
-                            Some(tok) => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                }
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-
-            Expr::Aggregate(AggregateCtor { ty, fields })
-        }
-        Token::Ident(id) if id == "member" => {
-            it.next();
-
-            let indirect = matches!(it.peek().unwrap(), Token::Ident(id) if id == "indirect");
-
-            let id = parse_member_name(it);
-
-            if indirect {
-                Expr::MemberIndirect(id)
-            } else {
-                Expr::Member(id)
-            }
-        }
-        Token::Ident(id) if id == "asm" => {
-            it.next();
-
-            let mut opts = AsmOptions::empty();
-            let mut syntax = None;
-            let mut clobbers = Vec::new();
-            let mut inputs = Vec::new();
-            let mut outputs = Vec::new();
-            let mut access_class = AccessClass::Normal;
-            let mut targets = Vec::new();
-
-            loop {
-                match it.peek().unwrap() {
-                    Token::Ident(id) if id == "nomem" => {
-                        it.next();
-                        opts |= AsmOptions::NOMEM;
-                    }
-                    Token::Ident(id) if id == "nostack" => {
-                        it.next();
-                        opts |= AsmOptions::NOSTACK;
-                    }
-                    Token::Ident(id) if id == "pure" => {
-                        it.next();
-                        opts |= AsmOptions::PURE;
-                    }
-                    Token::Ident(id) if id == "transparent" => {
-                        it.next();
-                        opts |= AsmOptions::TRANSPARENT;
-                    }
-                    Token::Ident(id) if id == "noexit" => {
-                        it.next();
-                        opts |= AsmOptions::NOEXIT;
-                    }
-                    Token::Ident(id) if id == "syntax" => {
-                        it.next();
-                        match it.next().unwrap() {
-                            Token::Group(Group::Parenthesis(inner)) => {
-                                let mut it = inner.into_iter().peekmore();
-                                syntax = Some(match it.next().unwrap() {
-                                    Token::Ident(id) => id,
-                                    Token::StringLiteral(st) => st,
-                                    tok => panic!("Unexpected token {:?}", tok),
-                                });
-                            }
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                    Token::Ident(id) if id == "class" => {
-                        it.next();
-                        match it.next().unwrap() {
-                            Token::Group(Group::Parenthesis(inner)) => {
-                                let mut it = inner.into_iter().peekmore();
-                                access_class = parse_access_class(&mut it);
-                            }
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                    _ => break,
-                }
-            }
-
-            let asm_str = match it.next().unwrap() {
-                Token::StringLiteral(lit) => literal_to_xir_bytes(&lit).unwrap(),
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-
-            loop {
-                match it.peek().unwrap() {
-                    Token::Ident(id) if id == "goto" => {
-                        it.next();
-                        match it.next().unwrap() {
-                            Token::Group(Group::Parenthesis(inner)) => {
-                                let mut it = inner.into_iter().peekmore();
-                                loop {
-                                    match it.next() {
-                                        Some(Token::Sigil('@')) => {}
-                                        None => break,
-                                        Some(tok) => panic!("Unexpected token {:?}", tok),
-                                    }
-                                    match it.next().unwrap() {
-                                        Token::IntLiteral(n) => {
-                                            targets.push(u32::try_from(n).unwrap());
-                                        }
-                                        tok => panic!("Unexpected token {:?}", tok),
-                                    }
-
-                                    match it.next() {
-                                        Some(Token::Sigil(',')) => continue,
-                                        None => break,
-                                        Some(tok) => panic!("Unexpected token {:?}", tok),
-                                    }
-                                }
-                            }
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                    Token::Ident(id) if id == "clobbers" => {
-                        it.next();
-                        match it.next().unwrap() {
-                            Token::Group(Group::Parenthesis(inner)) => {
-                                let mut it = inner.into_iter().peekmore();
-                                loop {
-                                    match parse_asm_constraint(&mut it) {
-                                        Some(constraint) => clobbers.push(constraint),
-                                        None => break,
-                                    }
-
-                                    match it.next() {
-                                        Some(Token::Sigil(',')) => continue,
-                                        None => break,
-                                        Some(tok) => panic!("Unexpected token {:?}", tok),
-                                    }
-                                }
-                            }
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                    _ => break,
-                }
-            }
-
-            match it.next().unwrap() {
-                Token::Group(Group::Bracket(inner)) => {
-                    let mut it = inner.into_iter().peekmore();
-                    loop {
-                        match parse_asm_constraint(&mut it) {
-                            Some(constraint) => inputs.push(constraint),
-                            None => break,
-                        }
-
-                        match it.next() {
-                            Some(Token::Sigil(',')) => continue,
-                            None => break,
-                            Some(tok) => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                }
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-            match it.next().unwrap() {
-                Token::Group(Group::Bracket(inner)) => {
-                    let mut it = inner.into_iter().peekmore();
-                    loop {
-                        let late = match it.peek() {
-                            Some(Token::Ident(id)) if id == "late" => {
-                                it.next();
-                                true
-                            }
-                            None => break,
-                            Some(_) => false,
-                        };
-                        let constraint = parse_asm_constraint(&mut it).unwrap();
-
-                        match it.next().unwrap() {
-                            Token::Sigil('=') => {}
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-
-                        match it.next().unwrap() {
-                            Token::Sigil('>') => {}
-                            tok => panic!("Unexpected token {:?}", tok),
-                        }
-
-                        let ty = parse_type(&mut it).unwrap();
-
-                        let output = AsmOutput {
-                            late,
-                            constraint,
-                            ty,
-                        };
-
-                        outputs.push(output);
-
-                        match it.next() {
-                            Some(Token::Sigil(',')) => continue,
-                            None => break,
-                            Some(tok) => panic!("Unexpected token {:?}", tok),
-                        }
-                    }
-                }
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-
-            let syntax = syntax.unwrap_or_else(|| "".into());
-
-            let ret = Expr::Asm(AsmExpr {
-                opts,
-                syntax,
-                access_class,
-                string: asm_str,
-                clobbers,
-                targets,
-                inputs,
-                outputs,
-            });
-
-            eprintln!("Parsed asm-expr {:?}", ret);
-            ret
-        }
-        Token::Ident(id) if id == "begin" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "storage" => match it.next().unwrap() {
-                    Token::Ident(id) if id.starts_with('_') => {
-                        Expr::BeginStorage(id[1..].parse().unwrap())
-                    }
-                    tok => panic!("Unexpected token {:?}", tok),
-                },
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "end" => {
-            it.next();
-            match it.next().unwrap() {
-                Token::Ident(id) if id == "storage" => match it.next().unwrap() {
-                    Token::Ident(id) if id.starts_with('_') => {
-                        Expr::EndStorage(id[1..].parse().unwrap())
-                    }
-                    tok => panic!("Unexpected token {:?}", tok),
-                },
-                tok => panic!("Unexpected token {:?}", tok),
-            }
-        }
-        Token::Ident(id) if id == "compound_assign" => {
-            it.next();
-            let op = match it.next().unwrap() {
-                Token::Ident(id) if id == "add" => BinaryOp::Add,
-                Token::Ident(id) if id == "sub" => BinaryOp::Sub,
-                Token::Ident(id) if id == "mul" => BinaryOp::Mul,
-                Token::Ident(id) if id == "div" => BinaryOp::Div,
-                Token::Ident(id) if id == "mod" => BinaryOp::Mod,
-                Token::Ident(id) if id == "band" => BinaryOp::BitAnd,
-                Token::Ident(id) if id == "bor" => BinaryOp::BitOr,
-                Token::Ident(id) if id == "bxor" => BinaryOp::BitXor,
-                Token::Ident(id) if id == "lsh" => BinaryOp::Lsh,
-                Token::Ident(id) if id == "rsh" => BinaryOp::Rsh,
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-
-            let v = match it.peek() {
-                Some(Token::Ident(id)) if id == "wrap" => {
-                    it.next();
-                    OverflowBehaviour::Wrap
-                }
-                Some(Token::Ident(id)) if id == "checked" => {
-                    it.next();
-                    OverflowBehaviour::Checked
-                }
-                Some(Token::Ident(id)) if id == "saturate" => {
-                    it.next();
-                    OverflowBehaviour::Saturate
-                }
-                Some(Token::Ident(id)) if id == "unchecked" => {
-                    it.next();
-                    OverflowBehaviour::Unchecked
-                }
-                Some(Token::Ident(id)) if id == "trap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                _ => OverflowBehaviour::Wrap,
-            };
-
-            let acc = parse_access_class(it);
-            Expr::CompoundAssign(op, v, acc)
-        }
-        Token::Ident(id) if id == "fetch_assign" => {
-            it.next();
-            let op = match it.next().unwrap() {
-                Token::Ident(id) if id == "add" => BinaryOp::Add,
-                Token::Ident(id) if id == "sub" => BinaryOp::Sub,
-                Token::Ident(id) if id == "mul" => BinaryOp::Mul,
-                Token::Ident(id) if id == "div" => BinaryOp::Div,
-                Token::Ident(id) if id == "mod" => BinaryOp::Mod,
-                Token::Ident(id) if id == "band" => BinaryOp::BitAnd,
-                Token::Ident(id) if id == "bor" => BinaryOp::BitOr,
-                Token::Ident(id) if id == "bxor" => BinaryOp::BitXor,
-                Token::Ident(id) if id == "lsh" => BinaryOp::Lsh,
-                Token::Ident(id) if id == "rsh" => BinaryOp::Rsh,
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-
-            let v = match it.peek() {
-                Some(Token::Ident(id)) if id == "wrap" => {
-                    it.next();
-                    OverflowBehaviour::Wrap
-                }
-                Some(Token::Ident(id)) if id == "checked" => {
-                    it.next();
-                    OverflowBehaviour::Checked
-                }
-                Some(Token::Ident(id)) if id == "saturate" => {
-                    it.next();
-                    OverflowBehaviour::Saturate
-                }
-                Some(Token::Ident(id)) if id == "unchecked" => {
-                    it.next();
-                    OverflowBehaviour::Unchecked
-                }
-                Some(Token::Ident(id)) if id == "trap" => {
-                    it.next();
-                    OverflowBehaviour::Trap
-                }
-                _ => OverflowBehaviour::Wrap,
-            };
-
-            let acc = parse_access_class(it);
-            Expr::FetchAssign(op, v, acc)
-        }
-        Token::Ident(id) if id == "select" => {
-            it.next();
-            let val = match it.next().unwrap() {
-                Token::IntLiteral(n) => n as u32,
-                tok => panic!("Unexpected token {:?}", tok),
-            };
-            Expr::Select(val)
-        }
-        Token::Ident(id) if id == "indirect" => {
-            it.next();
-            Expr::Indirect
-        }
-        tok => todo!("{:?}", tok),
-    }
-}
-
-pub fn parse_asm_constraint<I: Iterator<Item = Token>>(
-    it: &mut PeekMoreIterator<I>,
-) -> Option<AsmConstraint> {
-    match it.next()? {
-        Token::Ident(id) if id == "memory" => Some(AsmConstraint::Memory),
-        Token::StringLiteral(id) if id == "memory" => Some(AsmConstraint::Memory),
-        Token::Ident(id) if id == "cc" => Some(AsmConstraint::CC),
-        Token::StringLiteral(id) if id == "cc" => Some(AsmConstraint::Memory),
-        Token::Ident(id) => Some(AsmConstraint::ArchConstraint(id)),
-        Token::StringLiteral(id) => Some(AsmConstraint::ArchConstraint(
-            literal_to_xir_bytes(&id).unwrap(),
-        )),
-        Token::Group(Group::Parenthesis(inner)) => {
-            let mut it = inner.into_iter().peekmore();
-            let constraint = parse_asm_constraint(&mut it).unwrap();
-            if let Some(tok) = it.next() {
-                panic!("Unexpected token {:?}", tok);
-            }
-
-            Some(constraint)
-        }
-        tok => panic!("Unexpected token {:?}", tok),
-    }
-}
-
-pub fn parse_member_name<I: Iterator<Item = Token>>(it: &mut PeekMoreIterator<I>) -> String {
-    match it.next().unwrap() {
-        Token::Ident(id) => id,
-        Token::IntLiteral(n) => xlang::abi::format!("{}", n),
-        Token::Group(Group::Parenthesis(inner)) => {
-            let mut it = inner.into_iter().peekmore();
-            parse_member_name(&mut it)
-        }
-        tok => panic!("Unexpected token {:?}", tok),
-    }
-}
-
-pub fn parse_file<I: Iterator<Item = Token>>(it: I) -> File {
-    let mut peekable = it.peekmore();
-
-    File {
-        target: String::new(),
-        root: Scope {
-            annotations: AnnotatedElement::default(),
-            members: core::iter::from_fn(move || parse_scope_member(&mut peekable)).collect(),
-        },
-    }
-}
diff --git a/xlang/xlang_abi/src/io.rs b/xlang/xlang_abi/src/io.rs
index cc070ea7..002feb18 100644
--- a/xlang/xlang_abi/src/io.rs
+++ b/xlang/xlang_abi/src/io.rs
@@ -231,7 +231,7 @@ pub trait IntoChars {
 }
 
 /// An Iterator over the chars of `R`
-pub struct ReadIntoChars<R: Read> {
+pub struct ReadIntoChars<R> {
     // Why is there a trait bound here
     buf: Vec<u8>,
     pos: usize,
diff --git a/xlang/xlang_abi/src/ops.rs b/xlang/xlang_abi/src/ops.rs
index 980538d8..b17ffefd 100644
--- a/xlang/xlang_abi/src/ops.rs
+++ b/xlang/xlang_abi/src/ops.rs
@@ -235,6 +235,44 @@ macro_rules! try_ {
 /// A type alias that changes the `Output` type of `R` to `T`
 pub type ChangeOutputType<R, T> = <<R as Try>::Residual as Residual<T>>::Try;
 
+/// Implement [`FromResidual`] of [`Yeet`] for this type, to support the [`yeet`] macro
+pub struct Yeet<T>(pub T);
+
+impl<T> FromResidual<Yeet<()>> for core::option::Option<T> {
+    fn from_residual(_: Yeet<()>) -> Self {
+        Self::None
+    }
+}
+
+impl<T> FromResidual<Yeet<()>> for crate::option::Option<T> {
+    fn from_residual(_: Yeet<()>) -> Self {
+        Self::None
+    }
+}
+
+impl<T, E> FromResidual<Yeet<E>> for core::result::Result<T, E> {
+    fn from_residual(res: Yeet<E>) -> Self {
+        Self::Err(res.0)
+    }
+}
+
+impl<T, E> FromResidual<Yeet<E>> for crate::result::Result<T, E> {
+    fn from_residual(res: Yeet<E>) -> Self {
+        Self::Err(res.0)
+    }
+}
+
+/// Yeets an expression, breaking out of a [`Try`] context with an explicit `None`/`Err`
+#[macro_export]
+macro_rules! yeet {
+    () => {
+        return $crate::ops::FromResidual::from_residual($crate::ops::Yeet(()))
+    };
+    ($e:expr) => {
+        return $crate::ops::FromResidual::from_residual($crate::ops::Yeet($e))
+    };
+}
+
 #[cfg(test)]
 mod test {
     use crate::prelude::v1::*;
diff --git a/xlang/xlang_abi/src/string.rs b/xlang/xlang_abi/src/string.rs
index c388f5f5..526410bf 100644
--- a/xlang/xlang_abi/src/string.rs
+++ b/xlang/xlang_abi/src/string.rs
@@ -7,6 +7,7 @@ use std::{
     ffi::OsStr,
     fmt::{Formatter, Write},
     hash::{Hash, Hasher},
+    iter::FromIterator,
     marker::PhantomData,
     ops::{Add, AddAssign},
     path::Path,
@@ -138,6 +139,23 @@ impl<A: Allocator> String<A> {
         self.push_str(c.encode_utf8(&mut [0u8; 4]));
     }
 
+    /// Pops the last character from the string
+    pub fn pop(&mut self) -> Option<char> {
+        let mut b = self.0.pop()?;
+        let mut val = 0;
+        while b & 0xC0 == 0x80 {
+            val |= (b & 0x3F) as u32;
+            val <<= 6;
+
+            b = self.0.pop().unwrap();
+        }
+        let bits = b.leading_ones();
+        val |= (b & (!0 >> bits)) as u32;
+
+        // SAFETY: the `String` is valid UTF-8 so we just decoded a valid `char`
+        Some(unsafe { char::from_u32_unchecked(val) })
+    }
+
     /// Converts a [`String`] into a [`crate::vec::Vec`] of UTF-8 bytes
     pub fn into_bytes(self) -> crate::vec::Vec<u8, A> {
         self.0
@@ -275,6 +293,37 @@ impl<A: Allocator> Write for String<A> {
     }
 }
 
+impl<A: Allocator> Extend<char> for String<A> {
+    fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T) {
+        let iter = iter.into_iter();
+        let (c_count, _) = iter.size_hint();
+        self.0.reserve(c_count);
+
+        for c in iter {
+            self.push(c)
+        }
+    }
+}
+
+impl<'a, A: Allocator> Extend<&'a str> for String<A> {
+    fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T) {
+        for s in iter {
+            self.push_str(s)
+        }
+    }
+}
+
+impl<I> FromIterator<I> for String
+where
+    String: Extend<I>,
+{
+    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
+        let mut st = String::new();
+        st.extend(iter);
+        st
+    }
+}
+
 /// Version of [`std::format`] that returns a [`String`]
 #[macro_export]
 macro_rules! format{
diff --git a/xlang/xlang_abi/src/traits.rs b/xlang/xlang_abi/src/traits.rs
index 7dc47db1..0cd67af5 100644
--- a/xlang/xlang_abi/src/traits.rs
+++ b/xlang/xlang_abi/src/traits.rs
@@ -48,7 +48,7 @@
 
 #![allow(clippy::borrow_as_ptr)]
 
-use core::marker::{PhantomData, Send, Sync};
+use core::marker::PhantomData;
 use std::{
     marker::PhantomPinned,
     ops::{Deref, DerefMut},
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index e98c7242..d432d286 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -2,7 +2,6 @@ use core::cell::Cell;
 
 use std::rc::Rc;
 
-use crate::expr::ValLocation;
 use crate::expr::*;
 use crate::mach::Machine;
 use crate::ty::TypeInformation;
diff --git a/xlang/xlang_frontend/Cargo.toml b/xlang/xlang_frontend/Cargo.toml
index 9ea2aecd..2f037e1b 100644
--- a/xlang/xlang_frontend/Cargo.toml
+++ b/xlang/xlang_frontend/Cargo.toml
@@ -6,4 +6,5 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-xlang = {path=".."}
\ No newline at end of file
+xlang = {path=".."}
+unicode-xid = {version = "0.2.4", features=["no_std"]}
\ No newline at end of file
diff --git a/xlang/xlang_frontend/src/iter.rs b/xlang/xlang_frontend/src/iter.rs
index a11e60dd..b69cbe1b 100644
--- a/xlang/xlang_frontend/src/iter.rs
+++ b/xlang/xlang_frontend/src/iter.rs
@@ -48,8 +48,8 @@ impl<I: Iterator> Iterator for PeekMoreIterator<I> {
 impl<I: FusedIterator> FusedIterator for PeekMoreIterator<I> {}
 
 impl<I: Iterator<Item = char>> PeekMoreIterator<Speekable<I>> {
-    pub fn last_pos(&self) -> Pos {
-        if let Some((pos, _)) = self.buf.front() {
+    pub fn last_pos(&mut self) -> Pos {
+        if let Some((pos, _)) = self.cursor() {
             *pos
         } else {
             self.inner.last_pos()
@@ -62,13 +62,17 @@ impl<I: Iterator<Item = char>> PeekMoreIterator<Speekable<I>> {
 }
 
 impl<I: Iterator> PeekMoreIterator<I> {
-    pub fn peek(&mut self) -> Option<&I::Item> {
-        if self.cursor == 0 {
-            self.cursor = 1;
+    fn cursor(&self) -> Option<&I::Item> {
+        if self.cursor != 0 && self.cursor <= self.buf.len() {
+            Some(&self.buf[self.cursor - 1])
+        } else {
+            None
         }
+    }
 
-        if self.cursor <= self.buf.len() {
-            Some(&self.buf[self.cursor - 1])
+    pub fn peek(&mut self) -> Option<&I::Item> {
+        if let Some(item) = self.cursor() {
+            Some(unsafe { &*(item as *const I::Item) })
         } else {
             let val = self.inner.next()?;
             self.buf.push_back(val);
@@ -107,9 +111,10 @@ impl<I: Iterator> PeekMoreIterator<I> {
     pub fn consume_peaked(&mut self) {
         if self.cursor == self.buf.len() {
             self.buf.clear();
+        } else {
+            drop(self.buf.drain(..(self.cursor.saturating_sub(1))));
         }
-        let count = self.cursor.saturating_sub(1);
-        drop(self.buf.drain(..count));
+
         self.cursor = 0;
         self.mark.clear();
     }
@@ -223,3 +228,97 @@ pub fn with_rewinder_accept_on_break<
         }
     }
 }
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum DecodeUtf8Error {
+    UnexpectedEof,
+    InvalidStartChar(u8),
+}
+
+#[derive(Debug, Clone)]
+pub struct DecodeUtf8<I>(I);
+
+impl<I> DecodeUtf8<I> {
+    pub const fn new(inner: I) -> Self {
+        Self(inner)
+    }
+
+    pub fn into_inner(self) -> I {
+        self.0
+    }
+}
+
+impl<I: Iterator<Item = u8>> Iterator for DecodeUtf8<I> {
+    type Item = Result<char, DecodeUtf8Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let b = self.0.next()?;
+        match b {
+            0x00..=0x7f => Some(Ok(b as char)),
+            0xC0..=0xDF => {
+                let n = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n & 0xC0) != 0x80 {
+                    return None;
+                }
+
+                let c = (((b & 0x1F) as u32) << 6) | (n & 0x3F) as u32;
+
+                char::from_u32(c).map(Ok)
+            }
+            0xE0..=0xEF => {
+                let n1 = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n1 & 0xC0) != 0x80 {
+                    return None;
+                }
+                let n2 = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n2 & 0xC0) != 0x80 {
+                    return None;
+                }
+
+                let c = (((b & 0x1F) as u32) << 12)
+                    | (((n1 & 0x3F) as u32) << 6)
+                    | ((n2 & 0x3F) as u32);
+                char::from_u32(c).map(Ok)
+            }
+            0xF0..=0xF7 => {
+                let n1 = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n1 & 0xC0) != 0x80 {
+                    return None;
+                }
+                let n2 = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n2 & 0xC0) != 0x80 {
+                    return None;
+                }
+                let n3 = match self.0.next() {
+                    Some(n) => n,
+                    None => return Some(Err(DecodeUtf8Error::UnexpectedEof)),
+                };
+                if (n3 & 0xC0) != 0x80 {
+                    return None;
+                }
+
+                let c = (((b & 0x1F) as u32) << 18)
+                    | (((n1 & 0x3F) as u32) << 12)
+                    | (((n2 & 0x3F) as u32) << 6)
+                    | ((n3 & 0x3F) as u32);
+                char::from_u32(c).map(Ok)
+            }
+            b => Some(Err(DecodeUtf8Error::InvalidStartChar(b))),
+        }
+    }
+}
diff --git a/xlang/xlang_frontend/src/lexer.rs b/xlang/xlang_frontend/src/lexer.rs
new file mode 100644
index 00000000..118a27f3
--- /dev/null
+++ b/xlang/xlang_frontend/src/lexer.rs
@@ -0,0 +1,662 @@
+use core::convert::Infallible;
+use core::hash::Hash;
+use std::ops::{
+    Bound, Range, RangeBounds, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+};
+
+use xlang::abi::string::String;
+use xlang::abi::{vec, vec::Vec};
+
+use crate::{
+    iter::{PeekMoreIterator, Peekmore},
+    span::{NoHygiene, Pos, Span, Spanned, Speekable, Speekerator},
+    symbol::Symbol,
+};
+
+use unicode_xid::UnicodeXID;
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct DefaultTy;
+
+#[derive(Debug)]
+pub enum Error {
+    UnexpectedEof(Pos),
+    UnrecognizedChar(char, Pos),
+    Custom(Pos, String),
+}
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+pub fn is_ident_start_unicode(c: char) -> bool {
+    c.is_xid_start()
+}
+
+pub fn is_ident_part_unicode(c: char) -> bool {
+    c.is_xid_continue()
+}
+
+pub fn is_ident_start_ascii(c: char) -> bool {
+    c.is_ascii_alphabetic()
+}
+
+pub fn is_ident_part_ascii(c: char) -> bool {
+    c.is_ascii_alphanumeric()
+}
+
+pub trait CharCount {
+    fn contains(&self, c: usize) -> bool;
+    fn end_bound(&self) -> Bound<&usize>;
+}
+
+impl CharCount for usize {
+    fn contains(&self, c: usize) -> bool {
+        c == *self
+    }
+
+    fn end_bound(&self) -> Bound<&usize> {
+        Bound::Included(self)
+    }
+}
+
+impl CharCount for Range<usize> {
+    fn contains(&self, c: usize) -> bool {
+        self.contains(&c)
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+impl CharCount for RangeTo<usize> {
+    fn contains(&self, c: usize) -> bool {
+        self.contains(&c)
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+impl CharCount for RangeFrom<usize> {
+    fn contains(&self, c: usize) -> bool {
+        self.contains(&c)
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+impl CharCount for RangeInclusive<usize> {
+    fn contains(&self, c: usize) -> bool {
+        self.contains(&c)
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+impl CharCount for RangeToInclusive<usize> {
+    fn contains(&self, c: usize) -> bool {
+        self.contains(&c)
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+impl CharCount for RangeFull {
+    fn contains(&self, _: usize) -> bool {
+        true
+    }
+    fn end_bound(&self) -> Bound<&usize> {
+        <Self as RangeBounds<usize>>::end_bound(&self)
+    }
+}
+
+pub struct HexEscape<C>(pub char, pub C);
+
+impl<R: CharCount> EscapeMatcher for HexEscape<R> {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool> {
+        if sel != self.0 {
+            return Ok(false);
+        }
+
+        let max = self.1.end_bound();
+        let mut counter = 0usize;
+
+        while let Some((pos, c)) = it.peek().copied() {
+            if !c.is_digit(16) {
+                if self.1.contains(counter) {
+                    return Ok(true);
+                } else {
+                    return Err(Error::UnrecognizedChar(c, pos));
+                }
+            }
+            counter += 1;
+            accepter.push(c);
+            it.next();
+            if !(Bound::Unbounded, max).contains(&counter) {
+                return Ok(true);
+            }
+        }
+
+        if self.1.contains(counter) {
+            Ok(true)
+        } else {
+            Err(Error::UnexpectedEof(it.last_pos()))
+        }
+    }
+}
+
+pub struct UnicodeEscapeRust<C>(pub char, pub C);
+
+impl<R: CharCount> EscapeMatcher for UnicodeEscapeRust<R> {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool> {
+        if sel != self.0 {
+            return Ok(false);
+        }
+
+        match it.next() {
+            Some((_, '{')) => accepter.push('{'),
+            Some((pos, c)) => return Err(Error::UnrecognizedChar(c, pos)),
+            None => return Err(Error::UnexpectedEof(it.last_pos())),
+        }
+
+        let max = self.1.end_bound();
+        let mut counter = 0usize;
+
+        while let Some((pos, c)) = it.peek().copied() {
+            if !c.is_digit(16) {
+                if self.1.contains(counter) {
+                    return Ok(true);
+                } else {
+                    return Err(Error::UnrecognizedChar(c, pos));
+                }
+            }
+            counter += 1;
+            if !(Bound::Unbounded, max).contains(&counter) {
+                return Ok(true);
+            }
+        }
+
+        if self.1.contains(counter) {
+            match it.next() {
+                Some((_, '{')) => accepter.push('}'),
+                Some((pos, c)) => return Err(Error::UnrecognizedChar(c, pos)),
+                None => return Err(Error::UnexpectedEof(it.last_pos())),
+            }
+            Ok(true)
+        } else {
+            Err(Error::UnexpectedEof(it.last_pos()))
+        }
+    }
+}
+
+pub trait EscapeMatcher {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool>;
+}
+
+impl EscapeMatcher for char {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool> {
+        Ok(sel == *self)
+    }
+}
+
+impl<E: EscapeMatcher> EscapeMatcher for &E {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool> {
+        (**self).try_match(sel, it, accepter)
+    }
+}
+
+impl<E: EscapeMatcher, const N: usize> EscapeMatcher for [E; N] {
+    fn try_match<I: Iterator<Item = char>>(
+        &self,
+        sel: char,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+        accepter: &mut String,
+    ) -> Result<bool> {
+        for e in self {
+            if e.try_match(sel, it, accepter)? {
+                return Ok(true);
+            }
+        }
+        return Ok(false);
+    }
+}
+
+macro_rules! impl_for_tuple{
+    ($($T:ident),* $(,)?) => {
+
+    impl<$($T: EscapeMatcher),*> EscapeMatcher for ($($T,)*){
+            #[allow(unused_variables)]
+            fn try_match<_I: Iterator<Item=char>>(&self, sel: char, it: &mut PeekMoreIterator<Speekable<_I>>, accepter: &mut String) -> Result<bool>{
+                let ($($T,)*) = self;
+
+                $({
+                    if EscapeMatcher::try_match($T, sel, it, accepter)?{
+                        return Ok(true)
+                    }
+                })*
+
+                Ok(false)
+            }
+        }
+    }
+}
+
+impl_for_tuple!();
+impl_for_tuple!(A);
+impl_for_tuple!(A, B);
+impl_for_tuple!(A, B, C);
+impl_for_tuple!(A, B, C, D);
+impl_for_tuple!(A, B, C, D, E);
+impl_for_tuple!(A, B, C, D, E, F);
+impl_for_tuple!(A, B, C, D, E, F, G);
+impl_for_tuple!(A, B, C, D, E, F, G, H);
+impl_for_tuple!(A, B, C, D, E, F, G, H, I);
+impl_for_tuple!(A, B, C, D, E, F, G, H, I, J);
+impl_for_tuple!(A, B, C, D, E, F, G, H, I, J, K);
+impl_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
+impl_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+
+pub fn parse_escape<I: Iterator<Item = char>, E: EscapeMatcher>(
+    it: &mut PeekMoreIterator<Speekable<I>>,
+    escapes: E,
+) -> Result<String> {
+    match it.next() {
+        Some((pos, c)) => {
+            let mut v = String::from(c);
+            if !escapes.try_match(c, it, &mut v)? {
+                Err(Error::UnrecognizedChar(c, pos))
+            } else {
+                Ok(v)
+            }
+        }
+        None => Err(Error::UnexpectedEof(it.last_pos())),
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum TokenType<IdTy, StrTy, CharTy = StrTy, O = Infallible> {
+    Eof,
+    Identifier(IdTy),
+    String(StrTy),
+    Char(CharTy),
+    Integer,
+    Float,
+    Punct,
+    Other(O),
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Token<IdTy, StrTy, CharTy = StrTy, O = Infallible> {
+    pub ty: TokenType<IdTy, StrTy, CharTy, O>,
+    pub body: Symbol,
+}
+
+pub type LToken<L> =
+    Token<<L as Lexer>::IdentTy, <L as Lexer>::StrTy, <L as Lexer>::CharTy, <L as Lexer>::OtherTy>;
+pub type LTokenType<L> = TokenType<
+    <L as Lexer>::IdentTy,
+    <L as Lexer>::StrTy,
+    <L as Lexer>::CharTy,
+    <L as Lexer>::OtherTy,
+>;
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Group<Lex, H = NoHygiene, GType = Infallible> {
+    pub ty: GType,
+    pub stream: Vec<Spanned<Lex, H>>,
+}
+
+pub enum Lexeme<L: Lexer> {
+    Token(LToken<L>),
+    Group(Group<Self, L::Hygiene, L::GroupType>),
+    Other(L::OtherLex),
+}
+
+impl<L: Lexer> Clone for Lexeme<L>
+where
+    LToken<L>: Clone,
+    L::GroupType: Clone,
+    L::OtherLex: Clone,
+    L::Hygiene: Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Lexeme::Token(tok) => Lexeme::Token(tok.clone()),
+            Lexeme::Group(group) => Lexeme::Group(group.clone()),
+            Lexeme::Other(other) => Self::Other(other.clone()),
+        }
+    }
+}
+
+impl<L: Lexer> PartialEq for Lexeme<L>
+where
+    LToken<L>: PartialEq,
+    L::GroupType: PartialEq,
+    L::OtherLex: PartialEq,
+    L::Hygiene: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Token(this), Self::Token(other)) => this == other,
+            (Self::Group(this), Self::Group(other)) => this == other,
+            (Self::Other(this), Self::Other(other)) => this == other,
+            _ => false,
+        }
+    }
+}
+
+impl<L: Lexer> Eq for Lexeme<L>
+where
+    LToken<L>: Eq,
+    L::GroupType: Eq,
+    L::OtherLex: Eq,
+    L::Hygiene: Eq,
+{
+}
+
+impl<L: Lexer> Hash for Lexeme<L>
+where
+    LToken<L>: Hash,
+    L::GroupType: Hash,
+    L::OtherLex: Hash,
+    L::Hygiene: Hash,
+{
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        let discrim = core::mem::discriminant(self);
+        discrim.hash(state);
+        match self {
+            Self::Token(this) => this.hash(state),
+            Self::Group(this) => this.hash(state),
+            Self::Other(this) => this.hash(state),
+        }
+    }
+}
+
+impl<L: Lexer> core::fmt::Debug for Lexeme<L>
+where
+    LToken<L>: core::fmt::Debug,
+    L::GroupType: core::fmt::Debug,
+    L::OtherLex: core::fmt::Debug,
+    L::Hygiene: core::fmt::Debug,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Lexeme::Token(this) => f.debug_tuple("Token").field(this).finish(),
+            Lexeme::Group(this) => f.debug_tuple("Group").field(this).finish(),
+            Lexeme::Other(this) => this.fmt(f),
+        }
+    }
+}
+
+pub trait Lexer {
+    type Hygiene: Default;
+    type IdentTy;
+    type StrTy;
+    type CharTy;
+    type OtherTy;
+    type GroupType;
+    type OtherLex;
+    fn is_ident_start(&self, c: char) -> bool;
+    fn is_ident_part(&self, c: char) -> bool;
+    fn ident_type(&self, id: &str) -> Self::IdentTy;
+    fn is_num_sep(&self, c: char) -> bool;
+    fn is_num_prefix_frag(&self, c: &str) -> bool;
+    fn is_num_prefix(&self, c: &str) -> Option<u32>;
+    fn check_valid_num<I: Iterator<Item = char>>(
+        &self,
+        c: &str,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+    ) -> Result<()>;
+    fn is_float_in_radix(&self, radix: u32) -> bool;
+    fn is_float_exp_char(&self, c: char, radix: u32) -> bool;
+    fn is_group_start(&self, c: char) -> Option<(Self::GroupType, char)>;
+    fn next_token_start<I: Iterator<Item = char>>(
+        &self,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+    ) -> Result<Option<(char, Pos)>>;
+    fn punct_list(&self) -> &[&str];
+    fn check_valid_punct<I: Iterator<Item = char>>(
+        &self,
+        c: &str,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+    ) -> Result<()>;
+    fn default_str_type(&self) -> Self::StrTy;
+    fn default_char_type(&self) -> Self::CharTy;
+    fn check_escape<I: Iterator<Item = char>>(
+        &self,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+    ) -> Result<String>;
+    fn parse_rest<I: Iterator<Item = char>>(
+        &self,
+        preceeding: Spanned<LToken<Self>, Self::Hygiene>,
+        it: &mut PeekMoreIterator<Speekable<I>>,
+    ) -> Result<Spanned<LToken<Self>, Self::Hygiene>> {
+        Ok(preceeding)
+    }
+}
+
+fn do_lexeme_in_group<L: Lexer, I: Iterator<Item = char>>(
+    lex: &L,
+    iter: &mut PeekMoreIterator<Speekable<I>>,
+    end_char: Option<char>,
+) -> Result<Option<Spanned<Lexeme<L>, L::Hygiene>>> {
+    let (c, pos) = match lex.next_token_start(iter)? {
+        Some((c, pos)) => (c, pos),
+        None => {
+            if end_char.is_some() {
+                return Err(Error::UnexpectedEof(iter.last_pos()));
+            } else {
+                return Ok(None);
+            }
+        }
+    };
+
+    if Some(c) == end_char {
+        return Ok(None);
+    }
+
+    let l = match c {
+        c if lex.is_ident_start(c) => {
+            let mut s = String::from(c);
+            while let Some((_, c)) = iter.peek() {
+                if lex.is_ident_part(*c) {
+                    s.push(*c);
+                    iter.next();
+                } else {
+                    break;
+                }
+            }
+            let id_ty = lex.ident_type(&s);
+
+            Lexeme::Token(Token {
+                ty: TokenType::Identifier(id_ty),
+                body: Symbol::intern_by_value(s),
+            })
+        }
+        c @ '0'..='9' => {
+            let mut s = String::from(c);
+            let mut radix = lex.is_num_prefix(&s);
+            if !lex.is_num_prefix_frag(&s) {
+                radix = Some(10);
+            }
+            let mut flt_piece = 0;
+
+            while let Some((pos, c)) = iter.peek().copied() {
+                if c.is_digit(radix.unwrap_or(10)) {
+                    s.push(c);
+                    radix.get_or_insert(10);
+                } else if lex.is_num_sep(c) {
+                    // pass
+                } else if radix.is_none() {
+                    s.push(c);
+                    if let Some(r) = lex.is_num_prefix(&s) {
+                        radix = Some(r);
+                    } else if lex.is_num_prefix_frag(&s) {
+                        continue;
+                    } else {
+                        s.pop();
+                        break;
+                    }
+                } else if flt_piece == 0 && c == '.' {
+                    if !lex.is_float_in_radix(*radix.get_or_insert(10)) {
+                        break;
+                    }
+                    s.push(c);
+                    flt_piece = 1;
+                } else if flt_piece < 2 && lex.is_float_exp_char(c, radix.unwrap_or(10)) {
+                    s.push(c);
+                    radix.get_or_insert(10);
+                    flt_piece = 2;
+                } else {
+                    break;
+                }
+
+                iter.next();
+            }
+
+            lex.check_valid_num(&s, iter)?;
+            let tok_ty = if flt_piece == 0 {
+                TokenType::Integer
+            } else {
+                TokenType::Float
+            };
+            Lexeme::Token(Token {
+                ty: tok_ty,
+                body: Symbol::intern_by_value(s),
+            })
+        }
+        '\"' => {
+            let sty = lex.default_str_type();
+            let mut st = String::new();
+
+            loop {
+                match iter.next() {
+                    Some((_, '"')) => break,
+                    Some((_, c)) if c == '\\' => {
+                        st.push('\\');
+                        st.push_str(&lex.check_escape(iter)?);
+                    }
+                    Some((_, c)) => st.push(c),
+                    None => return Err(Error::UnexpectedEof(iter.last_pos())),
+                }
+            }
+
+            Lexeme::Token(Token {
+                ty: TokenType::String(sty),
+                body: Symbol::intern_by_value(st),
+            })
+        }
+        '\'' => {
+            let sty = lex.default_char_type();
+            let mut st = String::new();
+
+            match iter.next() {
+                Some((pos, '\'')) => return Err(Error::UnrecognizedChar('\'', pos)),
+                Some((_, c)) if c == '\\' => {
+                    st.push('\\');
+                    st.push_str(&lex.check_escape(iter)?);
+                }
+                Some((_, c)) => st.push(c),
+                None => return Err(Error::UnexpectedEof(iter.last_pos())),
+            }
+
+            Lexeme::Token(Token {
+                ty: TokenType::Char(sty),
+                body: Symbol::intern_by_value(st),
+            })
+        }
+        c => {
+            if let Some((gty, end)) = lex.is_group_start(c) {
+                let mut stream = Vec::new();
+                while let Some(tok) = do_lexeme_in_group(lex, iter, Some(end))? {
+                    stream.push(tok);
+                }
+
+                Lexeme::Group(Group { ty: gty, stream })
+            } else {
+                let mut st = String::from(c);
+
+                let mut puncts = lex.punct_list();
+
+                if !puncts.iter().any(|&s| s.starts_with(&*st)) {
+                    return Err(Error::UnrecognizedChar(c, pos));
+                }
+
+                while let Some((_, c)) = iter.peek().copied() {
+                    st.push(c);
+                    if !puncts.iter().any(|&s| s.starts_with(&*st)) {
+                        st.pop();
+                        break;
+                    }
+                    iter.next();
+                }
+                lex.check_valid_punct(&st, iter)?;
+
+                Lexeme::Token(Token {
+                    ty: TokenType::Punct,
+                    body: Symbol::intern_by_value(st),
+                })
+            }
+        }
+    };
+
+    let span = Span::new_simple(pos, iter.last_pos(), iter.file_name());
+
+    match l {
+        Lexeme::Token(tok) => {
+            let span = lex.parse_rest(Spanned::new(tok, span), iter)?;
+            Ok(Some(span.map(|tok| Lexeme::Token(tok))))
+        }
+        lex => Ok(Some(Spanned::new(lex, span))),
+    }
+}
+
+pub fn do_lexeme<L: Lexer, I: Iterator<Item = char>>(
+    lex: &L,
+    iter: &mut PeekMoreIterator<Speekable<I>>,
+) -> Result<Option<Spanned<Lexeme<L>, L::Hygiene>>> {
+    do_lexeme_in_group(lex, iter, None)
+}
+
+pub fn lex_file<L: Lexer, I: Iterator<Item = char>>(
+    lex: &L,
+    it: I,
+    file_name: impl Into<Symbol>,
+) -> Result<Vec<Spanned<Lexeme<L>, L::Hygiene>>> {
+    let mut lexemes = vec![];
+    let mut it = it.speekable(file_name.into()).peekmore();
+    loop {
+        match do_lexeme(lex, &mut it)? {
+            Some(lexeme) => lexemes.push(lexeme),
+            None => break,
+        }
+    }
+    Ok(lexemes)
+}
diff --git a/xlang/xlang_frontend/src/lib.rs b/xlang/xlang_frontend/src/lib.rs
index b33291aa..a9f0dcc1 100644
--- a/xlang/xlang_frontend/src/lib.rs
+++ b/xlang/xlang_frontend/src/lib.rs
@@ -4,3 +4,5 @@ pub mod iter;
 pub mod parse;
 pub mod span;
 pub mod symbol;
+
+pub mod lexer;
\ No newline at end of file
diff --git a/xlang/xlang_frontend/src/span.rs b/xlang/xlang_frontend/src/span.rs
index 3aea3987..fae1133d 100644
--- a/xlang/xlang_frontend/src/span.rs
+++ b/xlang/xlang_frontend/src/span.rs
@@ -7,31 +7,46 @@ use xlang::abi::try_;
 use crate::helpers::FetchIncrement;
 use crate::symbol::Symbol;
 
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
 pub struct Pos {
-    row: u32,
-    col: u32,
+    row_col: u32,
 }
 
 impl Pos {
     pub const fn new(row: u32, col: u32) -> Self {
-        Self { row, col }
+        [()][(row > 0xFFFFF) as usize];
+        [()][(col > 0xFFF) as usize];
+        Self {
+            row_col: row | (col << 20),
+        }
     }
 
     pub const fn synthetic() -> Self {
-        Self::new(!0, !0)
+        Self { row_col: !0 }
+    }
+
+    pub const fn is_synthetic(&self) -> bool {
+        self.row_col == !0
     }
 
+    #[allow(dead_code)]
     pub const fn row(self) -> u32 {
-        self.row
+        self.row_col & 0xFFFFF
     }
 
+    #[allow(dead_code)]
     pub const fn col(self) -> u32 {
-        self.col
+        self.row_col >> 20
+    }
+
+    pub const fn next_col(mut self) -> Self {
+        Self::new(self.row(), self.col() + 1)
     }
+}
 
-    pub const fn is_synthetic(self) -> bool {
-        self.row == !0 && self.col == !0
+impl core::fmt::Debug for Pos {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}:{}", self.row(), self.col())
     }
 }
 
@@ -226,11 +241,11 @@ impl<I: Iterator<Item = char>> Speekable<I> {
             } else if let Some(c) = c {
                 let idx = self.index.fetch_increment();
                 let next_pos = match c {
-                    '\n' => Pos::new(self.pos.row + 1, 1),
-                    _ => Pos::new(self.pos.row, self.pos.col + 1),
+                    '\n' => Pos::new(self.pos.row() + 1, 1),
+                    _ => Pos::new(self.pos.row(), self.pos.col() + 1),
                 };
 
-                if next_pos.row != self.pos.row {
+                if next_pos.row() != self.pos.row() {
                     self.row_map.push(idx);
                 }
 
diff --git a/xlang/xlang_frontend/src/symbol.rs b/xlang/xlang_frontend/src/symbol.rs
index 1c88da38..6e69c1eb 100644
--- a/xlang/xlang_frontend/src/symbol.rs
+++ b/xlang/xlang_frontend/src/symbol.rs
@@ -1,7 +1,8 @@
 use std::{
     borrow::Borrow,
+    convert::TryInto,
     hash::Hash,
-    num::NonZeroUsize,
+    num::NonZeroU32,
     ops::Deref,
     sync::{
         atomic::{self, AtomicUsize},
@@ -13,11 +14,11 @@ use xlang::abi::{collection::HashMap, string::String, string::StringView, sync::
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct Symbol(NonZeroUsize);
+pub struct Symbol(NonZeroU32);
 
 type SymHashMap = (
-    HashMap<NonZeroUsize, &'static str>,
-    HashMap<&'static str, NonZeroUsize>,
+    HashMap<NonZeroU32, &'static str>,
+    HashMap<&'static str, NonZeroU32>,
 );
 
 struct SymbolMap {
@@ -37,9 +38,10 @@ impl SymbolMap {
             .get_or_insert_with(|| RwLock::new((HashMap::new(), HashMap::new())))
     }
 
-    fn allocate_counter(&self) -> NonZeroUsize {
+    fn allocate_counter(&self) -> NonZeroU32 {
         let val = self.counter.fetch_add(1, atomic::Ordering::Relaxed);
-        NonZeroUsize::new(val).expect("Exhausted Counter Limit")
+        NonZeroU32::new(val.try_into().expect("Exhausted Counter Limit"))
+            .expect("Exhausted Counter Limit")
     }
 }
 
diff --git a/xlang/xlang_host/src/lib.rs b/xlang/xlang_host/src/lib.rs
index 2b089ba5..bedc5b90 100644
--- a/xlang/xlang_host/src/lib.rs
+++ b/xlang/xlang_host/src/lib.rs
@@ -1,5 +1,4 @@
 #![deny(warnings, clippy::all, clippy::pedantic, clippy::nursery, missing_docs)]
-#![cfg_attr(has_feature_c_unwind = "feature", feature(c_unwind))]
 
 //!
 //! The `xlang_host` crate provides access to the host target's apis, depending on the interfaces available from the OS
@@ -11,4 +10,7 @@ pub mod dso;
 /// Primitive types defined by the OS (such as the size type and the pointer-sized type).
 pub mod primitives;
 
+/// Synchronization Primitives, like `wait_by_address`
+pub mod sync;
+
 mod rustcall;
diff --git a/xlang/xlang_host/src/sync.rs b/xlang/xlang_host/src/sync.rs
new file mode 100644
index 00000000..e79c79d9
--- /dev/null
+++ b/xlang/xlang_host/src/sync.rs
@@ -0,0 +1 @@
+mod sys;
diff --git a/xlang/xlang_host/src/sync/sys.rs b/xlang/xlang_host/src/sync/sys.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/xlang/xlang_host/src/sync/sys.rs
@@ -0,0 +1 @@
+

From e507e17bd8b8fb0ce2c294bc68fa5ae5bca558b7 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 2 Mar 2024 01:49:43 -0500
Subject: [PATCH 27/74] feat: Add `autobuild.toml`s  to frontends and backends.

---
 Cargo.lock                    | 127 +++++++---------------------------
 autobuild                     |   2 +-
 autobuild.toml                |   4 +-
 c/Cargo.toml                  |   2 -
 c/autobuild.toml              |   4 ++
 c/src/pplex.rs                |   6 +-
 codegen-clever/autobuild.toml |   4 ++
 codegen-w65/autobuild.toml    |   4 ++
 codegen-x86/autobuild.toml    |   4 ++
 rust/Cargo.toml               |   2 -
 rust/autobuild.toml           |  14 ++++
 rust/src/interning.rs         |  24 +++----
 xlang/autobuild.toml          |  18 ++++-
 13 files changed, 91 insertions(+), 124 deletions(-)
 create mode 100644 c/autobuild.toml
 create mode 100644 codegen-clever/autobuild.toml
 create mode 100644 codegen-w65/autobuild.toml
 create mode 100644 codegen-x86/autobuild.toml
 create mode 100644 rust/autobuild.toml

diff --git a/Cargo.lock b/Cargo.lock
index fc37e84b..6ba04cb3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -25,15 +25,10 @@ dependencies = [
  "serde_derive",
  "target-tuples",
  "toml 0.8.10",
+ "windows-sys",
  "with_builtin_macros",
 ]
 
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
 [[package]]
 name = "binfmt"
 version = "0.1.0"
@@ -72,18 +67,6 @@ dependencies = [
  "syn 2.0.27",
 ]
 
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
 [[package]]
 name = "cfg-match"
 version = "0.2.1"
@@ -174,10 +157,8 @@ checksum = "185b4cd26aff3789b8662aa73732b585d46b9756cd3c6b302be72f68302c5eba"
 name = "frontend-c"
 version = "0.1.0"
 dependencies = [
- "unicode-xid",
  "xlang",
  "xlang_frontend",
- "xlang_struct",
 ]
 
 [[package]]
@@ -185,10 +166,8 @@ name = "frontend-rust"
 version = "0.1.0"
 dependencies = [
  "defile",
- "fxhash",
  "interning-static-syms",
  "lazy_static",
- "parking_lot",
  "peekmore",
  "rust_mir_macro",
  "unicode-xid",
@@ -205,15 +184,6 @@ dependencies = [
  "xlang_struct",
 ]
 
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.14.3"
@@ -294,16 +264,6 @@ version = "0.2.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
 
-[[package]]
-name = "lock_api"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
 [[package]]
 name = "memchr"
 version = "2.7.1"
@@ -316,29 +276,6 @@ version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets",
-]
-
 [[package]]
 name = "paste"
 version = "1.0.14"
@@ -369,15 +306,6 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags",
-]
-
 [[package]]
 name = "rlib"
 version = "0.1.0"
@@ -394,12 +322,6 @@ dependencies = [
  "xlang_frontend",
 ]
 
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
 [[package]]
 name = "serde"
 version = "1.0.171"
@@ -429,12 +351,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "smallvec"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -548,11 +464,20 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
-version = "0.48.1"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05d4b17490f70499f20b9e791dcf6a299785ce8af4d709018206dc5b4953e95f"
+checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
 dependencies = [
  "windows_aarch64_gnullvm",
  "windows_aarch64_msvc",
@@ -565,45 +490,45 @@ dependencies = [
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
 
 [[package]]
 name = "winnow"
diff --git a/autobuild b/autobuild
index 6e7bfbad..b243b37e 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit 6e7bfbad6e62a90790507611e8a7d8b26e26d7d3
+Subproject commit b243b37e1b54efbca02c0b94a2c4f4281f98ad93
diff --git a/autobuild.toml b/autobuild.toml
index 0a1ca22f..8a0593c7 100644
--- a/autobuild.toml
+++ b/autobuild.toml
@@ -25,7 +25,7 @@ members=["rust","c"]
 
 [target.groups.backends]
 optional=true
-path-specifier="codegen-{}"
+path-spec="codegen-{}"
 members=["clever","x86","w65"]
 
 [target.xlang]
@@ -35,6 +35,8 @@ subdir="xlang"
 deps=["xlang"]
 subdir="lccc"
 
+[defaults.rust]
+edition="2018"
 
 [stages.host]
 build=["xlang","languages","backends","lccc"]
diff --git a/c/Cargo.toml b/c/Cargo.toml
index 3e7603b3..5b68a042 100644
--- a/c/Cargo.toml
+++ b/c/Cargo.toml
@@ -8,9 +8,7 @@ license = "BSD-2-Clause-Patent"
 
 [dependencies]
 xlang = {path="../xlang"}
-xlang_struct = {path="../xlang/xlang_struct"}
 xlang_frontend = {path="../xlang/xlang_frontend"}
-unicode-xid = "0.2.2"
 
 [lib]
 crate-type = ["cdylib"]
diff --git a/c/autobuild.toml b/c/autobuild.toml
new file mode 100644
index 00000000..3e5fd44e
--- /dev/null
+++ b/c/autobuild.toml
@@ -0,0 +1,4 @@
+[targets.frontend-c]
+deps=["xlang:xlang_frontend", "xlang:xlang"]
+src="src/lib.rs"
+type="xlang:xlang-plugin"
\ No newline at end of file
diff --git a/c/src/pplex.rs b/c/src/pplex.rs
index 008a58c6..834a72f1 100644
--- a/c/src/pplex.rs
+++ b/c/src/pplex.rs
@@ -1,7 +1,7 @@
-use unicode_xid::UnicodeXID;
 use xlang::abi::string::String;
 use xlang::abi::try_;
 use xlang_frontend::iter::{IntoRewinder, PeekMoreIterator};
+use xlang_frontend::lexer::{is_ident_part_unicode, is_ident_start_unicode};
 use xlang_frontend::span::{Pos, Spanned, Speekable};
 use xlang_frontend::symbol::Symbol;
 
@@ -171,11 +171,11 @@ pub fn lex_one<I: Iterator<Item = char>>(
                     )
                 }
             }
-        } else if c.is_xid_start() {
+        } else if is_ident_start_unicode(c) {
             let mut string = String::from(c);
 
             while let Some((_, c)) = lex_char(tree) {
-                if c.is_xid_continue() {
+                if is_ident_part_unicode(c) {
                     tree.consume_peaked();
                     string.push(c)
                 } else if c == '\\' {
diff --git a/codegen-clever/autobuild.toml b/codegen-clever/autobuild.toml
new file mode 100644
index 00000000..ed28d10f
--- /dev/null
+++ b/codegen-clever/autobuild.toml
@@ -0,0 +1,4 @@
+[targets.codegen-clever]
+deps=["xlang:xlang", "xlang:xlang_backend", "lc-binutils:arch-ops", "lc-binutils:binfmt", "vendor:target-tuples-0.5.2"]
+src="src/lib.rs"
+type="xlang:xlang-plugin"
diff --git a/codegen-w65/autobuild.toml b/codegen-w65/autobuild.toml
new file mode 100644
index 00000000..ed28d10f
--- /dev/null
+++ b/codegen-w65/autobuild.toml
@@ -0,0 +1,4 @@
+[targets.codegen-clever]
+deps=["xlang:xlang", "xlang:xlang_backend", "lc-binutils:arch-ops", "lc-binutils:binfmt", "vendor:target-tuples-0.5.2"]
+src="src/lib.rs"
+type="xlang:xlang-plugin"
diff --git a/codegen-x86/autobuild.toml b/codegen-x86/autobuild.toml
new file mode 100644
index 00000000..ed28d10f
--- /dev/null
+++ b/codegen-x86/autobuild.toml
@@ -0,0 +1,4 @@
+[targets.codegen-clever]
+deps=["xlang:xlang", "xlang:xlang_backend", "lc-binutils:arch-ops", "lc-binutils:binfmt", "vendor:target-tuples-0.5.2"]
+src="src/lib.rs"
+type="xlang:xlang-plugin"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 9ebdfff5..d3a496dd 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -7,10 +7,8 @@ license = "BSD-2-Clause-Patent"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-fxhash = "0.2"
 unicode-xid = "0.2.2"
 xlang = {path="../xlang"}
-parking_lot = "0.12"
 peekmore = "1.3.0"
 lazy_static = "1"
 interning-static-syms={path="interning-static-syms"}
diff --git a/rust/autobuild.toml b/rust/autobuild.toml
new file mode 100644
index 00000000..c21e72dc
--- /dev/null
+++ b/rust/autobuild.toml
@@ -0,0 +1,14 @@
+
+[targets.interning-static-syms]
+src="interning-static-syms/src/lib.rs"
+type="rust-procmacro"
+
+[targets.rust-mir-macro]
+deps=["xlang:xlang_frontend"]
+src="rust_mir_macro/src/lib.rs"
+type="rust-procmacro"
+
+[targets.frontend-rust]
+deps=["xlang:xlang", "interning-static-syms", "rust-mir-macro", "vendor:unicode-xid-0.2.2", "vendor:peekmore-1.3.0", "vendor:defile-0.2.0-rc1"]
+src="src/lib.rs"
+type="xlang:xlang-plugin"
diff --git a/rust/src/interning.rs b/rust/src/interning.rs
index 7cd923b4..d96ed3ab 100644
--- a/rust/src/interning.rs
+++ b/rust/src/interning.rs
@@ -5,8 +5,8 @@ use core::num::NonZeroU32;
 use core::ops::Deref;
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use fxhash::FxHashMap;
-use parking_lot::RwLock;
+use std::sync::RwLock;
+use xlang::abi::collection::HashMap;
 use xlang::abi::string::StringView;
 
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -86,19 +86,19 @@ impl core::fmt::Debug for Symbol {
 static COUNTER: AtomicUsize = AtomicUsize::new(INIT_DYN_VAL as usize);
 
 lazy_static::lazy_static! {
-    static ref MAP: RwLock<(FxHashMap<&'static str, NonZeroU32>,FxHashMap<NonZeroU32,&'static str>)> = {
-        let mut map: (FxHashMap<&'static str, NonZeroU32>,FxHashMap<NonZeroU32,&'static str>) = Default::default();
+    static ref MAP: RwLock<InitBlob> = {
+        let mut map: InitBlob = Default::default();
 
         init_static_symbols(&mut map);
 
-        parking_lot::const_rwlock(map)
+        RwLock::new(map)
     };
 }
 
 // Do not remove
 type InitBlob = (
-    FxHashMap<&'static str, NonZeroU32>,
-    FxHashMap<NonZeroU32, &'static str>,
+    HashMap<&'static str, NonZeroU32>,
+    HashMap<NonZeroU32, &'static str>,
 );
 
 // Do not remove
@@ -147,7 +147,7 @@ impl<S: AsRef<str>> From<&S> for Symbol {
 
 impl Symbol {
     pub fn intern_by_val(st: String) -> Self {
-        let rdgrd = MAP.read();
+        let rdgrd = MAP.read().unwrap();
         if let Some(sym) = rdgrd.0.get(&*st).copied() {
             Symbol(sym)
         } else {
@@ -162,7 +162,7 @@ impl Symbol {
 
             let leaked = Box::leak(st.into_boxed_str());
 
-            let mut guard = MAP.write();
+            let mut guard = MAP.write().unwrap();
 
             let sym = unsafe { NonZeroU32::new_unchecked(val) };
             guard.0.insert(leaked, sym);
@@ -172,7 +172,7 @@ impl Symbol {
         }
     }
     pub fn intern(st: &str) -> Self {
-        let rdgrd = MAP.read();
+        let rdgrd = MAP.read().unwrap();
         if let Some(sym) = rdgrd.0.get(st).copied() {
             Symbol(sym)
         } else {
@@ -185,7 +185,7 @@ impl Symbol {
                 .try_into()
                 .expect("Overflowed number of symbols");
             let leaked = Box::leak(Box::<str>::from(st));
-            let mut guard = MAP.write();
+            let mut guard = MAP.write().unwrap();
             let sym = unsafe { NonZeroU32::new_unchecked(val) };
             guard.0.insert(leaked, sym);
             guard.1.insert(sym, leaked);
@@ -195,7 +195,7 @@ impl Symbol {
     }
 
     pub fn as_str(&self) -> &str {
-        MAP.read().1[&self.0]
+        MAP.read().unwrap().1[&self.0]
     }
 }
 
diff --git a/xlang/autobuild.toml b/xlang/autobuild.toml
index a6ed5e41..5a1febbf 100644
--- a/xlang/autobuild.toml
+++ b/xlang/autobuild.toml
@@ -21,10 +21,11 @@ src="xlang_interface/src/lib.rs"
 
 [target.xlang-interface.library]
 library-type="dynamic"
-soname="0.1"
+soversion="0.1"
 
 [target.xlang]
 deps=["xlang_abi", "xlang_host", "xlang_struct", "xlang_targets"]
+links=["xlang-interface"]
 src="src/lib.rs"
 
 [target.xlang_backend]
@@ -33,4 +34,17 @@ src="xlang_backend/src/lib.rs"
 
 [target.xlang_frontend]
 deps=["xlang"]
-src="xlang_frontend/src/lib.rs"
\ No newline at end of file
+src="xlang_frontend/src/lib.rs"
+
+[build.xlang-plugin]
+base="rust" # Use the rust compiler for this build step
+leaf=true # Don't allow `link`s or `dep`s keys
+
+[build.xlang-plugin.defaults.library]
+library-type="dynamic" # We want a shared object/dll
+generate-link=false # Don't generate a <target-name>.lib on windows
+
+
+[build.xlang-plugin.defaults.artifact]
+prefix="xlang" # replace `lib` or `` prefix with `xlang`
+install="{lcccdir}"
\ No newline at end of file

From 3cfa6b6c26c1db802397ee89a7b4c0eb4ffbceea Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 2 Mar 2024 01:59:36 -0500
Subject: [PATCH 28/74] chore: Update autobuild module

---
 .cargo/config.toml | 1 +
 autobuild          | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.cargo/config.toml b/.cargo/config.toml
index e6975437..af17f142 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -5,6 +5,7 @@ build-lccc = "autobuild build"
 clean-lccc = "autobuild clean"
 run-lccc = "run --bin lccc -- --intree"
 run-lccc-release = "run --release --bin lccc -- --intree"
+guess = "autobuild guess"
 
 [env]
 AUTOBUILD_DIR={relative=true, value="autobuild"}
diff --git a/autobuild b/autobuild
index b243b37e..df6df180 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit b243b37e1b54efbca02c0b94a2c4f4281f98ad93
+Subproject commit df6df1807777b4a0d3b1eef60fd199bb113a9a91

From 1421600ebc9fb43fbc9b6105b6145341789f33ae Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:02:06 -0400
Subject: [PATCH 29/74] feat(xir): Start parsing xir

---
 test/xir/hello.xir                      |  15 +-
 xir/src/lexer.rs                        |  10 +-
 xir/src/lib.rs                          |   1 +
 xir/src/parser.rs                       | 199 ++++++++++
 xlang/xlang_abi/src/ops.rs              |   2 +
 xlang/xlang_frontend/src/diagnostics.rs |   9 +
 xlang/xlang_frontend/src/lexer.rs       |  68 +++-
 xlang/xlang_frontend/src/parse.rs       | 492 +++++++++++++++++++++++-
 xlang/xlang_frontend/src/span.rs        |  15 +
 9 files changed, 786 insertions(+), 25 deletions(-)

diff --git a/test/xir/hello.xir b/test/xir/hello.xir
index e76216e0..c02ec20e 100644
--- a/test/xir/hello.xir
+++ b/test/xir/hello.xir
@@ -1,10 +1,13 @@
 function puts(_0: *const char(8)) -> int(32);
 
 function main() -> int(32){
-    const global_address puts
-    const *const char(8) "Hello, world!"
-    call function(*const char(8))->int(32)
-    pop
-    const int(32) 0
-    exit 1
+    target @0 [] {
+        const *const char(8) "Hello World!\0"
+        const global_address function(*const char(8))->int(32) puts
+        call puts function(*const char(8))->int(32) next fallthrough @1
+    }
+    target @1 [] {
+        const int(32) 0
+        exit 1
+    }
 }
\ No newline at end of file
diff --git a/xir/src/lexer.rs b/xir/src/lexer.rs
index aabf5354..14755675 100644
--- a/xir/src/lexer.rs
+++ b/xir/src/lexer.rs
@@ -3,6 +3,7 @@
 use std::convert::Infallible;
 
 use xlang::abi::string::String;
+use xlang_frontend::lexer;
 use xlang_frontend::span::{NoHygiene, Speekable};
 
 pub use xlang_frontend::lexer::{
@@ -10,6 +11,11 @@ pub use xlang_frontend::lexer::{
     Lexer, Result, UnicodeEscapeRust,
 };
 
+pub type Lexeme = lexer::Lexeme<XirLexer>;
+pub type Group = lexer::Group<XirLexer, NoHygiene, GroupType>;
+pub type Token = lexer::LToken<XirLexer>;
+pub type TokenType = lexer::LToken<XirLexer>;
+
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum GroupType {
     Paren,
@@ -138,7 +144,7 @@ impl Lexer for XirLexer {
     }
 
     fn punct_list(&self) -> &[&str] {
-        &["->", "::", ":", "#", "@"]
+        &["->", "::", ":", "#", "@", "*", ";"]
     }
 
     fn check_valid_punct<I: Iterator<Item = char>>(
@@ -147,7 +153,7 @@ impl Lexer for XirLexer {
         it: &mut xlang_frontend::iter::PeekMoreIterator<Speekable<I>>,
     ) -> Result<()> {
         match c {
-            "->" | "::" | ":" | "#" | "@" => Ok(()),
+            "->" | "::" | ":" | "#" | "@" | "*" | ";" => Ok(()),
             _ => match it.next() {
                 Some((pos, c)) => Err(Error::UnrecognizedChar(c, pos)),
                 None => Err(Error::UnexpectedEof(it.last_pos())),
diff --git a/xir/src/lib.rs b/xir/src/lib.rs
index c7ea5a35..e478cf90 100644
--- a/xir/src/lib.rs
+++ b/xir/src/lib.rs
@@ -9,6 +9,7 @@ use xlang::plugin::{Error, XLangFrontend, XLangPlugin};
 use xlang::targets::properties::TargetProperties;
 
 mod lexer;
+mod parser;
 
 struct XirFrontend {
     filename: Option<String>,
diff --git a/xir/src/parser.rs b/xir/src/parser.rs
index 8b137891..6c9932a3 100644
--- a/xir/src/parser.rs
+++ b/xir/src/parser.rs
@@ -1 +1,200 @@
+#![allow(dead_code, unused_imports)]
+use std::convert::Infallible;
 
+use xlang::abi::collection::HashMap;
+use xlang_frontend::{
+    diagnostics::NoLocation,
+    iter::with_rewinder_accept_on_continue,
+    keywords,
+    parse::{do_lexeme_class, do_lexeme_classes, PError, PLexeme, PLexemeClass, PResult, Parser},
+    punctuation,
+    span::NoHygiene,
+};
+
+use crate::lexer::XirLexer;
+
+pub use xlang::ir;
+
+pub struct XirParser;
+
+keywords! {
+    function => Function,
+    public => Public,
+    origin => Origin,
+    module => Module,
+    private => Private,
+
+    atomic => Atomic,
+    relaxed => Relaxed,
+    release => Release,
+    acquire => Acquire,
+    acq_rel => AcqRel,
+    seq_cst => SeqCst,
+    volatile => Volatile,
+    nontemporal => Nontemporal,
+    freeze => Freeze,
+
+    mutable => Mutable,
+
+    asm => Asm,
+    pure => Pure,
+    transparent => Transparent,
+    nostack => NoStack,
+    nomem => NoMem,
+    noexit => NoExit,
+    class => Class,
+    syntax => Syntax,
+    clobbers => Clobbers,
+    targets => Targets,
+    late => Late,
+
+    unicode => Unicode,
+
+    target => Target,
+
+    fallthrough => Fallthrough,
+    cold => Cold,
+    continue => Continue,
+
+    willreturn => WillReturn,
+
+    next => Next,
+
+    static => Static,
+    immut => Immutable,
+
+    void => Void,
+    int => Int,
+    uint => UInt,
+    float => Float,
+    uchar => UChar,
+    schar => SChar,
+    min => Min,
+    max => Max,
+    posit => Posit,
+    fixed => Fixed,
+    fractbits => FractBits,
+    binary => Binary,
+    decimal => Decimal,
+    dfloat => DFloat,
+    extrange => ExtRange,
+    extprecision => ExtPrecision,
+    tagged => Tagged,
+    product => Product,
+    aligned => Aligned,
+    vectorsize => VectorSize,
+    nonzero => Nonzero,
+    finite => Finite,
+    nonnan => Nonnan,
+
+    struct => Struct,
+    union => Union,
+    enum => Enum,
+
+    sequence => Sequence,
+
+    add => Add,
+    sub => Sub,
+    mul => Mul,
+    div => Div,
+    mod => Mod,
+    bitand => BitAnd,
+    bitor => BitOr,
+    bitxor => BitXor,
+    rsh => Rsh,
+    lsh => Lsh,
+    cmp => Cmp,
+    cmp_lt => CmpLt,
+    cmp_gt => CmpGt,
+    cmp_eq => CmpEq,
+    cmp_ne => CmpNe,
+    cmp_ge => CmpGe,
+    cmp_le => CmpLe,
+
+    minus => Minus,
+    bitnot => BitNot,
+    logicnot => LogicNot,
+
+    preinc => PreInc,
+    postinc => PostInc,
+    predec => PreDec,
+    postdec => PostDec,
+
+    xchg => Xchg,
+    cmpxchg => CmpXchg,
+    wcmpxchg => WCmpXchg,
+
+    convert => Convert,
+    weak => Weak,
+    strong => Strong,
+    reinterpret => Reinterpret,
+    derive => Derive,
+    local => Local,
+    pop => Pop,
+    dup => Dup,
+    pivot => Pivot,
+
+    member => Member,
+    indirect => Indirect,
+    aggregate => Aggregate,
+
+    assign => Assign,
+    as_rvalue => AsRvalue,
+
+    compound_assign => CompoundAssign,
+    fetch_assign => FetchAssign,
+
+    addr_of => AddrOf,
+
+    fence => Fence,
+    begin => Begin,
+    end => End,
+    storage => Storage,
+    select => Select,
+
+
+}
+
+punctuation! {
+    -> => Arrow,
+    :: => PathSep,
+    : => Colon,
+    ; => SemiColon,
+    # => Pound,
+    @ => At,
+    * => Star,
+}
+
+impl Parser for XirParser {
+    type Loc = NoLocation;
+
+    type Lexer = XirLexer;
+
+    type Keyword = Keyword;
+
+    type Punct = Punctuation;
+
+    type Other = Infallible;
+
+    type Hygiene = NoHygiene;
+
+    fn build_loc(
+        &self,
+        _: &xlang_frontend::span::Spanned<
+            xlang_frontend::lexer::Lexeme<Self::Lexer>,
+            Self::Hygiene,
+        >,
+    ) -> Self::Loc {
+        NoLocation
+    }
+}
+
+pub type Error = PError<XirParser>;
+pub type SResult<T> = PResult<T, XirParser>;
+pub type LexemeClass = PLexemeClass<XirParser>;
+pub type Lexeme = PLexeme<XirParser>;
+pub type Span = xlang_frontend::span::Span;
+
+pub struct DiagSpanMap {
+    pub item_spans: HashMap<ir::Path, Span>,
+}
diff --git a/xlang/xlang_abi/src/ops.rs b/xlang/xlang_abi/src/ops.rs
index b17ffefd..4034568f 100644
--- a/xlang/xlang_abi/src/ops.rs
+++ b/xlang/xlang_abi/src/ops.rs
@@ -273,6 +273,8 @@ macro_rules! yeet {
     };
 }
 
+pub use yeet;
+
 #[cfg(test)]
 mod test {
     use crate::prelude::v1::*;
diff --git a/xlang/xlang_frontend/src/diagnostics.rs b/xlang/xlang_frontend/src/diagnostics.rs
index 8b137891..4a3fe232 100644
--- a/xlang/xlang_frontend/src/diagnostics.rs
+++ b/xlang/xlang_frontend/src/diagnostics.rs
@@ -1 +1,10 @@
+use crate::span::{NoHygiene, Span};
 
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct NoLocation;
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct DiagPosition<R = NoLocation, H = NoHygiene> {
+    pub span: Span<H>,
+    pub extra: R,
+}
diff --git a/xlang/xlang_frontend/src/lexer.rs b/xlang/xlang_frontend/src/lexer.rs
index 118a27f3..27544c37 100644
--- a/xlang/xlang_frontend/src/lexer.rs
+++ b/xlang/xlang_frontend/src/lexer.rs
@@ -214,8 +214,8 @@ impl EscapeMatcher for char {
     fn try_match<I: Iterator<Item = char>>(
         &self,
         sel: char,
-        it: &mut PeekMoreIterator<Speekable<I>>,
-        accepter: &mut String,
+        _: &mut PeekMoreIterator<Speekable<I>>,
+        _: &mut String,
     ) -> Result<bool> {
         Ok(sel == *self)
     }
@@ -252,7 +252,7 @@ macro_rules! impl_for_tuple{
     ($($T:ident),* $(,)?) => {
 
     impl<$($T: EscapeMatcher),*> EscapeMatcher for ($($T,)*){
-            #[allow(unused_variables)]
+            #[allow(unused_variables, non_snake_case)] // I'm not typing two idents into a macro input when there's a perfectly good ident already.
             fn try_match<_I: Iterator<Item=char>>(&self, sel: char, it: &mut PeekMoreIterator<Speekable<_I>>, accepter: &mut String) -> Result<bool>{
                 let ($($T,)*) = self;
 
@@ -333,6 +333,7 @@ pub struct Group<Lex, H = NoHygiene, GType = Infallible> {
     pub stream: Vec<Spanned<Lex, H>>,
 }
 
+pub type LGroup<L> = Group<Lexeme<L>, <L as Lexer>::Hygiene, <L as Lexer>::GroupType>;
 pub enum Lexeme<L: Lexer> {
     Token(LToken<L>),
     Group(Group<Self, L::Hygiene, L::GroupType>),
@@ -453,6 +454,7 @@ pub trait Lexer {
         &self,
         it: &mut PeekMoreIterator<Speekable<I>>,
     ) -> Result<String>;
+    #[allow(unused_variables)] // I don't want `_it` to be silencing the warning downstream in implementors
     fn parse_rest<I: Iterator<Item = char>>(
         &self,
         preceeding: Spanned<LToken<Self>, Self::Hygiene>,
@@ -466,20 +468,33 @@ fn do_lexeme_in_group<L: Lexer, I: Iterator<Item = char>>(
     lex: &L,
     iter: &mut PeekMoreIterator<Speekable<I>>,
     end_char: Option<char>,
-) -> Result<Option<Spanned<Lexeme<L>, L::Hygiene>>> {
+) -> Result<Spanned<Lexeme<L>, L::Hygiene>> {
     let (c, pos) = match lex.next_token_start(iter)? {
         Some((c, pos)) => (c, pos),
         None => {
             if end_char.is_some() {
                 return Err(Error::UnexpectedEof(iter.last_pos()));
             } else {
-                return Ok(None);
+                let pos = iter.last_pos();
+                return Ok(Spanned::new(
+                    Lexeme::Token(Token {
+                        ty: TokenType::Eof,
+                        body: Symbol::intern(""),
+                    }),
+                    Span::new_simple(pos, pos, iter.file_name()),
+                ));
             }
         }
     };
 
     if Some(c) == end_char {
-        return Ok(None);
+        return Ok(Spanned::new(
+            Lexeme::Token(Token {
+                ty: TokenType::Eof,
+                body: Symbol::intern(""),
+            }),
+            Span::new_simple(pos, pos, iter.file_name()),
+        ));
     }
 
     let l = match c {
@@ -508,7 +523,7 @@ fn do_lexeme_in_group<L: Lexer, I: Iterator<Item = char>>(
             }
             let mut flt_piece = 0;
 
-            while let Some((pos, c)) = iter.peek().copied() {
+            while let Some((_, c)) = iter.peek().copied() {
                 if c.is_digit(radix.unwrap_or(10)) {
                     s.push(c);
                     radix.get_or_insert(10);
@@ -595,15 +610,27 @@ fn do_lexeme_in_group<L: Lexer, I: Iterator<Item = char>>(
         c => {
             if let Some((gty, end)) = lex.is_group_start(c) {
                 let mut stream = Vec::new();
-                while let Some(tok) = do_lexeme_in_group(lex, iter, Some(end))? {
-                    stream.push(tok);
+                loop {
+                    let lexeme = do_lexeme_in_group(lex, iter, Some(end))?;
+                    let is_eof = matches!(
+                        lexeme.body(),
+                        Lexeme::Token(Token {
+                            ty: TokenType::Eof,
+                            ..
+                        })
+                    );
+                    stream.push(lexeme);
+
+                    if is_eof {
+                        break;
+                    }
                 }
 
                 Lexeme::Group(Group { ty: gty, stream })
             } else {
                 let mut st = String::from(c);
 
-                let mut puncts = lex.punct_list();
+                let puncts = lex.punct_list();
 
                 if !puncts.iter().any(|&s| s.starts_with(&*st)) {
                     return Err(Error::UnrecognizedChar(c, pos));
@@ -632,16 +659,16 @@ fn do_lexeme_in_group<L: Lexer, I: Iterator<Item = char>>(
     match l {
         Lexeme::Token(tok) => {
             let span = lex.parse_rest(Spanned::new(tok, span), iter)?;
-            Ok(Some(span.map(|tok| Lexeme::Token(tok))))
+            Ok(span.map(|tok| Lexeme::Token(tok)))
         }
-        lex => Ok(Some(Spanned::new(lex, span))),
+        lex => Ok(Spanned::new(lex, span)),
     }
 }
 
 pub fn do_lexeme<L: Lexer, I: Iterator<Item = char>>(
     lex: &L,
     iter: &mut PeekMoreIterator<Speekable<I>>,
-) -> Result<Option<Spanned<Lexeme<L>, L::Hygiene>>> {
+) -> Result<Spanned<Lexeme<L>, L::Hygiene>> {
     do_lexeme_in_group(lex, iter, None)
 }
 
@@ -653,9 +680,18 @@ pub fn lex_file<L: Lexer, I: Iterator<Item = char>>(
     let mut lexemes = vec![];
     let mut it = it.speekable(file_name.into()).peekmore();
     loop {
-        match do_lexeme(lex, &mut it)? {
-            Some(lexeme) => lexemes.push(lexeme),
-            None => break,
+        let lexeme = do_lexeme(lex, &mut it)?;
+        let is_eof = matches!(
+            lexeme.body(),
+            Lexeme::Token(Token {
+                ty: TokenType::Eof,
+                ..
+            })
+        );
+        lexemes.push(lexeme);
+
+        if is_eof {
+            break;
         }
     }
     Ok(lexemes)
diff --git a/xlang/xlang_frontend/src/parse.rs b/xlang/xlang_frontend/src/parse.rs
index 0e97fd22..9c48265e 100644
--- a/xlang/xlang_frontend/src/parse.rs
+++ b/xlang/xlang_frontend/src/parse.rs
@@ -1,6 +1,13 @@
+use std::convert::Infallible;
+
 use xlang::abi::ops::{ControlFlow, Try};
 
-use crate::iter::PeekMoreIterator;
+use crate::{
+    diagnostics::{DiagPosition, NoLocation},
+    iter::PeekMoreIterator,
+    lexer::{DefaultTy, Group, LGroup, LToken, Lexeme, Lexer, TokenType},
+    span::{NoHygiene, Spanned},
+};
 
 pub fn take_left<R>(left: R, _: R) -> R {
     left
@@ -57,3 +64,486 @@ where
         C::from_residual(last_res.expect("alternates must not be empty"))
     })
 }
+
+pub trait TokenDiscriminator<L: Lexer>: Sized {
+    fn matches(&self, lex: &LToken<L>) -> bool;
+}
+
+impl<L: Lexer> TokenDiscriminator<L> for Infallible {
+    fn matches(&self, _: &LToken<L>) -> bool {
+        match *self {}
+    }
+}
+
+pub trait LexemeDiscriminator<L: Lexer>: Sized {
+    fn matches(&self, lex: &Lexeme<L>) -> bool;
+}
+
+impl<L: Lexer, T: TokenDiscriminator<L>> LexemeDiscriminator<L> for T {
+    fn matches(&self, lex: &Lexeme<L>) -> bool {
+        match lex {
+            Lexeme::Token(lex) => <T as TokenDiscriminator<L>>::matches(self, lex),
+            _ => false,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum LexemeClass<K, P, I = DefaultTy, GTy = Infallible, O = Infallible> {
+    Ident(Option<I>),
+    Keyword(K),
+    Punct(P),
+    Group(Option<GTy>),
+    String,
+    Char,
+    Integer,
+    Float,
+    Other(O),
+    Eof,
+}
+impl<K, P, I, GTy, O> LexemeClass<K, P, I, GTy, O> {
+    pub fn matches<L: Lexer>(&self, lex: &Lexeme<L>) -> bool
+    where
+        K: TokenDiscriminator<L>,
+        P: TokenDiscriminator<L>,
+        I: PartialEq<L::IdentTy>,
+        GTy: PartialEq<L::GroupType>,
+        O: LexemeDiscriminator<L>,
+    {
+        match (lex, self) {
+            (Lexeme::Token(tok), cl) => match (&tok.ty, cl) {
+                (TokenType::Identifier(_), LexemeClass::Keyword(kw)) if kw.matches(tok) => true,
+                (TokenType::Identifier(_), LexemeClass::Ident(None)) => true,
+                (TokenType::Identifier(ty), LexemeClass::Ident(Some(cl_ty))) if cl_ty == ty => true,
+                (TokenType::Eof, LexemeClass::Eof) => true,
+                (TokenType::Punct, LexemeClass::Punct(p)) => p.matches(tok),
+                (TokenType::String(_), LexemeClass::String) => true,
+                (TokenType::Char(_), LexemeClass::Char) => true,
+                (TokenType::Integer, LexemeClass::Integer) => true,
+                (TokenType::Float, LexemeClass::Float) => true,
+                (TokenType::Other(_), LexemeClass::Other(o)) => o.matches(lex),
+                _ => false,
+            },
+            (Lexeme::Group(_), LexemeClass::Group(None)) => true,
+            (Lexeme::Group(g), LexemeClass::Group(Some(cl_gty))) => cl_gty == &g.ty,
+            (Lexeme::Other(_), LexemeClass::Other(o)) => o.matches(lex),
+            _ => false,
+        }
+    }
+}
+
+pub trait Parser {
+    type Loc;
+    type Lexer: Lexer<Hygiene = Self::Hygiene>;
+    type Keyword: TokenDiscriminator<Self::Lexer>;
+    type Punct: TokenDiscriminator<Self::Lexer>;
+    type Other: LexemeDiscriminator<Self::Lexer>;
+    type Hygiene;
+
+    fn build_loc(&self, tok: &Spanned<Lexeme<Self::Lexer>, Self::Hygiene>) -> Self::Loc;
+}
+
+pub type PLexemeClass<P> = LexemeClass<
+    <P as Parser>::Keyword,
+    <P as Parser>::Punct,
+    <<P as Parser>::Lexer as Lexer>::IdentTy,
+    <<P as Parser>::Lexer as Lexer>::GroupType,
+    <P as Parser>::Other,
+>;
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct Error<Cl, Lex, R = NoLocation, H = NoHygiene> {
+    pub expected: Vec<Cl>,
+    pub got: Lex,
+    pub at: DiagPosition<R, H>,
+    pub next: Option<Box<Self>>,
+}
+
+fn combine_errors_non_residual<Cl, Lex, R, H>(
+    mut a: Error<Cl, Lex, R, H>,
+    b: Error<Cl, Lex, R, H>,
+) -> Error<Cl, Lex, R, H>
+where
+    DiagPosition<R, H>: PartialEq,
+{
+    if a.at == b.at {
+        a.expected.extend(b.expected)
+    } else {
+        if let Some(mut next) = { a.next } {
+            *next = combine_errors_non_residual(*next, b);
+            a.next = Some(next);
+        } else {
+            a.next = Some(Box::new(b))
+        }
+    }
+
+    a
+}
+
+pub fn combine_errors<Cl, Lex, R, H>(
+    a: Result<Infallible, Error<Cl, Lex, R, H>>,
+    b: Result<Infallible, Error<Cl, Lex, R, H>>,
+) -> Result<Infallible, Error<Cl, Lex, R, H>>
+where
+    DiagPosition<R, H>: PartialEq,
+{
+    match (a, b) {
+        (Err(a), Err(b)) => Err(combine_errors_non_residual(a, b)),
+        (Ok(a), _) | (_, Ok(a)) => match a {},
+    }
+}
+
+pub type PToken<P> = LToken<<P as Parser>::Lexer>;
+pub type PGroup<P> = LGroup<<P as Parser>::Lexer>;
+pub type PLexeme<P> = Lexeme<<P as Parser>::Lexer>;
+
+pub type PError<P> = Error<PLexemeClass<P>, PLexeme<P>, <P as Parser>::Loc, <P as Parser>::Hygiene>;
+
+pub type PResult<T, P> = Result<Spanned<T, <P as Parser>::Hygiene>, PError<P>>;
+
+pub type PClassResult<T, P> =
+    Result<(PLexemeClass<P>, Spanned<T, <P as Parser>::Hygiene>), PError<P>>;
+
+pub fn do_lexeme_class<P: Parser, I: Iterator<Item = Spanned<PLexeme<P>, <P as Parser>::Hygiene>>>(
+    parse: &P,
+    it: &mut PeekMoreIterator<I>,
+    cl: PLexemeClass<P>,
+) -> PResult<PLexeme<P>, P>
+where
+    PLexeme<P>: Clone,
+    P::Hygiene: Clone,
+    <P::Lexer as Lexer>::IdentTy: PartialEq,
+    <P::Lexer as Lexer>::GroupType: PartialEq,
+{
+    let tok = it.peek().cloned().unwrap();
+
+    if cl.matches(tok.body()) {
+        it.peek_next();
+        Ok(tok)
+    } else {
+        let pos = parse.build_loc(&tok);
+        let span = tok.span().clone();
+        Err(Error {
+            expected: vec![cl],
+            got: tok.into_inner(),
+            at: DiagPosition { span, extra: pos },
+            next: None,
+        })
+    }
+}
+
+pub fn do_lexeme_classes<
+    P: Parser,
+    I: Iterator<Item = Spanned<PLexeme<P>, <P as Parser>::Hygiene>>,
+    C: IntoIterator,
+>(
+    parse: &P,
+    it: &mut PeekMoreIterator<I>,
+    cl: C,
+) -> PClassResult<PLexeme<P>, P>
+where
+    C::Item: AsRef<PLexemeClass<P>>,
+    PLexeme<P>: Clone,
+    P::Hygiene: Clone,
+    <P::Lexer as Lexer>::IdentTy: PartialEq,
+    <P::Lexer as Lexer>::GroupType: PartialEq,
+    PLexemeClass<P>: Clone,
+{
+    let tok = it.peek().cloned().unwrap();
+    let mut expected = vec![];
+    for cl in cl {
+        let class = cl.as_ref();
+        if class.matches(tok.body()) {
+            return Ok((class.clone(), tok));
+        } else {
+            expected.push(class.clone())
+        }
+    }
+
+    let pos = parse.build_loc(&tok);
+    let span = tok.span().clone();
+    Err(Error {
+        expected,
+        got: tok.into_inner(),
+        at: DiagPosition { span, extra: pos },
+        next: None,
+    })
+}
+
+pub fn do_lexeme_group<P: Parser, I: Iterator<Item = Spanned<PLexeme<P>, <P as Parser>::Hygiene>>>(
+    parse: &P,
+    it: &mut PeekMoreIterator<I>,
+    ty: Option<<P::Lexer as Lexer>::GroupType>,
+) -> PResult<PGroup<P>, P>
+where
+    PLexeme<P>: Clone,
+    P::Hygiene: Clone,
+    <P::Lexer as Lexer>::IdentTy: PartialEq,
+    <P::Lexer as Lexer>::GroupType: PartialEq,
+{
+    do_lexeme_class(parse, it, LexemeClass::Group(ty)).map(|lex| {
+        lex.map(|lex| match lex {
+            Lexeme::Group(g) => g,
+            _ => unreachable!(),
+        })
+    })
+}
+
+pub fn do_token_class<P: Parser, I: Iterator<Item = Spanned<PLexeme<P>, <P as Parser>::Hygiene>>>(
+    parse: &P,
+    it: &mut PeekMoreIterator<I>,
+    cl: PLexemeClass<P>,
+) -> PResult<PToken<P>, P>
+where
+    PLexeme<P>: Clone,
+    P::Hygiene: Clone,
+    <P::Lexer as Lexer>::IdentTy: PartialEq,
+    <P::Lexer as Lexer>::GroupType: PartialEq,
+{
+    do_lexeme_class(parse, it, cl).map(|lex| {
+        lex.map(|lex| match lex {
+            Lexeme::Token(tok) => tok,
+            _ => panic!("do_token_class is not valid for non-token Lexemes"),
+        })
+    })
+}
+
+pub fn do_token_classes<
+    P: Parser,
+    I: Iterator<Item = Spanned<PLexeme<P>, <P as Parser>::Hygiene>>,
+    C: IntoIterator,
+>(
+    parse: &P,
+    it: &mut PeekMoreIterator<I>,
+    cl: C,
+) -> PClassResult<PToken<P>, P>
+where
+    C::Item: AsRef<PLexemeClass<P>>,
+    PLexeme<P>: Clone,
+    P::Hygiene: Clone,
+    <P::Lexer as Lexer>::IdentTy: PartialEq,
+    <P::Lexer as Lexer>::GroupType: PartialEq,
+    PLexemeClass<P>: Clone,
+{
+    do_lexeme_classes(parse, it, cl).map(|(cl, lex)| {
+        (
+            cl,
+            lex.map(|lex| match lex {
+                Lexeme::Token(tok) => tok,
+                _ => panic!("do_token_class is not valid for non-token Lexemes"),
+            }),
+        )
+    })
+}
+
+#[macro_export]
+macro_rules! punctuation {
+    {
+        $($tok:tt => $name:ident),* $(,)?
+    } => {
+        #[derive(Clone, Copy, Hash, PartialEq, Eq)]
+        pub enum Punctuation {
+            $($name),*
+        }
+
+        impl Punctuation{
+            pub fn from_token(x: &str) -> Self {
+                match x {
+                    $(::core::stringify!($tok) => Self::$name,)*
+                    _ => panic!("Not a punctuation token: {}", x),
+                }
+            }
+
+            #[allow(dead_code)]
+            pub const fn symbol(&self) -> &'static str {
+                match self {
+                    $(Self::$name => ::core::stringify!($tok)),*
+                }
+            }
+        }
+
+        impl<L: $crate::lexer::Lexer> $crate::parse::TokenDiscriminator<L> for Punctuation{
+            fn matches(&self, ty: &$crate::lexer::LToken<L>) -> bool{
+                match &ty.ty{
+                    $crate::lexer::TokenType::Punct => &ty.body == self.symbol(),
+                    _ => false
+                }
+            }
+        }
+
+        impl core::fmt::Debug for Punctuation{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        impl core::fmt::Display for Punctuation{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! punct {
+            $(
+                [
+                    $tok
+                ] => {
+                    $crate::parse::LexemeClass::Punctuation($crate::lex::Punctuation::$name)
+                };
+            )*
+
+            [$tt:tt] => {
+                {
+                    ::core::compile_error!(::core::concat!("Not a punctuation token: ", ::core::stringify!($tt)))
+                }
+            };
+        }
+
+        pub use punct;
+    }
+}
+
+#[macro_export]
+macro_rules! keywords{
+    {
+        type $($pat:pat)|+ in $ident_ty:ty;
+        $($tok:tt => $name:ident),* $(,)?
+    } => {
+        #[derive(Clone, Copy, Hash, PartialEq, Eq)]
+        pub enum Keyword {
+            $($name),*
+        }
+
+        impl Keyword {
+            pub fn from_token(x: &str) -> Self {
+                match x {
+                    $(::core::stringify!($tok) => Self::$name,)*
+                    _ => panic!("Not a keyword: {}", x),
+                }
+            }
+
+            pub const fn symbol(&self) -> &'static str {
+                match self {
+                    $(Self::$name => ::core::stringify!($tok)),*
+                }
+            }
+        }
+
+        impl<L: $crate::lexer::Lexer<IdentTy = $ident_ty>> $crate::parse::TokenDiscriminator<L>  for Keyword{
+            fn matches(&self, ty: &$crate::lexer::LToken<L>) -> bool{
+                match &ty.ty{
+                    $crate::lexer::TokenType::Identifier($($pat)|+) => &ty.body == self.symbol(),
+                    _ => false
+                }
+            }
+        }
+
+        impl core::fmt::Debug for Keyword{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        impl core::fmt::Display for Keyword{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! keyword {
+            $(
+                [
+                    $tok
+                ] => {
+                    $crate::parse::LexemeClass::Keyword($crate::lex::Keyword::$name)
+                };
+            )*
+
+            [$tt:tt] => {
+                {
+                    ::core::compile_error!(::core::concat!("Not a keyword: ", ::core::stringify!($tt)))
+                }
+            };
+        }
+
+        pub use keyword;
+    };
+    {
+        $($tok:tt => $name:ident),* $(,)?
+    } => {
+        #[derive(Clone, Copy, Hash, PartialEq, Eq)]
+        pub enum Keyword {
+            $($name),*
+        }
+
+        impl Keyword {
+            pub fn from_token(x: &str) -> Self {
+                match x {
+                    $(::core::stringify!($tok) => Self::$name,)*
+                    _ => panic!("Not a keyword: {}", x),
+                }
+            }
+
+            pub const fn symbol(&self) -> &'static str {
+                match self {
+                    $(Self::$name => ::core::stringify!($tok)),*
+                }
+            }
+        }
+
+        impl<L: $crate::lexer::Lexer> $crate::parse::TokenDiscriminator<L>  for Keyword{
+            fn matches(&self, ty: &$crate::lexer::LToken<L>) -> bool{
+                match &ty.ty{
+                    $crate::lexer::TokenType::Identifier(_) => &ty.body == self.symbol(),
+                    _ => false
+                }
+            }
+        }
+
+        impl core::fmt::Debug for Keyword{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        impl core::fmt::Display for Keyword{
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result{
+                match self{
+                    $(Self::$name => f.write_str(::core::stringify!($tok))),*
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! keyword {
+            $(
+                [
+                    $tok
+                ] => {
+                    $crate::parse::LexemeClass::Keyword($crate::lex::Keyword::$name)
+                };
+            )*
+
+            [$tt:tt] => {
+                {
+                    ::core::compile_error!(::core::concat!("Not a keyword: ", ::core::stringify!($tt)))
+                }
+            };
+        }
+
+        pub use keyword;
+    };
+}
diff --git a/xlang/xlang_frontend/src/span.rs b/xlang/xlang_frontend/src/span.rs
index fae1133d..58e2ce05 100644
--- a/xlang/xlang_frontend/src/span.rs
+++ b/xlang/xlang_frontend/src/span.rs
@@ -147,6 +147,10 @@ impl<T, H> Spanned<T, H> {
         &self.span
     }
 
+    pub const fn body(&self) -> &T {
+        &self.val
+    }
+
     pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Spanned<U, H> {
         let Self { val, span } = self;
 
@@ -188,6 +192,17 @@ impl<T, H> Spanned<T, H> {
     }
 }
 
+impl<A, B, H> Spanned<(A, B), H> {
+    pub fn unzip(self) -> (Spanned<A, H>, Spanned<B, H>)
+    where
+        H: Copy,
+    {
+        let Self { val, span } = self;
+
+        (Spanned::new(val.0, span), Spanned::new(val.1, span))
+    }
+}
+
 pub trait Speekerator: Iterator<Item = char> + Sized {
     fn speekable(self, file_name: impl Into<Symbol>) -> Speekable<Self>;
 }

From 46183eb5967b61762f6e25a06048131d2b87fd96 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:02:39 -0400
Subject: [PATCH 30/74] feat(xlang-ir): Continue documenting xlang_struct

---
 xlang/xlang_backend/src/ty.rs |  18 +----
 xlang/xlang_struct/src/lib.rs | 122 +++++++++++++++++++++-------------
 2 files changed, 77 insertions(+), 63 deletions(-)

diff --git a/xlang/xlang_backend/src/ty.rs b/xlang/xlang_backend/src/ty.rs
index c2df07ec..ee7e0e6e 100644
--- a/xlang/xlang_backend/src/ty.rs
+++ b/xlang/xlang_backend/src/ty.rs
@@ -3,9 +3,9 @@ use std::convert::TryInto;
 use xlang::{
     ir::{
         AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule, PointerKind,
-        ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type, ValidRangeType, Value,
+        ScalarType, ScalarTypeHeader, ScalarTypeKind, ScalarValidity, Type, Value,
     },
-    prelude::v1::{HashMap, Pair, Some as XLangSome},
+    prelude::v1::{HashMap, Some as XLangSome},
     targets::properties::TargetProperties,
 };
 
@@ -140,19 +140,7 @@ impl TypeInformation {
             Type::Void => None,
             Type::FnType(_) => None,
             Type::Pointer(pty) => {
-                if pty.alias.contains(PointerAliasingRule::NONNULL)
-                    || pty.alias.contains(PointerAliasingRule::INVALID)
-                {
-                    Some(VStackValue::Constant(Value::Invalid(Type::Pointer(
-                        pty.clone(),
-                    ))))
-                } else if let Pair(
-                    ValidRangeType::Dereference
-                    | ValidRangeType::DereferenceWrite
-                    | ValidRangeType::WriteOnly,
-                    _,
-                ) = pty.valid_range
-                {
+                if pty.alias.contains(PointerAliasingRule::NONNULL) || pty.valid_range.1 > 0 {
                     Some(VStackValue::Constant(Value::Invalid(Type::Pointer(
                         pty.clone(),
                     ))))
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 91b1504b..51dcd552 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1247,42 +1247,100 @@ impl Default for Type {
 
 /// An Array type.
 ///
-///
+/// Matches
 ///
 #[repr(C)]
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct ArrayType {
+    /// The type of the array
     pub ty: Type,
+    /// The length of the array
     pub len: Value,
 }
 
 bitflags::bitflags! {
+    /// An aliasing Rule for a pointer, that indicates what assumptions are made about the pointer.
+    ///
+    /// All valid pointers exist in at least one of two modes for any given byte:
+    /// * `Valid`
+    /// * `Disabled`
+    ///
+    /// A pointer that is marked as valid for any given byte may freely read from and (subject to restrictions) freely write to that byte.
+    /// When a pointer is `Disabled` for a byte, writing to that byte via that pointer and reads yield uninit scalar values.
+    ///
+    /// The determination of whether a particular access is valid occurs after the effect of any aliasing attribute is applied.
+    /// A pointer that is marked as `Disabled` for a byte cannot be marked in any other way - any operation that attempts to do so is ignored.
+    ///
+    /// When a pointer is derived, the Valid/Disabled state of each byte is copied to the child.
+    ///
+    /// Matches the syntax
+    /// ```abnf
+    /// pointer-aliasing = "unique" / "readonly" / "nonnull"
+    /// ```
     #[repr(transparent)]
     #[derive(Default)]
     pub struct PointerAliasingRule : u32{
+        /// Indicates that no other pointers access any of the same bytes while this pointer is active.
+        ///
+        /// Matches `"unique"`
+        ///
+        /// ## Activation
+        /// For any given byte accessible through a `unique` pointer which is `Valid` for that byte, the pointer has two modes.
+        /// * Active
+        /// * Frozen
+        /// * Reserved
+        ///
+        /// When a pointer is derived as `unique` the pointer is marked as `Reserved` in each byte accessible from that pointer.
+        ///
+        /// Regardless of mode, the pointer may make any read access. In `Reserved` or `Active` mode, write accesses may be performed.
+        ///
+        /// When a pointer is used to write to a byte, then the following happens:
+        /// * That pointer (if `unique`) and all of its ancestors marked `unique` are set to `Active` for that byte. If any of these pointers were marked `Frozen` for that byte, instead that pointer and all descendants are marked `Disabled`.
+        /// * All pointers that are not an ancestor of the pointer are marked as `Disabled` for that byte.
+        /// * All `readonly` pointers and all children of readonly pointers are marked as `Disabled` for that byte.
+        ///
+        /// When a read access occurs to byte through any pointer, the following happens:
+        /// * All pointers that are `unique` and not an ancestor that are `Reserved` for that byte become `Frozen`.
+        /// * All pointers that are `unique` and are `Active` for that byte and not an ancestor become `Disabled`.
+        ///
+        ///
+        /// `unique` may be combined with `readonly`, but has no effect as `readonly` prohibits write accesses and `unique` activation requires a write access.
         const UNIQUE = 2;
+        /// Indicates that no pointer may perform a write access to any of the same bytes while this pointer is active.
+        ///
+        /// A `readonly` pointer becomes `Disabled` for a byte when any pointer (included a descendant) is used to perform a write access to that byte.
         const READ_ONLY = 4;
-        const READ_SHALLOW = 8;
-        const INVALID = 16;
+
+        /// Indicates that the pointer may not be null.
+        /// This is a trivial validity attribute and does not impose any additional aliasing constraints.
         const NONNULL = 32;
-        const NULL_OR_INVALID = 256;
     }
 }
 
-fake_enum::fake_enum! {
-    #[repr(u16)]
-    #[derive(Default,Hash)]
-    pub enum struct ValidRangeType{
-        None = 0,
-        Dereference = 1,
-        DereferenceWrite = 2,
-        WriteOnly = 3,
-        NullOrDereference = 4,
-        NullOrDereferenceWrite = 5,
-        NullOrWriteOnly = 6,
+bitflags::bitflags! {
+    /// Determines the type of valid range.
+    ///
+    /// A byte is accessible from a pointer if:
+    /// * The pointer is a root pointer to an object, the byte belongs to the complete object the root pointer points to,
+    /// * If the pointer was returned from the intrinsic function `__lccc::xlang::limit_valid_range`, the byte is part of the range `[p, p+n)` where the parameters to the intrinsic call were `[.., p, n]`, or
+    /// * If the pointer was not returned from the intrinsic function `__lccc::xlang::limit_valid_range` and the pointer is a child of some pointer `p`, the byte is accessible from `p`.
+    ///
+    /// A range of bytes is accessible from a pointer if each byte contained in the range is accessible from that pointer and each byte in the range belongs to the same complete object.
+    ///
+    /// Syntax:
+    /// ```abnf
+    /// valid-range-option := "inbounds" / "read" / "write"
+    /// ```
+    ///
+    #[repr(transparent)]
+    #[derive(Default)]
+    pub struct ValidRangeType : u16{
+        /// Indicates that the valid range of the pointer
+        const INBOUNDS = 1;
+        const READ = 2;
+        const WRITE = 4;
     }
 }
-
 bitflags::bitflags! {
     #[repr(transparent)]
     #[derive(Default)]
@@ -1334,41 +1392,9 @@ impl core::fmt::Display for PointerType {
         if self.alias.contains(PointerAliasingRule::READ_ONLY) {
             f.write_str("readonly ")?;
         }
-        if self.alias.contains(PointerAliasingRule::READ_SHALLOW) {
-            f.write_str("read_shallow ")?;
-        }
-        if self.alias.contains(PointerAliasingRule::INVALID) {
-            f.write_str("invalid ")?;
-        }
         if self.alias.contains(PointerAliasingRule::NONNULL) {
             f.write_str("nonnull ")?;
         }
-        if self.alias.contains(PointerAliasingRule::NULL_OR_INVALID) {
-            f.write_str("null_or_invalid ")?;
-        }
-
-        match self.valid_range {
-            Pair(ValidRangeType::None, _) => {}
-            Pair(ValidRangeType::Dereference, n) => {
-                f.write_fmt(format_args!("dereferenceable({}) ", n))?;
-            }
-            Pair(ValidRangeType::DereferenceWrite, n) => {
-                f.write_fmt(format_args!("dereference_write({}) ", n))?;
-            }
-            Pair(ValidRangeType::WriteOnly, n) => {
-                f.write_fmt(format_args!("write_only({}) ", n))?;
-            }
-            Pair(ValidRangeType::NullOrDereference, n) => {
-                f.write_fmt(format_args!("null_or_dereferenceable({}) ", n))?;
-            }
-            Pair(ValidRangeType::NullOrDereferenceWrite, n) => {
-                f.write_fmt(format_args!("null_or_dereference_write({}) ", n))?;
-            }
-            Pair(ValidRangeType::NullOrWriteOnly, n) => {
-                f.write_fmt(format_args!("null_or_write_only({}) ", n))?;
-            }
-            Pair(ty, n) => panic!("{:?}({}) is invalid", ty, n),
-        }
 
         if self.addr_space != 0 {
             f.write_fmt(format_args!("addr_space({}) ", self.addr_space))?;

From f5d2eaf3bdef5480c639b98496b20c0fd99509e0 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:03:22 -0400
Subject: [PATCH 31/74] fix(lccc): Don't try to rerun the build script when
 config.toml isn't present.

---
 lccc/build.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lccc/build.rs b/lccc/build.rs
index 9e249b74..615a8728 100644
--- a/lccc/build.rs
+++ b/lccc/build.rs
@@ -50,8 +50,7 @@ pub struct Config {
 }
 
 fn main() -> std::io::Result<()> {
-    println!("cargo:rerun-if-changed=config.toml");
-
+    println!("cargo:rerun-if-changed=build.rs");
     let file = {
         let mut file = PathBuf::from(std::env!("CARGO_MANIFEST_DIR"));
         file.push("config.toml");
@@ -59,6 +58,7 @@ fn main() -> std::io::Result<()> {
     };
 
     let mut cfg: Config = if let Ok(mut file) = std::fs::File::open(file) {
+        println!("cargo:rerun-if-changed=config.toml");
         let mut content = String::new();
         file.read_to_string(&mut content)?;
         toml::from_str(&content).unwrap()

From 11e7cd6e7998276052cdbc02bcec476c45fab199 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:03:58 -0400
Subject: [PATCH 32/74] feat(lccc): Start moving builtin target properties to
 external files

---
 lccc/targets/x86/builtins.toml | 24 ++++++++++++++++++++++++
 lccc/targets/x86/machines.toml |  0
 lccc/targets/x86_64.toml       |  2 ++
 3 files changed, 26 insertions(+)
 create mode 100644 lccc/targets/x86/builtins.toml
 create mode 100644 lccc/targets/x86/machines.toml
 create mode 100644 lccc/targets/x86_64.toml

diff --git a/lccc/targets/x86/builtins.toml b/lccc/targets/x86/builtins.toml
new file mode 100644
index 00000000..5dcbeebe
--- /dev/null
+++ b/lccc/targets/x86/builtins.toml
@@ -0,0 +1,24 @@
+[_mm_2intersect_epi32]
+return="void()"
+params = ["int vectorsize(4)(32)", "int vectorsize(4)(32)", "*uint(8)", "*uint(8)"]
+
+[_mm256_2intersect_epi32]
+return="void()"
+params = ["int vectorsize(8)(32)", "int vectorsize(8)(32)", "*uint(8)", "*uint(8)"]
+
+[_mm512_2intersect_epi32]
+return="void()"
+params = ["int vectorsize(16)(32)", "int vectorsize(16)(32)", "*uint(16)", "*uint(16)"]
+
+[_mm_2intersect_epi64]
+return="void()"
+params = ["int vectorsize(4)(32)", "int vectorsize(4)(32)", "*uint(8)", "*uint(8)"]
+
+[_mm256_2intersect_epi64]
+return="void()"
+params = ["int vectorsize(8)(32)", "int vectorsize(8)(32)", "*uint(8)", "*uint(8)"]
+
+[_mm512_2intersect_epi64]
+return="void()"
+params = ["int vectorsize(16)(32)", "int vectorsize(16)(32)", "*uint(8)", "*uint(8)"]
+
diff --git a/lccc/targets/x86/machines.toml b/lccc/targets/x86/machines.toml
new file mode 100644
index 00000000..e69de29b
diff --git a/lccc/targets/x86_64.toml b/lccc/targets/x86_64.toml
new file mode 100644
index 00000000..514a48a6
--- /dev/null
+++ b/lccc/targets/x86_64.toml
@@ -0,0 +1,2 @@
+[arch]
+lock-free-atomics = [8, 16, 32, 64]

From 22c4d4a001158b191a27f6fb738df9899df1469a Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:04:40 -0400
Subject: [PATCH 33/74] feat(xlang-backend): Support `jump` with remaps and
 `call`

---
 codegen-clever/src/lib.rs       |   1 +
 codegen-w65/src/lib.rs          |   1 +
 codegen-x86/src/lib.rs          | 161 +++++++++++++++++++++++++++++---
 xlang/xlang_backend/src/mach.rs |   1 +
 xlang/xlang_backend/src/ssa.rs  |  62 +++++++-----
 5 files changed, 190 insertions(+), 36 deletions(-)

diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index 836f3bfa..07596d62 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -65,6 +65,7 @@ impl Machine for CleverMachine {
         incoming: &[OpaqueLocation],
         fnty: &xlang_struct::FnType,
         tys: &TypeInformation,
+        which: u32,
     ) {
         todo!()
     }
diff --git a/codegen-w65/src/lib.rs b/codegen-w65/src/lib.rs
index e626c136..62562a4b 100644
--- a/codegen-w65/src/lib.rs
+++ b/codegen-w65/src/lib.rs
@@ -65,6 +65,7 @@ impl Machine for W65Machine {
         incoming: &[OpaqueLocation],
         fnty: &xlang_struct::FnType,
         tys: &TypeInformation,
+        which: u32,
     ) {
         todo!()
     }
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index a76b3c3d..cf304b39 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -26,6 +26,7 @@ mod callconv;
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum X86ValLocation {
+    Null,
     Register(X86Register),
 }
 
@@ -43,6 +44,7 @@ pub struct X86Assignments {
     mode: X86Mode,
     sp: X86Register,
     available_int_registers: Vec<X86Register>,
+    return_reg: Option<X86Register>,
     stack_width: i32,
     assigns: HashMap<u32, LocationAssignment>,
 }
@@ -97,8 +99,8 @@ fn move_opcode(
                 X86CodegenOpcode::Vmovups
             }
         }
-        X86RegisterClass::Tmm => todo!("tmmreg"),
-        X86RegisterClass::St => todo!("fpreg"),
+        X86RegisterClass::Tmm => panic!("No mov reg, reg for tmm"),
+        X86RegisterClass::St => panic!("No mov for st reg"),
         _ => X86CodegenOpcode::Mov,
     }
 }
@@ -114,17 +116,28 @@ impl X86Machine {
             return Ok(());
         }
         match (dest, src) {
+            (X86ValLocation::Null, X86ValLocation::Null) => Ok(()),
             (X86ValLocation::Register(dest), X86ValLocation::Register(src)) => {
                 if dest.class() != src.class() {
                     panic!("Cannot move between register classes")
                 }
 
-                let opcode = move_opcode(dest.class(), None, false);
+                match dest.class() {
+                    X86RegisterClass::St => todo!("fpreg"), // We need to do shenanigans to move between arbitrary st slots
+                    X86RegisterClass::Tmm => todo!("tmmreg"), // Less shenanigans are needed here, but we need to spill to memory
+                    _ => {
+                        let opcode = move_opcode(dest.class(), None, false);
 
-                writer.write_insn(X86Instruction::new(
-                    opcode,
-                    vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
-                ))
+                        writer.write_insn(X86Instruction::new(
+                            opcode,
+                            vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
+                        ))
+                    }
+                }
+            }
+            (X86ValLocation::Null, X86ValLocation::Register(_))
+            | (X86ValLocation::Register(_), X86ValLocation::Null) => {
+                panic!("Cannot move a register to/from null")
             }
         }
     }
@@ -167,6 +180,7 @@ impl Machine for X86Machine {
             mode,
             sp,
             available_int_registers: int_registers,
+            return_reg: None,
             stack_width: 0,
             assigns: HashMap::new(),
         }
@@ -184,16 +198,116 @@ impl Machine for X86Machine {
         let mut clobbers = X86Clobbers {};
         for (num, insn) in insns.iter().enumerate() {
             match insn {
-                xlang_backend::ssa::SsaInstruction::Call(_, _) => todo!("call"),
+                xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
+                    let callconv = X86CallConvInfo {
+                        mode: assignments.mode,
+                    };
+
+                    let callconv = compute_call_conv(&callconv, &targ.real_ty, &targ.call_ty, tys);
+
+                    // TODO: Clobber non-saved registers
+
+                    for (loc, call_loc) in locations.params.iter().zip(callconv.params()) {
+                        match call_loc {
+                            CallConvLocation::Null => {}
+                            CallConvLocation::Register(reg) => {
+                                assignments
+                                    .assigns
+                                    .get_or_insert_with_mut(loc.num, |_| LocationAssignment {
+                                        foreign_location: X86ValLocation::Register(*reg),
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                    })
+                                    .change_owner
+                                    .push((num, X86ValLocation::Register(*reg)));
+                            }
+                            loc => todo!("{:?}", loc),
+                        }
+                    }
+
+                    if let Some(ret) = &locations.ret {
+                        match callconv.ret_location() {
+                            CallConvLocation::Null => {}
+                            CallConvLocation::Register(reg) => {
+                                assignments.assigns.insert(
+                                    ret.num,
+                                    LocationAssignment {
+                                        foreign_location: X86ValLocation::Register(*reg),
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                    },
+                                );
+                            }
+                            loc => todo!("{:?}", loc),
+                        }
+                    }
+                }
                 xlang_backend::ssa::SsaInstruction::Jump(targ, old_locs)
                 | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
-                        todo!("jump remap {} => {}", old_loc, new_loc)
+                        match (
+                            assignments
+                                .assigns
+                                .get_mut(&new_loc.num)
+                                .map(|x| x.foreign_location.clone()),
+                            assignments.assigns.get_mut(&old_loc.num),
+                        ) {
+                            (Some(foreign), Some(old)) => {
+                                old.change_owner.push((num, foreign));
+                            }
+                            (Some(foreign), None) => {
+                                assignments.assigns.insert(
+                                    old_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: foreign,
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                    },
+                                );
+                            }
+                            (None, Some(old)) => {
+                                let incoming = old
+                                    .change_owner
+                                    .last()
+                                    .map_or(&old.foreign_location, |(_, x)| x)
+                                    .clone();
+
+                                assignments.assigns.insert(
+                                    new_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: incoming,
+                                        owning_bb: *targ,
+                                        change_owner: vec![],
+                                    },
+                                );
+                            }
+                            (None, None) => {
+                                todo!("Allocate register");
+                            }
+                        }
                     }
                 }
-                xlang_backend::ssa::SsaInstruction::Exit(_) => todo!("exit"),
+                xlang_backend::ssa::SsaInstruction::Exit(val) => match &**val {
+                    [] => {}
+                    [retval] => {
+                        let reg = assignments.return_reg;
+                        if let Some(reg) = reg {
+                            let loc = X86ValLocation::Register(reg);
+                            assignments
+                                .assigns
+                                .get_or_insert_with_mut(retval.num, |_| LocationAssignment {
+                                    foreign_location: loc.clone(),
+                                    owning_bb: which,
+                                    change_owner: vec![],
+                                })
+                                .change_owner
+                                .push((num, loc));
+                        }
+                    }
+                    vals => panic!("exit with more than 1 value: {:?}", vals),
+                },
                 xlang_backend::ssa::SsaInstruction::Tailcall(targ, locs) => {
                     let callconv = X86CallConvInfo {
                         mode: assignments.mode,
@@ -256,7 +370,13 @@ impl Machine for X86Machine {
             }
 
             match insn {
-                xlang_backend::ssa::SsaInstruction::Call(_, _) => todo!("call"),
+                xlang_backend::ssa::SsaInstruction::Call(targ, _) => match &targ.ptr {
+                    OpaquePtr::Symbol(sym) => encoder.write_insn(X86Instruction::new(
+                        X86CodegenOpcode::Call,
+                        vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
+                    ))?,
+                    OpaquePtr::Pointer(ptr) => todo!("indirect call"),
+                },
                 xlang_backend::ssa::SsaInstruction::Jump(targ, _) => {
                     encoder.write_insn(X86Instruction::new(
                         X86CodegenOpcode::Jmp,
@@ -267,7 +387,7 @@ impl Machine for X86Machine {
                     ))?;
                 }
                 xlang_backend::ssa::SsaInstruction::Fallthrough(_, _) => {}
-                xlang_backend::ssa::SsaInstruction::Exit(_) => {
+                xlang_backend::ssa::SsaInstruction::Exit(val) => {
                     if assignments.stack_width > 0 {
                         encoder.write_insn(X86Instruction::new(
                             X86CodegenOpcode::Add,
@@ -305,6 +425,7 @@ impl Machine for X86Machine {
                                     ],
                                 ))?;
                             }
+                            X86ValLocation::Null => {}
                         }
                     }
                 }
@@ -339,6 +460,7 @@ impl Machine for X86Machine {
         incoming: &[xlang_backend::ssa::OpaqueLocation],
         fnty: &xlang::ir::FnType,
         tys: &TypeInformation,
+        which: u32,
     ) {
         let callconv = X86CallConvInfo {
             mode: assignments.mode,
@@ -346,11 +468,24 @@ impl Machine for X86Machine {
         let callconv = compute_call_conv(&callconv, fnty, fnty, tys);
 
         for (param, incoming) in callconv.params().iter().zip(incoming) {
-            todo!()
+            let loc = match param {
+                CallConvLocation::Null => X86ValLocation::Null,
+                CallConvLocation::Register(reg) => X86ValLocation::Register(*reg),
+                loc => todo!("Param in {:?}", loc),
+            };
+
+            let assignment = LocationAssignment {
+                foreign_location: loc,
+                change_owner: vec![],
+                owning_bb: which,
+            };
+
+            assignments.assigns.insert(incoming.num, assignment);
         }
 
         match callconv.ret_location() {
             CallConvLocation::Null => {}
+            CallConvLocation::Register(reg) => assignments.return_reg = Some(*reg),
             loc => todo!("Return in {:?}", loc),
         }
     }
diff --git a/xlang/xlang_backend/src/mach.rs b/xlang/xlang_backend/src/mach.rs
index 6a87585e..0ea2593b 100644
--- a/xlang/xlang_backend/src/mach.rs
+++ b/xlang/xlang_backend/src/mach.rs
@@ -33,6 +33,7 @@ pub trait Machine {
         incoming: &[OpaqueLocation],
         fnty: &ir::FnType,
         tys: &TypeInformation,
+        which: u32,
     );
 
     /// Assigns the locations for a basic block, specifying the instructions the make up the lowered basic block, and the list of locations incoming to the basic block.
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index d432d286..6add935c 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -33,7 +33,7 @@ pub struct CallLocations {
     /// The locations of the parameters
     pub params: Vec<OpaqueLocation>,
     /// The location of the return value
-    pub ret: OpaqueLocation,
+    pub ret: Option<OpaqueLocation>,
 }
 
 /// An instruction for ssa codegen lowered from a [`Expr`][xlang::ir::Expr]
@@ -67,9 +67,12 @@ impl core::fmt::Display for SsaInstruction {
                     sep = ", ";
                     item.fmt(f)?;
                 }
-                f.write_str(") -> ")?;
-
-                locs.ret.fmt(f)
+                f.write_str(")")?;
+                if let Some(ret) = &locs.ret {
+                    f.write_str(" -> ")?;
+                    ret.fmt(f)?;
+                }
+                Ok(())
             }
             SsaInstruction::Jump(val, stack) => {
                 f.write_fmt(format_args!("jump @{} [", val))?;
@@ -305,6 +308,7 @@ impl<M: Machine> FunctionBuilder<M> {
                 &self.incoming_locations[&bb.id],
                 &self.fnty,
                 &self.tys,
+                bb.id,
             )
         }
 
@@ -510,24 +514,36 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 };
 
                 if let Some(next) = next {
-                    let ret_loc = OpaqueLocation {
-                        ty: Rc::new(real_ty.ret.clone()),
-                        kind: ir::StackValueKind::RValue,
-                        num: self.loc_id_counter.next(),
-                        has_addr: false,
-                    };
-                    self.insns.push(SsaInstruction::Call(
-                        CallTarget {
-                            ptr: OpaquePtr::Symbol(sym),
-                            real_ty,
-                            call_ty,
-                        },
-                        CallLocations {
-                            params,
-                            ret: ret_loc.clone(),
-                        },
-                    ));
-                    self.write_jump(&next, [ret_loc]);
+                    if call_ty.ret == ir::Type::Void {
+                        self.insns.push(SsaInstruction::Call(
+                            CallTarget {
+                                ptr: OpaquePtr::Symbol(sym),
+                                real_ty,
+                                call_ty,
+                            },
+                            CallLocations { params, ret: None },
+                        ));
+                        self.write_jump(&next, []);
+                    } else {
+                        let ret_loc = OpaqueLocation {
+                            ty: Rc::new(real_ty.ret.clone()),
+                            kind: ir::StackValueKind::RValue,
+                            num: self.loc_id_counter.next(),
+                            has_addr: false,
+                        };
+                        self.insns.push(SsaInstruction::Call(
+                            CallTarget {
+                                ptr: OpaquePtr::Symbol(sym),
+                                real_ty,
+                                call_ty,
+                            },
+                            CallLocations {
+                                params,
+                                ret: Some(ret_loc.clone()),
+                            },
+                        ));
+                        self.write_jump(&next, [ret_loc]);
+                    }
                 } else {
                     self.insns.push(SsaInstruction::Tailcall(
                         CallTarget {
@@ -551,7 +567,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
         }
     }
 
-    /// Writes a (possibly [`FALLTHROUGH`][ir::JumpFlags::FALLTHROUGH]) jump to the specified target.
+    /// Writes a (possibly [`FALLTHROUGH`][ir::JumpTargetFlags::FALLTHROUGH]) jump to the specified target.
     ///
     /// `head_vals` contains value placed on the head of the incoming target stack, which much be at most the total number of incoming values
     pub fn write_jump<H: IntoIterator<Item = OpaqueLocation>>(

From 659b878c0e4d36750d6bf2f74efa6ca68b83e536 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:05:53 -0400
Subject: [PATCH 34/74] feat(rust-frontend): Support `unsafe` and `extern` for
 functions

---
 rust/src/ast.rs   |  7 ++++-
 rust/src/parse.rs | 66 +++++++++++++++++++++++++++++++++++++----------
 rust/src/sema.rs  | 11 ++++----
 test/rust/main.rs | 11 ++++++++
 4 files changed, 75 insertions(+), 20 deletions(-)
 create mode 100644 test/rust/main.rs

diff --git a/rust/src/ast.rs b/rust/src/ast.rs
index 00504dcb..cfb16a80 100644
--- a/rust/src/ast.rs
+++ b/rust/src/ast.rs
@@ -97,10 +97,15 @@ pub struct ImplBlock {
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct Async;
 
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Extern {
+    pub tag: Option<Spanned<Symbol>>,
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct Function {
     pub safety: Option<Spanned<Safety>>,
-    pub abi: Option<Spanned<Symbol>>,
+    pub abi: Option<Spanned<Extern>>,
     pub constness: Option<Spanned<Mutability>>,
     pub is_async: Option<Spanned<Async>>,
     pub name: Spanned<Symbol>,
diff --git a/rust/src/parse.rs b/rust/src/parse.rs
index d7cffa8c..63e06051 100644
--- a/rust/src/parse.rs
+++ b/rust/src/parse.rs
@@ -4,19 +4,20 @@ use peekmore::{PeekMore, PeekMoreIterator};
 
 use crate::{
     ast::{
-        AssociatedTypeBound, AsyncBlock, Attr, AttrInput, Auto, BinaryOp, BindingPattern, Block,
-        CaptureSpec, Closure, ClosureParam, CompoundBlock, CondBlock, ConstParam, Constructor,
-        ConstructorExpr, EnumVariant, Expr, ExternBlock, FieldInit, Function, GenericArg,
-        GenericArgs, GenericBound, GenericParam, GenericParams, IfBlock, ImplBlock, Item, ItemBody,
-        ItemValue, Label, LetStatement, Lifetime, LifetimeParam, Literal, LiteralKind, MatchArm,
-        MatchArmValue, MatchBlock, Mod, Param, Path, PathSegment, Pattern, Safety, SelfParam,
-        SimplePath, SimplePathSegment, Spanned, Statement, StructCtor, StructField, StructKind,
-        TraitDef, TupleCtor, TupleField, Type, TypeParam, UnaryOp, UserType, UserTypeBody,
-        Visibility, WhereClause,
+        AssociatedTypeBound, Async, AsyncBlock, Attr, AttrInput, Auto, BinaryOp, BindingPattern,
+        Block, CaptureSpec, Closure, ClosureParam, CompoundBlock, CondBlock, ConstParam,
+        Constructor, ConstructorExpr, EnumVariant, Expr, Extern, ExternBlock, FieldInit, Function,
+        GenericArg, GenericArgs, GenericBound, GenericParam, GenericParams, IfBlock, ImplBlock,
+        Item, ItemBody, ItemValue, Label, LetStatement, Lifetime, LifetimeParam, Literal,
+        LiteralKind, MatchArm, MatchArmValue, MatchBlock, Mod, Param, Path, PathSegment, Pattern,
+        Safety, SelfParam, SimplePath, SimplePathSegment, Spanned, Statement, StructCtor,
+        StructField, StructKind, TraitDef, TupleCtor, TupleField, Type, TypeParam, UnaryOp,
+        UserType, UserTypeBody, Visibility, WhereClause,
     },
     interning::Symbol,
     lex::{
-        AstFrag, AstFragClass, CharType, Group, GroupType, IsEof, Keyword, Lexeme, LexemeBody, LexemeClass, Punctuation, StringType, Token, TokenType
+        AstFrag, AstFragClass, CharType, Group, GroupType, IsEof, Keyword, Lexeme, LexemeBody,
+        LexemeClass, Punctuation, StringType, Token, TokenType,
     },
     sema::ty::Mutability,
     span::{Pos, Span},
@@ -2992,6 +2993,43 @@ pub fn do_item_fn(
     tree: &mut PeekMoreIterator<impl Iterator<Item = Lexeme>>,
 ) -> Result<Spanned<ItemBody>> {
     let mut tree = tree.into_rewinder();
+
+    let constness = match do_lexeme_token(&mut tree, keyword!(const)) {
+        Ok((span, _)) => Some(Spanned {
+            body: Mutability::Const,
+            span,
+        }),
+        Err(_) => None,
+    };
+
+    let is_async = match do_lexeme_token(&mut tree, keyword!(async)) {
+        Ok((span, _)) => Some(Spanned { body: Async, span }),
+        Err(_) => None,
+    };
+
+    let safety = match do_lexeme_token(&mut tree, keyword!(unsafe)) {
+        Ok((span, _)) => Some(Spanned {
+            body: Safety::Unsafe,
+            span,
+        }),
+        Err(_) => None,
+    };
+
+    let abi = match do_lexeme_token(&mut tree, keyword!(extern)) {
+        Ok((span, _)) => {
+            let (span, tag) = match do_string(&mut tree) {
+                Ok((tok, _)) => (Span::between(span, tok.span), Some(tok)),
+                Err(_) => (span, None),
+            };
+
+            Some(Spanned {
+                body: Extern { tag },
+                span,
+            })
+        }
+        Err(_) => None,
+    };
+
     let Lexeme {
         span: span_start, ..
     } = do_lexeme_class(&mut tree, keyword!(fn))?;
@@ -3037,10 +3075,10 @@ pub fn do_item_fn(
     Ok(Spanned {
         body: ItemBody::Function(Spanned {
             body: Function {
-                safety: None,
-                abi: None,
-                constness: None,
-                is_async: None,
+                safety,
+                abi,
+                constness,
+                is_async,
                 name,
                 generics,
                 receiver: None, // TODO: parse receiver
diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index 1eb93b95..4175080b 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -2833,9 +2833,10 @@ fn collect_function(
     let actual_tag = itemfn
         .abi
         .map(|tag| {
-            Ok(Spanned {
-                body: ty::convert_tag(tag, curmod, item)?,
-                span: tag.span,
+            tag.try_map_span(|tag| {
+                tag.tag.map_or(Ok(ty::AbiTag::C { unwind: false }), |tag| {
+                    ty::convert_tag(tag, curmod, item)
+                })
             })
         })
         .transpose()?;
@@ -2880,12 +2881,12 @@ fn collect_function(
 
     let constness = itemfn.constness.unwrap_or(Spanned {
         body: Mutability::Mut,
-        span: Span::empty(),
+        span: Span::synthetic(),
     });
     let asyncness = itemfn.is_async.map_or(
         Spanned {
             body: ty::AsyncType::Normal,
-            span: Span::empty(),
+            span: Span::synthetic(),
         },
         |isasync| Spanned {
             body: ty::AsyncType::Async,
diff --git a/test/rust/main.rs b/test/rust/main.rs
new file mode 100644
index 00000000..67ce78c1
--- /dev/null
+++ b/test/rust/main.rs
@@ -0,0 +1,11 @@
+#![no_main]
+#![no_std]
+
+extern "lcrust-v0" {
+    fn __lccc_main() -> i32;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn main() -> i32 {
+    __lccc_main()
+}

From 1a79d0a0ae0d47559742efbb17aa5bb140685e4d Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 20:06:15 -0400
Subject: [PATCH 35/74] chore: update submodules

---
 .gitignore  | 2 +-
 autobuild   | 2 +-
 lc-binutils | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index e6571968..bfa4c924 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,7 @@ autom4te.cache/
 /config.toml
 *.o
 *.a
-a.out
+*.out
 testfile
 test-output.txt
 /build*/
\ No newline at end of file
diff --git a/autobuild b/autobuild
index df6df180..d13ec442 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit df6df1807777b4a0d3b1eef60fd199bb113a9a91
+Subproject commit d13ec44269711b6a71d5789204f7f6114dae28db
diff --git a/lc-binutils b/lc-binutils
index 39d2cf0a..5c82a510 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 39d2cf0a5b1aba7dafb1fb5eada9e9ce4c4cc7e7
+Subproject commit 5c82a510059a2bb1cd1e9ad2d29ac7a709a5eaf7

From 3a1953d6057916208993a9af8d8241d414695eeb Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 10 Mar 2024 20:20:10 -0500
Subject: [PATCH 36/74] feat(rust-xir): lower more binary exprs

---
 rust/src/irgen/xir_visitor.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 802e0af1..7bfd21e6 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -2179,7 +2179,11 @@ impl<'a> XirBinaryExprVisitor<'a> {
 impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
     fn visit_op(&mut self, op: BinaryOp) {
         self.op = Some(match op {
+            BinaryOp::Add => ir::BinaryOp::Add,
             BinaryOp::Sub => ir::BinaryOp::Sub,
+            BinaryOp::Mul => ir::BinaryOp::Mul,
+            BinaryOp::Div => ir::BinaryOp::Div,
+            BinaryOp::Rem => ir::BinaryOp::Mod,
             x => todo!("{:?}", x),
         });
     }

From 035bcaaf6859fff47086f2c7a09891ca6899ac28 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 10 Mar 2024 22:19:33 -0400
Subject: [PATCH 37/74] feat(codegen): Support string literals and empty
 product types

---
 codegen-x86/src/lib.rs              | 106 ++++++++++++++++++++++++++--
 lc-binutils                         |   2 +-
 xlang/xlang_backend/src/callconv.rs |   6 +-
 xlang/xlang_backend/src/lib.rs      |  22 +++++-
 xlang/xlang_backend/src/ssa.rs      |  70 +++++++++++++++++-
 xlang/xlang_backend/src/str.rs      |  10 ++-
 6 files changed, 199 insertions(+), 17 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index cf304b39..684b512f 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -1,7 +1,7 @@
 use arch_ops::{
     traits::{Address, InsnWrite},
     x86::{
-        codegen::{X86CodegenOpcode, X86Encoder, X86Instruction, X86Operand},
+        codegen::{X86CodegenOpcode, X86Encoder, X86Instruction, X86MemoryOperand, X86Operand},
         X86Mode, X86Register, X86RegisterClass,
     },
 };
@@ -9,6 +9,7 @@ use callconv::X86CallConvInfo;
 use target_tuples::{Architecture, Target};
 use xlang::{
     abi::{pair::Pair, string::StringView},
+    ir,
     plugin::XLangCodegen,
     prelude::v1::{DynBox, HashMap},
     targets::properties::TargetProperties,
@@ -51,6 +52,39 @@ pub struct X86Assignments {
 
 pub struct X86Clobbers {}
 
+fn xor_opcode(class: X86RegisterClass, hint_vec_is_int: bool) -> X86CodegenOpcode {
+    match class {
+        X86RegisterClass::Xmm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Pxor
+            } else {
+                X86CodegenOpcode::Xorps
+            }
+        }
+        X86RegisterClass::Ymm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vpxor
+            } else {
+                X86CodegenOpcode::Vxorps
+            }
+        }
+        X86RegisterClass::Zmm => {
+            if hint_vec_is_int {
+                X86CodegenOpcode::Vpxord
+            } else {
+                X86CodegenOpcode::Vxorps
+            }
+        }
+        X86RegisterClass::Byte
+        | X86RegisterClass::ByteRex
+        | X86RegisterClass::Word
+        | X86RegisterClass::Double
+        | X86RegisterClass::Quad => X86CodegenOpcode::Xor,
+        X86RegisterClass::AvxMask => todo!("kreg"),
+        cl => panic!("Cannot xor {:?}", cl),
+    }
+}
+
 fn move_opcode(
     class: X86RegisterClass,
     align: Option<u64>,
@@ -199,6 +233,10 @@ impl Machine for X86Machine {
         for (num, insn) in insns.iter().enumerate() {
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
+                    eprintln!("Current width {:?}", assignments.stack_width);
+                    assignments.stack_width = ((assignments.stack_width + 7) & !15) + 8;
+                    eprintln!("Aligned width width {:?}", assignments.stack_width);
+
                     let callconv = X86CallConvInfo {
                         mode: assignments.mode,
                     };
@@ -227,7 +265,16 @@ impl Machine for X86Machine {
 
                     if let Some(ret) = &locations.ret {
                         match callconv.ret_location() {
-                            CallConvLocation::Null => {}
+                            CallConvLocation::Null => {
+                                assignments.assigns.insert(
+                                    ret.num,
+                                    LocationAssignment {
+                                        foreign_location: X86ValLocation::Null,
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                    },
+                                );
+                            }
                             CallConvLocation::Register(reg) => {
                                 assignments.assigns.insert(
                                     ret.num,
@@ -284,7 +331,7 @@ impl Machine for X86Machine {
                                 );
                             }
                             (None, None) => {
-                                todo!("Allocate register");
+                                todo!("Allocate register {} => {}", old_loc, new_loc);
                             }
                         }
                     }
@@ -334,7 +381,9 @@ impl Machine for X86Machine {
                     }
                 }
                 xlang_backend::ssa::SsaInstruction::Trap(_) => {}
-                xlang_backend::ssa::SsaInstruction::LoadImmediate(_, _) => {}
+                xlang_backend::ssa::SsaInstruction::LoadImmediate(_, _)
+                | xlang_backend::ssa::SsaInstruction::LoadSymAddr(_, _)
+                | xlang_backend::ssa::SsaInstruction::ZeroInit(_) => {}
             }
         }
         clobbers
@@ -429,6 +478,53 @@ impl Machine for X86Machine {
                         }
                     }
                 }
+                xlang_backend::ssa::SsaInstruction::LoadSymAddr(loc, addr) => {
+                    if let Some(location) = cur_locations.get(&loc.num) {
+                        match location {
+                            X86ValLocation::Register(reg) => {
+                                let lea = X86CodegenOpcode::Lea;
+                                let cl = reg.class();
+
+                                encoder.write_insn(X86Instruction::new(
+                                    lea,
+                                    vec![
+                                        X86Operand::Register(*reg),
+                                        X86Operand::Memory(
+                                            cl,
+                                            None,
+                                            X86MemoryOperand::RelAddr(addr.clone()),
+                                        ),
+                                    ],
+                                ))?;
+                            }
+                            X86ValLocation::Null => {}
+                        }
+                    }
+                }
+                xlang_backend::ssa::SsaInstruction::ZeroInit(dest) => {
+                    if let Some(loc) = cur_locations.get(&dest.num) {
+                        match loc {
+                            X86ValLocation::Register(reg) => {
+                                let is_int = match &*dest.ty {
+                                    ir::Type::Scalar(ir::ScalarType {
+                                        kind:
+                                            ir::ScalarTypeKind::Float { .. } | ir::ScalarTypeKind::Posit,
+                                        ..
+                                    }) => false,
+                                    _ => true, // TODO: Be better with heauristics arround aggregate types
+                                };
+
+                                let xor = xor_opcode(reg.class(), is_int);
+
+                                encoder.write_insn(X86Instruction::new(
+                                    xor,
+                                    vec![X86Operand::Register(*reg), X86Operand::Register(*reg)],
+                                ))?;
+                            }
+                            X86ValLocation::Null => {}
+                        }
+                    }
+                }
             }
         }
 
@@ -446,7 +542,7 @@ impl Machine for X86Machine {
                 X86CodegenOpcode::Sub,
                 vec![
                     X86Operand::Register(assignments.sp),
-                    X86Operand::Immediate(-assignments.stack_width as i64),
+                    X86Operand::Immediate(assignments.stack_width as i64),
                 ],
             ))?;
         }
diff --git a/lc-binutils b/lc-binutils
index 5c82a510..4665334c 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 5c82a510059a2bb1cd1e9ad2d29ac7a709a5eaf7
+Subproject commit 4665334c544d00046c4b309d998e3813c99dabf5
diff --git a/xlang/xlang_backend/src/callconv.rs b/xlang/xlang_backend/src/callconv.rs
index a432e364..7d5e33b3 100644
--- a/xlang/xlang_backend/src/callconv.rs
+++ b/xlang/xlang_backend/src/callconv.rs
@@ -243,7 +243,11 @@ pub fn classify_type<I: CallConvInfo>(
         Type::Pointer(ptr) => classes.push(info.classify_pointer(ptr.kind)),
         Type::Array(_) => todo!(),
         Type::TaggedType(_, ty) => classes = classify_type(info, ty, tys),
-        Type::Product(_) => todo!(),
+        Type::Product(vals) => {
+            if vals.len() != 0 {
+                todo!("Aggregate types")
+            }
+        }
         Type::Aligned(_, _) => todo!(),
         Type::Aggregate(_) => todo!(),
         Type::Named(_) => todo!(),
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index 3ec9caf1..435cb3a7 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -2,11 +2,14 @@
 //! A helper crate for implementing [`xlang::plugin::XLangCodegen`]s without duplicating code (also can be used to evaluate constant expressions)
 //! the `xlang_backend` crate provides a general interface for writing expressions to an output.
 
-use std::rc::Rc;
+use core::cell::RefCell;
+
+use std::{io::Write, rc::Rc};
 
 use arch_ops::traits::InsnWrite;
 use mach::Machine;
 use ssa::FunctionBuilder;
+use str::StringMap;
 use ty::TypeInformation;
 use xlang::{
     abi::{io::WriteAdapter, option::Some as XLangSome, pair::Pair, try_},
@@ -85,6 +88,7 @@ pub struct SsaCodegenPlugin<M> {
     mach: Rc<M>,
     targ: Option<&'static TargetProperties<'static>>,
     functions: Vec<(String, FunctionDef<M>)>,
+    string_interner: Rc<RefCell<StringMap>>,
 }
 
 impl<M> SsaCodegenPlugin<M> {
@@ -94,6 +98,7 @@ impl<M> SsaCodegenPlugin<M> {
             mach: Rc::new(mach),
             targ: None,
             functions: Vec::new(),
+            string_interner: Rc::new(RefCell::new(StringMap::new())),
         }
     }
 }
@@ -143,6 +148,7 @@ impl<M: Machine> XLangPlugin for SsaCodegenPlugin<M> {
                             tys.clone(),
                             targ,
                             ty.clone(),
+                            self.string_interner.clone(),
                         );
                         for local in &body.locals {
                             builder.push_local(local.clone());
@@ -248,6 +254,20 @@ impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
                 },
             ];
             let mut syms = vec![];
+            let str_map = self.string_interner.borrow();
+            for (sym, bytes) in str_map.symbols() {
+                let sec = &mut sections[1];
+                let sym = Symbol::new(
+                    sym.to_string(),
+                    1,
+                    sec.offset() as u128,
+                    SymbolType::Object,
+                    SymbolKind::Local,
+                );
+                syms.push(sym);
+                sec.write_all(bytes)
+                    .expect("Section::write should not error");
+            }
 
             for (sym_name, def) in core::mem::take(&mut self.functions) {
                 let sym_kind = match def.linkage {
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 6add935c..9385f654 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -1,12 +1,17 @@
 use core::cell::Cell;
 
+use core::cell::RefCell;
 use std::rc::Rc;
 
 use crate::expr::*;
 use crate::mach::Machine;
 use crate::ty::TypeInformation;
 
+use crate::str::StringMap;
+
+use arch_ops::traits::Address;
 use arch_ops::traits::InsnWrite;
+use xlang::abi::pair::Pair;
 use xlang::{ir::JumpTarget, targets::properties::TargetProperties};
 
 use xlang::ir;
@@ -54,6 +59,10 @@ pub enum SsaInstruction {
     Trap(Trap),
     /// Loads a scalar immediate value into the given [`OpaqueLocation`]
     LoadImmediate(OpaqueLocation, u128),
+    /// Loads an address
+    LoadSymAddr(OpaqueLocation, Address),
+    /// Initializes a (potentially large) memory location with zeroes
+    ZeroInit(OpaqueLocation),
 }
 
 impl core::fmt::Display for SsaInstruction {
@@ -118,6 +127,10 @@ impl core::fmt::Display for SsaInstruction {
             SsaInstruction::LoadImmediate(dest, val) => {
                 f.write_fmt(format_args!("loadimm {}, {}", dest, val))
             }
+            SsaInstruction::LoadSymAddr(dest, addr) => {
+                f.write_fmt(format_args!("loadsymaddr {}, {}", dest, addr))
+            }
+            SsaInstruction::ZeroInit(dest) => f.write_fmt(format_args!("zeroinit {}", dest)),
         }
     }
 }
@@ -199,6 +212,7 @@ pub struct FunctionBuilder<M> {
     incoming_locations: HashMap<u32, Vec<OpaqueLocation>>,
     incoming_count: Rc<HashMap<u32, usize>>,
     fnty: Rc<ir::FnType>,
+    string_interner: Rc<RefCell<StringMap>>,
 }
 
 impl<M> FunctionBuilder<M> {
@@ -211,6 +225,7 @@ impl<M> FunctionBuilder<M> {
         tys: Rc<TypeInformation>,
         target: &'static TargetProperties<'static>,
         fnty: Rc<ir::FnType>,
+        string_interner: Rc<RefCell<StringMap>>,
     ) -> Self {
         Self {
             sym_name,
@@ -223,6 +238,7 @@ impl<M> FunctionBuilder<M> {
             incoming_locations: HashMap::new(),
             fnty,
             incoming_count: Rc::new(HashMap::new()),
+            string_interner,
         }
     }
 
@@ -286,6 +302,7 @@ impl<M> FunctionBuilder<M> {
             vstack,
             incoming_count: self.incoming_count.clone(),
             loc_id_counter: self.loc_id_counter.clone(),
+            string_interner: self.string_interner.clone(),
         };
 
         self.basic_blocks.push_mut(builder)
@@ -367,6 +384,7 @@ pub struct BasicBlockBuilder<M> {
     vstack: Vec<VStackValue<OpaqueLocation>>,
     incoming_count: Rc<HashMap<u32, usize>>,
     loc_id_counter: Rc<SharedCounter>,
+    string_interner: Rc<RefCell<StringMap>>,
 }
 
 impl<M: Machine> BasicBlockBuilder<M> {
@@ -382,14 +400,47 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 }
                 ir::Value::GlobalAddress { .. } => todo!(),
                 ir::Value::ByteString { .. } => todo!(),
-                ir::Value::String { .. } => todo!("{}", loc),
+                ir::Value::String {
+                    encoding,
+                    utf8,
+                    ty: ir::Type::Pointer(_),
+                } => {
+                    let mut string_map = self.string_interner.borrow_mut();
+                    let sym = string_map.get_string_symbol(
+                        utf8.into_bytes(),
+                        crate::str::Encoding::XLang(encoding),
+                    );
+
+                    self.insns.push(SsaInstruction::LoadSymAddr(
+                        loc,
+                        Address::Symbol {
+                            name: sym.to_string(),
+                            disp: 0,
+                        },
+                    ));
+                }
+                ir::Value::String { ty, .. } => todo!("String const as {}", ty),
                 ir::Value::LabelAddress(_) => todo!(),
                 ir::Value::Empty => panic!("Empty IR value"),
             },
             VStackValue::LValue(_, _) => todo!(),
             VStackValue::Pointer(_, _) => todo!(),
             VStackValue::OpaqueScalar(_, _) => todo!(),
-            VStackValue::AggregatePieced(_, _) => todo!(),
+            VStackValue::AggregatePieced(ty, fields) => {
+                let aggregate_info = self
+                    .tys
+                    .aggregate_layout(&ty)
+                    .expect("Required a aggregate type");
+                self.insns.push(SsaInstruction::ZeroInit(loc.clone()));
+                for Pair(field, val) in fields {
+                    todo!(
+                        "{} (offset {}): {}",
+                        field,
+                        aggregate_info.fields[&field].0,
+                        val
+                    );
+                }
+            }
             VStackValue::OpaqueAggregate(_, _) => todo!(),
             VStackValue::CompareResult(_, _) => todo!(),
             VStackValue::Trapped => todo!(),
@@ -645,7 +696,20 @@ impl<M: Machine> BasicBlockBuilder<M> {
                 self.push_values(first);
                 self.push_values(second);
             }
-            ir::Expr::Aggregate(_) => todo!("aggregate"),
+            ir::Expr::Aggregate(ctor) => {
+                let ty = ctor.ty.clone();
+
+                let field_vals = self.pop_values(ctor.fields.len());
+
+                let fields = ctor
+                    .fields
+                    .iter()
+                    .map(|s| s.to_string())
+                    .zip(field_vals)
+                    .collect();
+
+                self.push(VStackValue::AggregatePieced(ty, fields));
+            }
             ir::Expr::Member(_) => todo!("member"),
             ir::Expr::MemberIndirect(_) => todo!("member indirect"),
             ir::Expr::Assign(_) => todo!("assign"),
diff --git a/xlang/xlang_backend/src/str.rs b/xlang/xlang_backend/src/str.rs
index 84eb4807..132c355d 100644
--- a/xlang/xlang_backend/src/str.rs
+++ b/xlang/xlang_backend/src/str.rs
@@ -90,7 +90,7 @@ impl StringMap {
     }
 
     /// Obtains a symbol for the given string, interning the content if necessary
-    pub fn get_string_symbol(&mut self, bytes: Vec<u8>, enc: Encoding) -> String {
+    pub fn get_string_symbol(&mut self, bytes: Vec<u8>, enc: Encoding) -> &str {
         let StringInterner { map, idx } =
             self.inner.get_or_insert_with_mut(enc, |_| StringInterner {
                 map: HashMap::new(),
@@ -118,17 +118,15 @@ impl StringMap {
                 st
             )
         })
-        .clone()
     }
 
     /// Enumerates all of the symbols in the file
-    pub fn symbols(&self) -> impl Iterator<Item = (Encoding, &str, &[u8])> {
-        self.inner.iter().flat_map(|Pair(enc, intern)| {
-            let enc = *enc;
+    pub fn symbols(&self) -> impl Iterator<Item = (&str, &[u8])> {
+        self.inner.iter().flat_map(|Pair(_, intern)| {
             intern
                 .map
                 .iter()
-                .map(move |Pair(bytes, sym)| (enc, &**sym, &**bytes))
+                .map(move |Pair(bytes, sym)| (&**sym, &**bytes))
         })
     }
 }

From 955a3ebcf52cd7955448554300047a514d670a9f Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 10 Mar 2024 21:34:49 -0500
Subject: [PATCH 38/74] feat(rust-mir): add fallthrough handling, propagate to
 xir

---
 rust/rust_mir_macro/src/parse.rs | 13 ++++++++++++-
 rust/src/irgen/visitor.rs        |  4 ++++
 rust/src/irgen/xir_visitor.rs    |  4 ++++
 rust/src/sema.rs                 |  2 +-
 rust/src/sema/mir.rs             | 15 ++++++++++++++-
 rust/src/sema/mir_defs.rs        |  1 +
 6 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/rust/rust_mir_macro/src/parse.rs b/rust/rust_mir_macro/src/parse.rs
index de6a9cac..8a6595aa 100644
--- a/rust/rust_mir_macro/src/parse.rs
+++ b/rust/rust_mir_macro/src/parse.rs
@@ -1292,6 +1292,13 @@ pub fn do_jump_target<I: Iterator<Item = TokenTree>>(
     dollar_crate: &TokenStream,
 ) -> Result<TokenStream> {
     with_rewinder_accept_on_continue(tokens, |tree| {
+        let fallthrough = do_keyword(tree, "fallthrough");
+
+        let fallthrough = match fallthrough {
+            Ok(span) => TokenStream::from(TokenTree::Ident(Ident::new("true", span))),
+            Err(x) => TokenStream::from(TokenTree::Ident(Ident::new("false", x.span))),
+        };
+
         let target = do_basic_block_id(tree, dollar_crate)?;
 
         let inner_tree = do_group(tree, Some(Delimiter::Bracket))?;
@@ -1351,7 +1358,11 @@ pub fn do_jump_target<I: Iterator<Item = TokenTree>>(
         write_constructor(
             &mut output,
             Span::call_site(),
-            [("targbb", target), ("remaps", remaps)],
+            [
+                ("targbb", target),
+                ("remaps", remaps),
+                ("fallthrough", fallthrough),
+            ],
         );
 
         Ok(output)
diff --git a/rust/src/irgen/visitor.rs b/rust/src/irgen/visitor.rs
index 02a4806b..2ced0a25 100644
--- a/rust/src/irgen/visitor.rs
+++ b/rust/src/irgen/visitor.rs
@@ -411,6 +411,9 @@ pub fn visit_jump<V: JumpVisitor>(mut visitor: V, info: &mir::MirJumpInfo) {
     for remap in &info.remaps {
         visitor.visit_remap(remap.0, remap.1);
     }
+    if info.fallthrough {
+        visitor.visit_fallthrough();
+    }
 }
 
 pub fn visit_fnty<V: FunctionTyVisitor>(mut visitor: V, fnty: &ty::FnType, defs: &Definitions) {
@@ -847,6 +850,7 @@ def_visitors! {
     pub trait JumpVisitor {
         fn visit_target_bb(&mut self, targbb: mir::BasicBlockId);
         fn visit_remap(&mut self, src: mir::SsaVarId, targ: mir::SsaVarId);
+        fn visit_fallthrough(&mut self);
     }
 
     pub trait TerminatorVisitor {
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 7bfd21e6..dfef603f 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1296,6 +1296,10 @@ impl<'a> JumpVisitor for XirJumpVisitor<'a> {
             self.exprs.push(ir::Expr::Pivot(depth, 1));
         }
     }
+
+    fn visit_fallthrough(&mut self) {
+        self.targ.flags |= ir::JumpTargetFlags::FALLTHROUGH;
+    }
 }
 
 pub struct XirCallVisitor<'a> {
diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index 4175080b..6cd2528b 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -3868,7 +3868,7 @@ pub fn convert_crate(
         } else {
             mir::mir! {
                 @0: { []
-                    call _0 = #<main>: <fnty>() next @1 []
+                    call _0 = #<main>: <fnty>() next fallthrough @1 []
                 }
                 @1: { [_0: <retty>]
                     store dead _0;
diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index 35eea8de..f1dae6f2 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -261,6 +261,10 @@ impl core::fmt::Display for MirTailcallInfo {
 
 impl core::fmt::Display for MirJumpInfo {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        if self.fallthrough {
+            f.write_str("fallthrough ")?;
+        }
+
         self.targbb.fmt(f)?;
         f.write_str(" [")?;
 
@@ -1068,6 +1072,7 @@ impl<'a> MirConverter<'a> {
         MirJumpInfo {
             targbb: bb_id,
             remaps,
+            fallthrough: self.cur_basic_block.id.0 + 1 == bb_id.0,
         }
     }
 
@@ -1109,6 +1114,7 @@ impl<'a> MirConverter<'a> {
             MirJumpInfo {
                 targbb: bb_id,
                 remaps,
+                fallthrough: self.cur_basic_block.id.0 + 1 == bb_id.0,
             },
             assignments,
             incoming_vars,
@@ -1186,7 +1192,14 @@ impl<'a> MirConverter<'a> {
                 }
             }
 
-            jump_map.push((reinit_stat, MirJumpInfo { targbb, remaps }))
+            jump_map.push((
+                reinit_stat,
+                MirJumpInfo {
+                    targbb,
+                    remaps,
+                    fallthrough: self.cur_basic_block.id.0 + 1 == targbb.0,
+                },
+            ))
         }
 
         (jump_map, new_assignments, incoming)
diff --git a/rust/src/sema/mir_defs.rs b/rust/src/sema/mir_defs.rs
index c151bf97..c7ee2d29 100644
--- a/rust/src/sema/mir_defs.rs
+++ b/rust/src/sema/mir_defs.rs
@@ -138,6 +138,7 @@ pub struct MirBranchInfo {
 pub struct MirJumpInfo {
     pub targbb: BasicBlockId,
     pub remaps: Vec<(SsaVarId, SsaVarId)>,
+    pub fallthrough: bool,
 }
 
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]

From 9fb17d1064745f8a8f9e8307971be9983249e088 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 16 May 2024 23:15:58 -0400
Subject: [PATCH 39/74] feat(rust): Redo branch lowering from AST

---
 .gitmodules                                |   5 +-
 Cargo.lock                                 |  20 +-
 rust/Cargo.toml                            |   2 +-
 rust/src/irgen/visitor.rs                  |  16 +-
 rust/src/irgen/xir_visitor.rs              |  40 +-
 rust/src/lang.rs                           |  10 +
 rust/src/sema.rs                           |  23 +-
 rust/src/sema/hir.rs                       | 253 +++++----
 rust/src/sema/intrin_defs.rs               |   1 +
 rust/src/sema/mir.rs                       | 607 ++++++++++-----------
 rust/src/sema/mir/transform.rs             |   6 +-
 rust/src/sema/mir/transform/fallthrough.rs |  59 ++
 rust/src/sema/mir_defs.rs                  |   7 +-
 rust/src/sema/ty.rs                        | 121 ++--
 rust/src/sema/tyck.rs                      | 357 ++++++------
 15 files changed, 847 insertions(+), 680 deletions(-)
 create mode 100644 rust/src/sema/mir/transform/fallthrough.rs

diff --git a/.gitmodules b/.gitmodules
index 3aa2b241..11889b1c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -9,4 +9,7 @@
 	url = https://github.com/lccc-project/rtlibs.git
 [submodule "autobuild"]
 	path = autobuild
-	url = https://github.com/lccc-project/autobuild.git
\ No newline at end of file
+	url = https://github.com/lccc-project/autobuild.git
+[submodule "lcrust/libraries/lccc-siphash"]
+	path = lcrust/libraries/lccc-siphash
+	url = https://github.com/lccc-project/lccc-siphash.git
diff --git a/Cargo.lock b/Cargo.lock
index 6ba04cb3..f2ececf1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,7 +17,9 @@ dependencies = [
 name = "autobuild"
 version = "0.1.0"
 dependencies = [
+ "bytemuck",
  "cfg-match",
+ "hashbrown",
  "install-dirs 0.3.2",
  "lccc-siphash",
  "libc",
@@ -34,6 +36,7 @@ name = "binfmt"
 version = "0.1.0"
 dependencies = [
  "arch-ops",
+ "bitflags 2.5.0",
  "bytemuck",
  "fake-enum",
  "lazy_static",
@@ -47,11 +50,20 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "bytemuck"
-version = "1.13.1"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
+checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -311,7 +323,7 @@ name = "rlib"
 version = "0.1.0"
 dependencies = [
  "binfmt",
- "bitflags",
+ "bitflags 1.3.2",
  "bytemuck",
 ]
 
@@ -635,7 +647,7 @@ dependencies = [
 name = "xlang_struct"
 version = "0.2.0"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "fake-enum",
  "xlang_abi",
  "xlang_targets",
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index d3a496dd..d0f297e5 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "frontend-rust"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/rust/src/irgen/visitor.rs b/rust/src/irgen/visitor.rs
index 2ced0a25..219810e1 100644
--- a/rust/src/irgen/visitor.rs
+++ b/rust/src/irgen/visitor.rs
@@ -394,12 +394,8 @@ pub fn visit_branch<V: BranchVisitor>(
         return;
     }
 
-    for cond in &info.conds {
-        let mut branch_arm_visitor = visitor.visit_branch_arm();
-        visit_expr(branch_arm_visitor.visit_cond(), &cond.0, defs);
-        visit_jump(branch_arm_visitor.visit_jump(), &cond.1);
-    }
-
+    visit_expr(visitor.visit_cond(), &info.cond, defs);
+    visit_jump(visitor.visit_if_arm(), &info.if_block);
     visit_jump(visitor.visit_else(), &info.else_block);
 }
 
@@ -838,13 +834,9 @@ def_visitors! {
     }
 
     pub trait BranchVisitor {
-        fn visit_branch_arm(&mut self) -> Option<Box<dyn BranchArmVisitor + '_>>;
-        fn visit_else(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
-    }
-
-    pub trait BranchArmVisitor {
         fn visit_cond(&mut self) -> Option<Box<dyn ExprVisitor + '_>>;
-        fn visit_jump(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
+        fn visit_if_arm(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
+        fn visit_else(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
     }
 
     pub trait JumpVisitor {
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index dfef603f..cabd5ab2 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -30,13 +30,13 @@ use crate::{
 use crate::{lex::StringType, sema::Definitions};
 
 use super::visitor::{
-    ArrayTyVisitor, AttrVisitor, BasicBlockVisitor, BinaryExprVisitor, BranchArmVisitor,
-    BranchVisitor, CallVisitor, CastVisitor, ConstCharVisitor, ConstIntVisitor, ConstStringVisitor,
-    ConstructorDefVisitor, ConstructorVisitor, ExprVisitor, FieldAccessVisitor, FieldInitVisitor,
-    FieldVisitor, FunctionBodyVisitor, FunctionDefVisitor, FunctionTyVisitor, IntTyVisitor,
-    JumpVisitor, LetStatementVisitor, ModVisitor, PointerTyVisitor, ReferenceTyVisitor,
-    StatementVisitor, TailcallVisitor, TerminatorVisitor, TupleExprVisitor, TupleTyVisitor,
-    TypeDefVisitor, TypeVisitor, UnaryExprVisitor, ValueDefVisitor,
+    ArrayTyVisitor, AttrVisitor, BasicBlockVisitor, BinaryExprVisitor, BranchVisitor, CallVisitor,
+    CastVisitor, ConstCharVisitor, ConstIntVisitor, ConstStringVisitor, ConstructorDefVisitor,
+    ConstructorVisitor, ExprVisitor, FieldAccessVisitor, FieldInitVisitor, FieldVisitor,
+    FunctionBodyVisitor, FunctionDefVisitor, FunctionTyVisitor, IntTyVisitor, JumpVisitor,
+    LetStatementVisitor, ModVisitor, PointerTyVisitor, ReferenceTyVisitor, StatementVisitor,
+    TailcallVisitor, TerminatorVisitor, TupleExprVisitor, TupleTyVisitor, TypeDefVisitor,
+    TypeVisitor, UnaryExprVisitor, ValueDefVisitor,
 };
 use super::NameMap;
 
@@ -1200,6 +1200,7 @@ impl<'a> TerminatorVisitor for XirTerminatorVisitor<'a> {
             self.stack_height,
             self.var_heights,
             self.var_stack,
+            0,
         )))
     }
 
@@ -1234,6 +1235,8 @@ pub struct XirJumpVisitor<'a> {
     stack_height: &'a mut u32,
     var_heights: &'a mut HashMap<SsaVarId, u32>,
     var_stack: &'a mut Vec<SsaVarId>,
+    volatile_vals: u32,
+    remapped_var_count: u32,
 }
 
 impl<'a> XirJumpVisitor<'a> {
@@ -1250,6 +1253,7 @@ impl<'a> XirJumpVisitor<'a> {
         stack_height: &'a mut u32,
         var_heights: &'a mut HashMap<SsaVarId, u32>,
         var_stack: &'a mut Vec<SsaVarId>,
+        volatile_vals: u32,
     ) -> Self {
         Self {
             defs,
@@ -1264,6 +1268,8 @@ impl<'a> XirJumpVisitor<'a> {
             stack_height,
             var_heights,
             var_stack,
+            volatile_vals,
+            remapped_var_count: 0,
         }
     }
 }
@@ -1293,8 +1299,9 @@ impl<'a> JumpVisitor for XirJumpVisitor<'a> {
         let depth = (*self.stack_height) - (height + 1);
 
         if depth != 0 {
-            self.exprs.push(ir::Expr::Pivot(depth, 1));
+            self.exprs.push(ir::Expr::Pivot(1, depth));
         }
+        self.remapped_var_count += 1;
     }
 
     fn visit_fallthrough(&mut self) {
@@ -1302,6 +1309,15 @@ impl<'a> JumpVisitor for XirJumpVisitor<'a> {
     }
 }
 
+impl<'a> Drop for XirJumpVisitor<'a> {
+    fn drop(&mut self) {
+        if self.remapped_var_count != 0 && self.volatile_vals != 0 {
+            self.exprs
+                .push(ir::Expr::Pivot(self.volatile_vals, self.remapped_var_count));
+        }
+    }
+}
+
 pub struct XirCallVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
@@ -1317,6 +1333,7 @@ pub struct XirCallVisitor<'a> {
     late_bound_intrinsic: Option<IntrinsicDef>,
     fnty: ir::FnType,
     targ: Option<ir::JumpTarget>,
+    param_count: u32,
 }
 
 impl<'a> XirCallVisitor<'a> {
@@ -1348,6 +1365,7 @@ impl<'a> XirCallVisitor<'a> {
             late_bound_intrinsic: None,
             fnty: ir::FnType::default(),
             targ: None,
+            param_count: 0,
         }
     }
 }
@@ -1381,6 +1399,7 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
     }
 
     fn visit_param(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        self.param_count += 1;
         Some(Box::new(XirExprVisitor::new(
             self.defs,
             self.names,
@@ -1413,6 +1432,7 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
             self.stack_height,
             self.var_heights,
             self.var_stack,
+            self.param_count + 1,
         )))
     }
 
@@ -1717,11 +1737,11 @@ impl<'a> ExprVisitor for XirExprVisitor<'a> {
         let depth = (*self.stack_height) - (height + 1);
 
         if depth != 0 {
-            self.exprs.push(ir::Expr::Pivot(depth, 1));
+            self.exprs.push(ir::Expr::Pivot(1, depth));
         }
         self.exprs.push(ir::Expr::Dup(1));
         if depth != 0 {
-            self.exprs.push(ir::Expr::Pivot(1, depth + 1));
+            self.exprs.push(ir::Expr::Pivot(depth + 1, 1));
         }
     }
 
diff --git a/rust/src/lang.rs b/rust/src/lang.rs
index d5eab50c..452058d6 100644
--- a/rust/src/lang.rs
+++ b/rust/src/lang.rs
@@ -77,6 +77,16 @@ define_lang_items! {
     F64: f64 @ ImplBlock,
     F32Rt: f32_rt @ ImplBlock,
     F64Rt: f64_rt @ ImplBlock,
+    F16: f16 @ ImplBlock,
+    F128: f128 @ ImplBlock,
+    F16Rt: f16_rt @ ImplBlock,
+    F128Rt: f128_rt @ ImplBlock,
+    Bf16: bf16 @ ImplBlock,
+    Bf16Rt: bf16_rt @ ImplBlock,
+    Fx80: fx80 @ ImplBlock,
+    Fx80Rt: fx80_rt @ ImplBlock,
+    Fd128: fd128 @ ImplBlock,
+    Fd128Rt: fd128_rt @ ImplBlock,
     ConstPtr: const_ptr @ ImplBlock,
     MutPtr: mut_ptr @ ImplBlock,
     Char: char @ ImplBlock,
diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index 6cd2528b..d2649e6d 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -1527,24 +1527,15 @@ impl Definitions {
                         niches: None,
                     }
                 }
-                Type::Float(width) => {
-                    let (size, align) = match width {
-                        ty::FloatWidth::Bits(bits) => {
-                            let max_align = self.properties.primitives.max_align;
-                            let width = bits.get();
-                            let size = width >> 8;
+                Type::Float(fty) => {
+                    let (size, align) = {
+                        let max_align = self.properties.primitives.max_align;
+                        let width = fty.width.get();
+                        let size = width >> 8;
 
-                            let align = size.min(max_align);
+                        let align = size.next_power_of_two().min(max_align);
 
-                            (size as u64, align as u64)
-                        }
-                        ty::FloatWidth::Long => {
-                            let align = self.properties.primitives.ldbl_align;
-                            let size = self.properties.primitives.ldbl_format.size();
-
-                            let real_size = (size + (align - 1)) & !(align - 1);
-                            (real_size as u64, align as u64)
-                        }
+                        (size as u64, align as u64)
                     };
 
                     ty::TypeLayout {
diff --git a/rust/src/sema/hir.rs b/rust/src/sema/hir.rs
index 5b537b68..c8117048 100644
--- a/rust/src/sema/hir.rs
+++ b/rust/src/sema/hir.rs
@@ -219,9 +219,8 @@ pub enum HirBlock {
     Loop(HirSimpleBlock),
     If {
         cond: Spanned<HirExpr>,
-        block: HirSimpleBlock,
-        elseifs: Vec<(Spanned<HirExpr>, HirSimpleBlock)>,
-        elseblock: HirSimpleBlock,
+        block: Box<Spanned<HirBlock>>,
+        elseblock: Option<Box<Spanned<HirBlock>>>,
     },
     Match(HirMatch),
 }
@@ -382,6 +381,81 @@ impl HirFunctionBody {
         Ok(())
     }
 
+    fn display_block(
+        &self,
+        block: &HirBlock,
+        f: &mut core::fmt::Formatter,
+        tabs: TabPrinter,
+    ) -> core::fmt::Result {
+        use core::fmt::Display;
+        match &block {
+            HirBlock::Normal(stmts) => {
+                f.write_str("{\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            HirBlock::Unsafe(stmts) => {
+                f.write_str("unsafe {\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            HirBlock::Loop(stmts) => {
+                f.write_str("loop {\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            HirBlock::If {
+                cond,
+                block,
+                elseblock,
+            } => {
+                write!(f, "if {} ", cond.body)?;
+                self.display_block(block, f, tabs)?;
+                if let Some(elseblk) = elseblock {
+                    write!(f, "{}else ", tabs)?;
+                    self.display_block(elseblk, f, tabs)
+                } else {
+                    Ok(())
+                }
+            }
+            HirBlock::Match(m) => {
+                let nested = tabs.nest();
+                write!(f, "match {} {{\n", m.discriminee.body)?;
+                for arm in &m.arms {
+                    nested.fmt(f)?;
+                    let subnested = nested.nest();
+                    arm.pattern.body.fmt(f)?;
+
+                    if let Some(guard) = &arm.guard {
+                        write!(f, "if {}", guard.body)?;
+                    }
+
+                    f.write_str(" => {\n")?;
+
+                    for stmt in &arm.expansion.body {
+                        self.display_statement(stmt, f, subnested)?;
+                    }
+                    nested.fmt(f)?;
+                    f.write_str("}\n")?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+        }
+    }
+
     fn display_statement(
         &self,
         stmt: &HirStatement,
@@ -409,91 +483,10 @@ impl HirFunctionBody {
             HirStatement::Return(expr) => {
                 f.write_fmt(format_args!("{}return {};\n", tabs, expr.body))
             }
-            HirStatement::Block(b) => match &b.body {
-                HirBlock::Normal(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("{\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                HirBlock::Unsafe(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("unsafe {\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                HirBlock::Loop(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("loop {\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                HirBlock::If {
-                    cond,
-                    block,
-                    elseifs,
-                    elseblock,
-                } => {
-                    tabs.fmt(f)?;
-                    write!(f, "if {} {{\n", cond.body)?;
-                    let nested = tabs.nest();
-                    for stmt in block {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    for (cond, block) in elseifs {
-                        tabs.fmt(f)?;
-                        write!(f, "}} else if {} {{\n", cond.body)?;
-                        for stmt in block {
-                            self.display_statement(stmt, f, nested)?;
-                        }
-                    }
-                    if elseblock.len() > 0 {
-                        tabs.fmt(f)?;
-                        f.write_str("} else {\n")?;
-                        for stmt in elseblock {
-                            self.display_statement(stmt, f, nested)?;
-                        }
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                HirBlock::Match(m) => {
-                    tabs.fmt(f)?;
-                    let nested = tabs.nest();
-                    write!(f, "match {} {{\n", m.discriminee.body)?;
-                    for arm in &m.arms {
-                        nested.fmt(f)?;
-                        let subnested = nested.nest();
-                        arm.pattern.body.fmt(f)?;
-
-                        if let Some(guard) = &arm.guard {
-                            write!(f, "if {}", guard.body)?;
-                        }
-
-                        f.write_str(" => {\n")?;
-
-                        for stmt in &arm.expansion.body {
-                            self.display_statement(stmt, f, subnested)?;
-                        }
-                        nested.fmt(f)?;
-                        f.write_str("}\n")?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-            },
+            HirStatement::Block(b) => {
+                tabs.fmt(f)?;
+                self.display_block(b, f, tabs)
+            }
             HirStatement::Discard(expr) => f.write_fmt(format_args!("{}{};\n", tabs, expr.body)),
             HirStatement::Call {
                 retplace,
@@ -1113,12 +1106,16 @@ impl<'a> HirLowerer<'a> {
                         },
                         &if_blk.block,
                     )?;
-                    let block = lowerer.stmts;
+
+                    let block = Spanned {
+                        body: HirBlock::Normal(lowerer.stmts),
+                        span: if_blk.block.span,
+                    };
+
                     self.nexthirvarid = lowerer.nexthirvarid;
 
-                    let mut elseifs = Vec::new();
+                    let mut partial_blocks = Vec::new();
                     for elseif in &if_blk.elseifs {
-                        let cond = self.desugar_expr(&elseif.cond)?;
                         let mut lowerer = HirLowerer::new(
                             self.defs,
                             self.atitem,
@@ -1129,7 +1126,30 @@ impl<'a> HirLowerer<'a> {
                         );
                         lowerer.nexthirvarid = self.nexthirvarid;
                         lowerer.varnames = self.varnames.clone();
-                        lowerer.desugar_block(
+                        let cond = lowerer.desugar_expr(&elseif.cond)?;
+
+                        let preamble_stmts = if lowerer.stmts.is_empty() {
+                            None
+                        } else {
+                            Some(lowerer.stmts)
+                        };
+
+                        self.nexthirvarid = lowerer.nexthirvarid;
+
+                        let mut inner_lowerer = HirLowerer::new(
+                            self.defs,
+                            self.atitem,
+                            self.curmod,
+                            self.vardebugmap,
+                            self.selfty,
+                            self.localitems,
+                        );
+
+                        inner_lowerer.nexthirvarid = self.nexthirvarid;
+
+                        inner_lowerer.varnames = self.varnames.clone();
+
+                        inner_lowerer.desugar_block(
                             if let Some(ret) = &mut ret {
                                 Some(ret)
                             } else {
@@ -1137,11 +1157,24 @@ impl<'a> HirLowerer<'a> {
                             },
                             &elseif.block,
                         )?;
-                        elseifs.push((cond, lowerer.stmts));
-                        self.nexthirvarid = lowerer.nexthirvarid;
+
+                        self.nexthirvarid = inner_lowerer.nexthirvarid;
+
+                        partial_blocks.push((
+                            preamble_stmts,
+                            elseif.copy_span(|_| HirBlock::If {
+                                cond: cond,
+                                block: Box::new(
+                                    elseif
+                                        .block
+                                        .copy_span(|_| HirBlock::Normal(inner_lowerer.stmts)),
+                                ),
+                                elseblock: None,
+                            }),
+                        ))
                     }
 
-                    let elseblock = if let Some(x) = if_blk.elseblock.as_ref() {
+                    let mut elseblock = if let Some(x) = if_blk.elseblock.as_ref() {
                         let mut lowerer = HirLowerer::new(
                             self.defs,
                             self.atitem,
@@ -1164,16 +1197,36 @@ impl<'a> HirLowerer<'a> {
                         )?;
                         self.nexthirvarid = lowerer.nexthirvarid;
 
-                        lowerer.stmts
+                        Some(x.copy_span(|_| HirBlock::Normal(lowerer.stmts)))
                     } else {
-                        Vec::new()
+                        None
                     };
 
+                    for (preamble, mut block) in partial_blocks.into_iter().rev() {
+                        match &mut block.body {
+                            HirBlock::If {
+                                elseblock: elseblk, ..
+                            } => *elseblk = elseblock.map(Box::new),
+                            _ => unreachable!(),
+                        }
+
+                        if let Some(mut preamble) = preamble {
+                            let span = block.span;
+                            let stmt = HirStatement::Block(block);
+                            preamble.push(Spanned { body: stmt, span });
+                            block = Spanned {
+                                body: HirBlock::Normal(preamble),
+                                span,
+                            };
+                        }
+
+                        elseblock = Some(block);
+                    }
+
                     let if_block = HirBlock::If {
                         cond,
-                        block,
-                        elseifs,
-                        elseblock,
+                        block: Box::new(block),
+                        elseblock: elseblock.map(Box::new),
                     };
                     self.stmts.push(
                         stmt.copy_span(|_| HirStatement::Block(if_blk.copy_span(|_| if_block))),
diff --git a/rust/src/sema/intrin_defs.rs b/rust/src/sema/intrin_defs.rs
index e0a1a01a..1f7a5ff8 100644
--- a/rust/src/sema/intrin_defs.rs
+++ b/rust/src/sema/intrin_defs.rs
@@ -28,6 +28,7 @@ def_intrinsics! {
     intrin __builtin_likely(bool) -> bool;
     intrin __builtin_unlikely(bool) -> bool;
 
+    intrin __builtin_cmp<type, type>(Var<0>, Var<0>) -> Var<1>;
 
     intrin __builtin_fadd_fast<type>(Var<0>, Var<0>) -> Var<0>;
     intrin __builtin_fsub_fast<type>(Var<0>, Var<0>) -> Var<0>;
diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index f1dae6f2..5fd9d060 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -16,7 +16,7 @@ use super::{
     hir::HirVarId,
     intrin::IntrinsicDef,
     ty::{FieldName, FnType, IntType, Type},
-    tyck::{Movability, ThirExpr, ThirExprInner, ThirStatement, ThirVarDef},
+    tyck::{Movability, ThirBlock, ThirExpr, ThirExprInner, ThirStatement, ThirVarDef},
     DefId, Definitions, SemaHint, Spanned,
 };
 
@@ -47,12 +47,22 @@ impl BasicBlockId {
         self.0
     }
 
+    pub const fn is_successor(self, other: BasicBlockId) -> bool {
+        other.0 != !0 && self.0.saturating_add(1) == other.0
+    }
+
     #[doc(hidden)]
     pub const fn __new_unchecked(x: u32) -> Self {
         Self(x)
     }
 }
 
+impl Default for BasicBlockId {
+    fn default() -> Self {
+        Self::UNUSED
+    }
+}
+
 impl core::borrow::Borrow<u32> for BasicBlockId {
     fn borrow(&self) -> &u32 {
         &self.0
@@ -393,21 +403,14 @@ impl MirFunctionBody {
             MirTerminator::Return(expr) => f.write_fmt(format_args!("return {}", expr.body)),
             MirTerminator::Jump(jmp) => f.write_fmt(format_args!("jump {}", jmp)),
             MirTerminator::Unreachable => f.write_str("unreachable"),
-            MirTerminator::ResumeUnwind => f.write_str("resume_unwind"),
+            MirTerminator::Resume => f.write_str("resume"),
             MirTerminator::DropInPlace(drop) => f.write_fmt(format_args!("drop_in_place {}", drop)),
             MirTerminator::Branch(branch) => {
-                f.write_str("branch {")?;
-
-                let mut sep = "";
-
-                for (cond, targ) in &branch.conds {
-                    f.write_str(sep)?;
-                    sep = ", ";
-                    cond.body.fmt(f)?;
-                    f.write_str(" then ")?;
-                    targ.fmt(f)?;
-                }
-                f.write_str("} else ")?;
+                f.write_str("branch if ")?;
+                branch.cond.body.fmt(f)?;
+                f.write_str(" then ")?;
+                branch.if_block.fmt(f)?;
+                f.write_str(" else ")?;
                 branch.else_block.fmt(f)
             }
             MirTerminator::SwitchInt(s) => {
@@ -1072,7 +1075,7 @@ impl<'a> MirConverter<'a> {
         MirJumpInfo {
             targbb: bb_id,
             remaps,
-            fallthrough: self.cur_basic_block.id.0 + 1 == bb_id.0,
+            fallthrough: false,
         }
     }
 
@@ -1084,6 +1087,7 @@ impl<'a> MirConverter<'a> {
         HashMap<HirVarId, HirVarAssignment>,
         Vec<(SsaVarId, Type)>,
     ) {
+        println!("{}", bb_id);
         let mut assignments = HashMap::new();
         let mut remaps = Vec::new();
         let mut incoming_vars = Vec::new();
@@ -1114,7 +1118,7 @@ impl<'a> MirConverter<'a> {
             MirJumpInfo {
                 targbb: bb_id,
                 remaps,
-                fallthrough: self.cur_basic_block.id.0 + 1 == bb_id.0,
+                fallthrough: false,
             },
             assignments,
             incoming_vars,
@@ -1123,7 +1127,7 @@ impl<'a> MirConverter<'a> {
 
     fn make_many_jumps(
         &mut self,
-        assign_sets: &Vec<HashMap<HirVarId, HirVarAssignment>>,
+        assign_sets: &[HashMap<HirVarId, HirVarAssignment>],
         targbb: BasicBlockId,
     ) -> (
         Vec<(Vec<MirStatement>, MirJumpInfo)>,
@@ -1197,7 +1201,7 @@ impl<'a> MirConverter<'a> {
                 MirJumpInfo {
                     targbb,
                     remaps,
-                    fallthrough: self.cur_basic_block.id.0 + 1 == targbb.0,
+                    fallthrough: false,
                 },
             ))
         }
@@ -1205,345 +1209,340 @@ impl<'a> MirConverter<'a> {
         (jump_map, new_assignments, incoming)
     }
 
-    pub fn write_statement(&mut self, thir_stat: Spanned<ThirStatement>) -> super::Result<()> {
-        if self.cur_basic_block.id == BasicBlockId::UNUSED {
-            return Ok(()); // short circuit out if we're unreachable
-        }
-        let span = thir_stat.span;
-
-        match thir_stat.body {
-            ThirStatement::Assign { dest, val, op } => {
-                let val = self.lower_expr(val)?;
-                self.lower_write(dest, val, op, span)?;
-            }
-            ThirStatement::Define { var, .. } => {
-                self.hir_def_spans.insert(var.body, var.span);
-            }
-            ThirStatement::Return(expr) => {
-                let expr = self.lower_expr(expr)?;
+    pub fn write_block(&mut self, thir_block: Spanned<ThirBlock>) -> super::Result<()> {
+        match thir_block.body {
+            super::tyck::ThirBlock::Normal(stmts) | super::tyck::ThirBlock::Unsafe(stmts) => {
+                let newbb = BasicBlockId(self.nextbb.fetch_increment());
+                let (jmp, assignments, incoming) = self.make_jump(newbb);
+                let term = MirTerminator::Jump(jmp);
 
                 let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                    body: MirTerminator::Return(expr),
-                    span,
+                    body: term,
+                    span: thir_block.span,
                 });
                 self.basic_blocks.push(bb);
-            }
-            ThirStatement::Block(blk) => match blk.body {
-                super::tyck::ThirBlock::Normal(stmts) | super::tyck::ThirBlock::Unsafe(stmts) => {
-                    let newbb = BasicBlockId(self.nextbb.fetch_increment());
-                    let (jmp, assignments, incoming) = self.make_jump(newbb);
-                    let term = MirTerminator::Jump(jmp);
+                self.cur_basic_block.id = newbb;
+                self.cur_basic_block.incoming_vars = incoming;
+                self.var_names = assignments;
+                for stmt in stmts {
+                    self.write_statement(stmt)?;
+                }
 
-                    let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                        body: term,
-                        span: blk.span,
-                    });
-                    self.basic_blocks.push(bb);
-                    self.cur_basic_block.id = newbb;
-                    self.cur_basic_block.incoming_vars = incoming;
-                    self.var_names = assignments;
-                    for stmt in stmts {
-                        self.write_statement(stmt)?;
-                    }
+                if self.cur_basic_block.id == BasicBlockId::UNUSED {
+                    return Ok(());
+                }
 
-                    if self.cur_basic_block.id == BasicBlockId::UNUSED {
-                        return Ok(());
-                    }
+                let newbb = BasicBlockId(self.nextbb.fetch_increment());
+                let (jmp, assignments, incoming) = self.make_jump(newbb);
 
-                    let newbb = BasicBlockId(self.nextbb.fetch_increment());
-                    let (jmp, assignments, incoming) = self.make_jump(newbb);
+                let term = MirTerminator::Jump(jmp);
 
-                    let term = MirTerminator::Jump(jmp);
+                let bb = self.cur_basic_block.finish_and_reset(Spanned {
+                    body: term,
+                    span: thir_block.span,
+                });
+                self.basic_blocks.push(bb);
 
-                    let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                        body: term,
-                        span: blk.span,
-                    });
-                    self.basic_blocks.push(bb);
+                self.cur_basic_block.id = newbb;
+                self.cur_basic_block.incoming_vars = incoming;
+                self.var_names = assignments;
+            }
+            super::tyck::ThirBlock::Loop(stmts) => {
+                let newbb = BasicBlockId(self.nextbb.fetch_increment());
+                let (jmp, assignments, incoming) = self.make_jump(newbb);
+                let term = MirTerminator::Jump(jmp);
 
-                    self.cur_basic_block.id = newbb;
-                    self.cur_basic_block.incoming_vars = incoming;
-                    self.var_names = assignments;
+                let bb = self.cur_basic_block.finish_and_reset(Spanned {
+                    body: term.clone(),
+                    span: thir_block.span,
+                });
+                self.basic_blocks.push(bb);
+                self.cur_basic_block.id = newbb;
+                self.var_names = assignments;
+                for stmt in stmts {
+                    self.write_statement(stmt)?;
                 }
-                super::tyck::ThirBlock::Loop(stmts) => {
-                    let newbb = BasicBlockId(self.nextbb.fetch_increment());
-                    let (jmp, assignments, incoming) = self.make_jump(newbb);
-                    let term = MirTerminator::Jump(jmp);
 
-                    let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                        body: term.clone(),
-                        span: blk.span,
-                    });
-                    self.basic_blocks.push(bb);
-                    self.cur_basic_block.id = newbb;
-                    self.var_names = assignments;
-                    for stmt in stmts {
-                        self.write_statement(stmt)?;
-                    }
-
-                    if self.cur_basic_block.id == BasicBlockId::UNUSED {
-                        return Ok(());
-                    }
-
-                    let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                        body: term,
-                        span: blk.span,
-                    });
-                    self.basic_blocks.push(bb);
+                if self.cur_basic_block.id == BasicBlockId::UNUSED {
+                    return Ok(());
                 }
-                super::tyck::ThirBlock::If {
-                    cond,
-                    block,
-                    elseifs,
-                    elseblock,
-                } => {
-                    let mut mir_conds = Vec::new();
-                    let mut branches = Vec::new();
-
-                    let newbb = BasicBlockId(self.nextbb.fetch_increment());
-                    let (basejmp, baseassignments, baseincoming) = self.make_jump(newbb);
-                    branches.push((newbb, baseassignments, baseincoming, block));
 
-                    let basecond = self.lower_expr(cond)?;
-                    mir_conds.push((basecond, basejmp));
+                let bb = self.cur_basic_block.finish_and_reset(Spanned {
+                    body: term,
+                    span: thir_block.span,
+                });
+                self.basic_blocks.push(bb);
+            }
+            super::tyck::ThirBlock::If {
+                cond,
+                block,
+                elseblock,
+            } => {
+                let cond = self.lower_expr(cond)?;
+                let ifbb = BasicBlockId(self.nextbb.fetch_increment());
 
-                    for (cond, block) in elseifs {
-                        let newbb = BasicBlockId(self.nextbb.fetch_increment());
-                        let (condjmp, condassignments, condincoming) = self.make_jump(newbb);
-                        branches.push((newbb, condassignments, condincoming, block));
+                let (ifjmp, assignments, incoming) = self.make_jump(ifbb);
+                let mut start_block =
+                    core::mem::replace(&mut self.cur_basic_block, UnbuiltBasicBlock::unused());
+                self.cur_basic_block.id = ifbb;
+                self.cur_basic_block.incoming_vars = incoming;
+                let mut cur_assigns = core::mem::replace(&mut self.var_names, assignments);
 
-                        let cond = self.lower_expr(cond)?;
-                        mir_conds.push((cond, condjmp));
-                    }
+                self.write_block(*block)?;
 
-                    let elsebb = BasicBlockId(self.nextbb.fetch_increment());
-                    let (elsejmp, elseassignments, elseincoming) = self.make_jump(elsebb);
+                let mut if_end_block =
+                    core::mem::replace(&mut self.cur_basic_block, UnbuiltBasicBlock::unused());
 
-                    branches.push((elsebb, elseassignments, elseincoming, elseblock));
+                let elsebb = BasicBlockId(self.nextbb.fetch_increment());
 
-                    let term = MirTerminator::Branch(MirBranchInfo {
-                        conds: mir_conds,
-                        else_block: elsejmp,
-                    });
+                let if_assigns = core::mem::replace(&mut self.var_names, cur_assigns);
 
-                    let endbb = BasicBlockId(self.nextbb.fetch_increment());
+                let (elsejmp, assignments, incoming) = self.make_jump(elsebb);
+                self.cur_basic_block.id = elsebb;
+                self.cur_basic_block.incoming_vars = incoming;
+                cur_assigns = core::mem::replace(&mut self.var_names, assignments);
 
-                    let bb = self.cur_basic_block.finish_and_reset(Spanned {
-                        body: term,
-                        span: blk.span,
-                    });
-
-                    self.basic_blocks.push(bb);
-
-                    let mut next_assigns = Vec::with_capacity(branches.len());
-                    let mut builders = Vec::new();
+                self.basic_blocks.push(start_block.finish(Spanned {
+                    body: MirTerminator::Branch(MirBranchInfo {
+                        cond: Box::new(cond),
+                        if_block: ifjmp,
+                        else_block: elsejmp,
+                    }),
+                    span: thir_block.span,
+                }));
 
-                    for (newbb, assignments, incoming, block) in branches {
-                        self.cur_basic_block.id = newbb;
-                        self.cur_basic_block.incoming_vars = incoming;
-                        self.var_names = assignments;
-                        for stat in block {
-                            self.write_statement(stat)?;
-                        }
+                if let Some(elseblock) = elseblock {
+                    self.write_block(*elseblock)?;
+                }
+                let nextbb = BasicBlockId(self.nextbb.fetch_increment());
 
-                        let bb = core::mem::replace(
-                            &mut self.cur_basic_block,
-                            UnbuiltBasicBlock::unused(),
-                        );
+                let else_assigns = core::mem::take(&mut self.var_names);
 
-                        if bb.id != BasicBlockId::UNUSED {
-                            builders.push(bb);
-                            next_assigns.push(core::mem::take(&mut self.var_names));
-                        }
-                    }
+                let (mut muljmps, assigns, incoming) =
+                    self.make_many_jumps(&[if_assigns, else_assigns], nextbb);
 
-                    let (jumps, endassignments, endincoming) =
-                        self.make_many_jumps(&next_assigns, endbb);
-
-                    for (mut builder, (init, jump)) in builders.into_iter().zip(jumps) {
-                        builder.stmts.extend(init.into_iter().map(synthetic));
-                        let term = MirTerminator::Jump(jump);
-                        self.basic_blocks.push(builder.finish(Spanned {
-                            body: term,
-                            span: blk.span,
-                        }));
+                let (ifinitstats, ifjmp) = core::mem::take(&mut muljmps[0]);
+                if_end_block
+                    .stmts
+                    .extend(ifinitstats.into_iter().map(|stmt| Spanned {
+                        body: stmt,
+                        span: thir_block.span,
+                    }));
+                self.basic_blocks.push(if_end_block.finish(Spanned {
+                    body: MirTerminator::Jump(ifjmp),
+                    span: thir_block.span,
+                }));
+                let (elseinitstats, elsejmp) = core::mem::take(&mut muljmps[1]);
+                self.cur_basic_block
+                    .stmts
+                    .extend(elseinitstats.into_iter().map(|stmt| Spanned {
+                        body: stmt,
+                        span: thir_block.span,
+                    }));
+                self.basic_blocks
+                    .push(self.cur_basic_block.finish_and_reset(Spanned {
+                        body: MirTerminator::Jump(elsejmp),
+                        span: thir_block.span,
+                    }));
+                self.cur_basic_block.id = nextbb;
+                self.cur_basic_block.incoming_vars = incoming;
+                self.var_names = assigns;
+            }
+            super::tyck::ThirBlock::Match(m) => {
+                let ty = m.discriminee.ty.clone();
+                let (discriminee, pat_var_kind, pat_var) =
+                    self.lower_register(m.discriminee, false)?;
+                let assignments = self.var_names.clone();
+                let mut end_blocks = Vec::new();
+                let mut match_builder = match_lower::MatchBuilder::new(self.defs);
+                let mut end_assign_set = Vec::new();
+                let mut arm_jumps = Vec::new();
+                let mut cur_bb =
+                    core::mem::replace(&mut self.cur_basic_block, UnbuiltBasicBlock::unused());
+                for arm in m.arms {
+                    match_builder.write_arm(arm.discrim.body.matcher)?;
+
+                    if let Some(guard) = arm.guard {
+                        todo!("match guard")
                     }
+                    let newbb = BasicBlockId(self.nextbb.fetch_increment());
 
-                    self.cur_basic_block.id = endbb;
-                    self.cur_basic_block.incoming_vars = endincoming;
-                    self.var_names = endassignments;
-                }
-                super::tyck::ThirBlock::Match(m) => {
-                    let ty = m.discriminee.ty.clone();
-                    let (discriminee, pat_var_kind, pat_var) =
-                        self.lower_register(m.discriminee, false)?;
-                    let assignments = self.var_names.clone();
-                    let mut end_blocks = Vec::new();
-                    let mut match_builder = match_lower::MatchBuilder::new(self.defs);
-                    let mut end_assign_set = Vec::new();
-                    let mut arm_jumps = Vec::new();
-                    let mut cur_bb =
-                        core::mem::replace(&mut self.cur_basic_block, UnbuiltBasicBlock::unused());
-                    for arm in m.arms {
-                        match_builder.write_arm(arm.discrim.body.matcher)?;
-
-                        if let Some(guard) = arm.guard {
-                            todo!("match guard")
-                        }
-                        let newbb = BasicBlockId(self.nextbb.fetch_increment());
-
-                        let (mut jmp, assigns, incoming) = self.make_jump(newbb);
+                    let (mut jmp, assigns, incoming) = self.make_jump(newbb);
 
-                        self.cur_basic_block.id = newbb;
-                        self.cur_basic_block.incoming_vars = incoming;
+                    self.cur_basic_block.id = newbb;
+                    self.cur_basic_block.incoming_vars = incoming;
 
-                        self.var_names = assigns;
+                    self.var_names = assigns;
 
-                        let mut binding_var = None;
+                    let mut binding_var = None;
 
-                        for binding in arm.discrim.body.bindings {
-                            let mut binding_var = if let Some(binding_var) = binding_var {
+                    for binding in arm.discrim.body.bindings {
+                        let mut binding_var = if let Some(binding_var) = binding_var {
+                            binding_var
+                        } else {
+                            for &(mapped, to) in &jmp.remaps {
+                                if mapped == pat_var {
+                                    binding_var = Some(to);
+                                    break;
+                                }
+                            }
+                            if let Some(binding_var) = binding_var {
                                 binding_var
                             } else {
-                                for &(mapped, to) in &jmp.remaps {
-                                    if mapped == pat_var {
-                                        binding_var = Some(to);
-                                        break;
-                                    }
-                                }
-                                if let Some(binding_var) = binding_var {
-                                    binding_var
-                                } else {
-                                    let var = SsaVarId(self.nextvar.fetch_increment());
-                                    self.cur_basic_block.incoming_vars.push((var, ty.clone()));
-                                    jmp.remaps.push((pat_var, var));
-                                    binding_var = Some(var);
-                                    var
-                                }
-                            };
+                                let var = SsaVarId(self.nextvar.fetch_increment());
+                                self.cur_basic_block.incoming_vars.push((var, ty.clone()));
+                                jmp.remaps.push((pat_var, var));
+                                binding_var = Some(var);
+                                var
+                            }
+                        };
 
-                            if binding.path.elements.len() != 0 {
-                                let real_binding_var = SsaVarId(self.nextvar.fetch_increment());
-                                let mut init_expr = Spanned {
-                                    body: MirExpr::Var(binding_var),
-                                    span: binding.span,
-                                };
-                                for elemen in binding.body.path.elements {
-                                    match elemen {
-                                        crate::sema::hir::PatternPathFragment::Field(field) => {
-                                            match pat_var_kind {
-                                                SsaVarKind::Register => {
-                                                    init_expr = Spanned {
-                                                        body: MirExpr::GetSubobject(
-                                                            Box::new(init_expr),
-                                                            field,
-                                                        ),
-                                                        span: binding.span,
-                                                    }
+                        if binding.path.elements.len() != 0 {
+                            let real_binding_var = SsaVarId(self.nextvar.fetch_increment());
+                            let mut init_expr = Spanned {
+                                body: MirExpr::Var(binding_var),
+                                span: binding.span,
+                            };
+                            for elemen in binding.body.path.elements {
+                                match elemen {
+                                    crate::sema::hir::PatternPathFragment::Field(field) => {
+                                        match pat_var_kind {
+                                            SsaVarKind::Register => {
+                                                init_expr = Spanned {
+                                                    body: MirExpr::GetSubobject(
+                                                        Box::new(init_expr),
+                                                        field,
+                                                    ),
+                                                    span: binding.span,
                                                 }
-                                                SsaVarKind::Alloca => {
-                                                    init_expr = Spanned {
-                                                        body: MirExpr::FieldProject(
-                                                            Box::new(init_expr),
-                                                            field,
-                                                        ),
-                                                        span: binding.span,
-                                                    }
+                                            }
+                                            SsaVarKind::Alloca => {
+                                                init_expr = Spanned {
+                                                    body: MirExpr::FieldProject(
+                                                        Box::new(init_expr),
+                                                        field,
+                                                    ),
+                                                    span: binding.span,
                                                 }
                                             }
                                         }
-                                        crate::sema::hir::PatternPathFragment::SliceElement(_) => {
-                                            todo!("slice element")
-                                        }
-                                        crate::sema::hir::PatternPathFragment::SliceHead(_) => {
-                                            todo!("slice head")
-                                        }
-                                        crate::sema::hir::PatternPathFragment::SliceTail(_) => {
-                                            todo!("slice tail")
-                                        }
+                                    }
+                                    crate::sema::hir::PatternPathFragment::SliceElement(_) => {
+                                        todo!("slice element")
+                                    }
+                                    crate::sema::hir::PatternPathFragment::SliceHead(_) => {
+                                        todo!("slice head")
+                                    }
+                                    crate::sema::hir::PatternPathFragment::SliceTail(_) => {
+                                        todo!("slice tail")
                                     }
                                 }
-                                let mut ty = self.hir_var_map[&*binding.body.var].ty.clone();
-                                if pat_var_kind == SsaVarKind::Alloca {
-                                    let mt = self.hir_var_map[&*binding.body.var].mt;
-                                    ty = Spanned {
-                                        body: Type::Pointer(mt, Box::new(ty)),
-                                        span: binding.span,
-                                    };
-                                }
-
-                                self.cur_basic_block.stmts.push(Spanned {
-                                    body: MirStatement::Declare {
-                                        var: Spanned {
-                                            body: real_binding_var,
-                                            span: binding.span,
-                                        },
-                                        ty,
-                                        init: init_expr,
-                                    },
+                            }
+                            let mut ty = self.hir_var_map[&*binding.body.var].ty.clone();
+                            if pat_var_kind == SsaVarKind::Alloca {
+                                let mt = self.hir_var_map[&*binding.body.var].mt;
+                                ty = Spanned {
+                                    body: Type::Pointer(mt, Box::new(ty)),
                                     span: binding.span,
-                                });
-                                binding_var = real_binding_var;
+                                };
                             }
 
-                            self.var_names.insert(
-                                binding.body.var.body,
-                                HirVarAssignment {
-                                    cur_var: binding_var,
-                                    var_kind: pat_var_kind,
+                            self.cur_basic_block.stmts.push(Spanned {
+                                body: MirStatement::Declare {
+                                    var: Spanned {
+                                        body: real_binding_var,
+                                        span: binding.span,
+                                    },
+                                    ty,
+                                    init: init_expr,
                                 },
-                            );
-                        }
-                        arm_jumps.push(jmp);
-                        for stmt in arm.expansion.body {
-                            self.write_statement(stmt)?;
+                                span: binding.span,
+                            });
+                            binding_var = real_binding_var;
                         }
-                        let end_assigns =
-                            core::mem::replace(&mut self.var_names, assignments.clone());
-                        let end_block = core::mem::replace(
-                            &mut self.cur_basic_block,
-                            UnbuiltBasicBlock::unused(),
+
+                        self.var_names.insert(
+                            binding.body.var.body,
+                            HirVarAssignment {
+                                cur_var: binding_var,
+                                var_kind: pat_var_kind,
+                            },
                         );
+                    }
+                    arm_jumps.push(jmp);
+                    for stmt in arm.expansion.body {
+                        self.write_statement(stmt)?;
+                    }
+                    let end_assigns = core::mem::replace(&mut self.var_names, assignments.clone());
+                    let end_block =
+                        core::mem::replace(&mut self.cur_basic_block, UnbuiltBasicBlock::unused());
 
-                        if end_block.id != BasicBlockId::UNUSED {
-                            end_blocks.push(end_block);
-                            end_assign_set.push(end_assigns);
-                        }
+                    if end_block.id != BasicBlockId::UNUSED {
+                        end_blocks.push(end_block);
+                        end_assign_set.push(end_assigns);
                     }
+                }
 
-                    let term = match_builder.build_match_term(discriminee, arm_jumps);
+                let term = match_builder.build_match_term(discriminee, arm_jumps);
 
-                    self.basic_blocks.push(cur_bb.finish(Spanned {
-                        body: term,
-                        span: blk.span,
-                    }));
+                self.basic_blocks.push(cur_bb.finish(Spanned {
+                    body: term,
+                    span: thir_block.span,
+                }));
 
-                    if !end_blocks.is_empty() {
-                        let end_block_id = BasicBlockId(self.nextbb.fetch_increment());
-                        self.cur_basic_block.id = end_block_id;
-
-                        let (jumps, assigns, incoming) =
-                            self.make_many_jumps(&end_assign_set, end_block_id);
-                        self.cur_basic_block.incoming_vars = incoming;
-
-                        self.var_names = assigns;
-
-                        for (mut end_block, (init_stats, jmp)) in end_blocks.into_iter().zip(jumps)
-                        {
-                            let span = blk.span;
-                            end_block.stmts.extend(
-                                init_stats
-                                    .into_iter()
-                                    .map(|stat| Spanned { body: stat, span }),
-                            );
-                            self.basic_blocks.push(end_block.finish(Spanned {
-                                body: MirTerminator::Jump(jmp),
-                                span,
-                            }));
-                        }
+                if !end_blocks.is_empty() {
+                    let end_block_id = BasicBlockId(self.nextbb.fetch_increment());
+                    self.cur_basic_block.id = end_block_id;
+
+                    let (jumps, assigns, incoming) =
+                        self.make_many_jumps(&end_assign_set, end_block_id);
+                    self.cur_basic_block.incoming_vars = incoming;
+
+                    self.var_names = assigns;
+
+                    for (mut end_block, (init_stats, jmp)) in end_blocks.into_iter().zip(jumps) {
+                        let span = thir_block.span;
+                        end_block.stmts.extend(
+                            init_stats
+                                .into_iter()
+                                .map(|stat| Spanned { body: stat, span }),
+                        );
+                        self.basic_blocks.push(end_block.finish(Spanned {
+                            body: MirTerminator::Jump(jmp),
+                            span,
+                        }));
                     }
                 }
-            },
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn write_statement(&mut self, thir_stat: Spanned<ThirStatement>) -> super::Result<()> {
+        if self.cur_basic_block.id == BasicBlockId::UNUSED {
+            return Ok(()); // short circuit out if we're unreachable
+        }
+        let span = thir_stat.span;
+
+        match thir_stat.body {
+            ThirStatement::Assign { dest, val, op } => {
+                let val = self.lower_expr(val)?;
+                self.lower_write(dest, val, op, span)?;
+            }
+            ThirStatement::Define { var, .. } => {
+                self.hir_def_spans.insert(var.body, var.span);
+            }
+            ThirStatement::Return(expr) => {
+                let expr = self.lower_expr(expr)?;
+
+                let bb = self.cur_basic_block.finish_and_reset(Spanned {
+                    body: MirTerminator::Return(expr),
+                    span,
+                });
+                self.basic_blocks.push(bb);
+            }
+            ThirStatement::Block(blk) => self.write_block(blk)?,
             ThirStatement::Discard(expr) => {
                 let expr = self.lower_expr(expr)?;
 
diff --git a/rust/src/sema/mir/transform.rs b/rust/src/sema/mir/transform.rs
index 53c45856..9ef24097 100644
--- a/rust/src/sema/mir/transform.rs
+++ b/rust/src/sema/mir/transform.rs
@@ -55,8 +55,12 @@ impl<P: MirStatementPass> MirBasicBlockPass for P {
     }
 }
 
+mod fallthrough;
 mod remove_discard;
 mod unreachable;
 
 pub const REQ_PASSES: &[&(dyn MirFunctionPass + Sync)] = &[];
-pub const OPT_PASSES: &[&(dyn MirFunctionPass + Sync)] = &[&unreachable::PropagateUnreachable];
+pub const OPT_PASSES: &[&(dyn MirFunctionPass + Sync)] = &[
+    &fallthrough::InferFallthrough,
+    &unreachable::PropagateUnreachable,
+];
diff --git a/rust/src/sema/mir/transform/fallthrough.rs b/rust/src/sema/mir/transform/fallthrough.rs
new file mode 100644
index 00000000..817fd249
--- /dev/null
+++ b/rust/src/sema/mir/transform/fallthrough.rs
@@ -0,0 +1,59 @@
+use crate::sema::mir;
+
+use super::MirBasicBlockPass;
+
+pub struct InferFallthrough;
+
+impl InferFallthrough {
+    fn accept_jump(&self, cur_bb: mir::BasicBlockId, jmp: &mut mir::MirJumpInfo) {
+        if cur_bb.is_successor(jmp.targbb) {
+            jmp.fallthrough = true;
+        }
+    }
+}
+
+impl MirBasicBlockPass for InferFallthrough {
+    fn pass_type(&self) -> super::MirPassType {
+        super::MirPassType::Optional(64)
+    }
+
+    fn accept_basic_block(
+        &self,
+        targ: &mut crate::sema::mir::MirBasicBlock,
+    ) -> crate::sema::Result<()> {
+        let id = targ.id;
+
+        match &mut targ.term.body {
+            crate::sema::mir::MirTerminator::Call(call) => {
+                self.accept_jump(id, &mut call.next);
+                Ok(())
+            }
+            crate::sema::mir::MirTerminator::DropInPlace(drop) => {
+                self.accept_jump(id, &mut drop.next);
+                Ok(())
+            }
+            crate::sema::mir::MirTerminator::Branch(br) => {
+                self.accept_jump(id, &mut br.if_block);
+                self.accept_jump(id, &mut br.else_block);
+                Ok(())
+            }
+            crate::sema::mir::MirTerminator::SwitchInt(switch) => {
+                for (_, jmp) in &mut switch.cases {
+                    self.accept_jump(id, jmp);
+                }
+                if let Some(default) = &mut switch.default {
+                    self.accept_jump(id, default);
+                }
+                Ok(())
+            }
+            crate::sema::mir::MirTerminator::Jump(jmp) => {
+                self.accept_jump(id, jmp);
+                Ok(())
+            }
+            crate::sema::mir::MirTerminator::Return(_)
+            | crate::sema::mir::MirTerminator::Tailcall(_)
+            | crate::sema::mir::MirTerminator::Unreachable
+            | crate::sema::mir::MirTerminator::Resume => Ok(()),
+        }
+    }
+}
diff --git a/rust/src/sema/mir_defs.rs b/rust/src/sema/mir_defs.rs
index c7ee2d29..1c153615 100644
--- a/rust/src/sema/mir_defs.rs
+++ b/rust/src/sema/mir_defs.rs
@@ -114,7 +114,7 @@ pub enum MirTerminator {
     Return(Spanned<MirExpr>),
     Jump(MirJumpInfo),
     Unreachable,
-    ResumeUnwind,
+    Resume,
     DropInPlace(MirDropInfo),
     Branch(MirBranchInfo),
     SwitchInt(MirSwitchIntInfo),
@@ -130,11 +130,12 @@ pub struct MirSwitchIntInfo {
 
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
 pub struct MirBranchInfo {
-    pub conds: Vec<(Spanned<MirExpr>, MirJumpInfo)>,
+    pub cond: Box<Spanned<MirExpr>>,
+    pub if_block: MirJumpInfo,
     pub else_block: MirJumpInfo,
 }
 
-#[derive(Clone, Hash, PartialEq, Eq, Debug)]
+#[derive(Clone, Hash, PartialEq, Eq, Debug, Default)]
 pub struct MirJumpInfo {
     pub targbb: BasicBlockId,
     pub remaps: Vec<(SsaVarId, SsaVarId)>,
diff --git a/rust/src/sema/ty.rs b/rust/src/sema/ty.rs
index e5085ddb..e831b5a3 100644
--- a/rust/src/sema/ty.rs
+++ b/rust/src/sema/ty.rs
@@ -48,9 +48,17 @@ pub enum IntWidth {
 }
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub enum FloatWidth {
-    Bits(NonZeroU16),
-    Long,
+pub enum FloatFormat {
+    IeeeBinary,
+    IeeeExtRange,
+    IeeeExtPrecision,
+    Dfloat,
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct FloatType {
+    pub width: NonZeroU16,
+    pub format: FloatFormat,
 }
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
@@ -81,7 +89,7 @@ pub enum SemaLifetime {
 pub enum Type {
     Bool,
     Int(IntType),
-    Float(FloatWidth),
+    Float(FloatType),
     Char,
     Str,
     Never,
@@ -311,9 +319,35 @@ pub fn convert_tag(tag: Spanned<Symbol>, curmod: DefId, at_item: DefId) -> super
 
 // Write the Rust type here
 #[allow(non_upper_case_globals)]
-impl FloatWidth {
-    pub const f32: FloatWidth = FloatWidth::Bits(nzu16!(32));
-    pub const f64: FloatWidth = FloatWidth::Bits(nzu16!(64));
+impl FloatType {
+    pub const f16: FloatType = FloatType {
+        width: nzu16!(16),
+        format: FloatFormat::IeeeBinary,
+    };
+    pub const f32: FloatType = FloatType {
+        width: nzu16!(32),
+        format: FloatFormat::IeeeBinary,
+    };
+    pub const f64: FloatType = FloatType {
+        width: nzu16!(64),
+        format: FloatFormat::IeeeBinary,
+    };
+    pub const f128: FloatType = FloatType {
+        width: nzu16!(128),
+        format: FloatFormat::IeeeBinary,
+    };
+    pub const bf16: FloatType = FloatType {
+        width: nzu16!(16),
+        format: FloatFormat::IeeeExtRange,
+    };
+    pub const fx80: FloatType = FloatType {
+        width: nzu16!(80),
+        format: FloatFormat::IeeeExtPrecision,
+    };
+    pub const fd128: FloatType = FloatType {
+        width: nzu16!(128),
+        format: FloatFormat::Dfloat,
+    };
 }
 
 #[allow(non_upper_case_globals)] // Write the Rust type here
@@ -593,8 +627,13 @@ impl Type {
     pub fn rt_impl_lang(&self) -> Option<LangItem> {
         match self {
             Self::Float(x) => match *x {
-                FloatWidth::f32 => Some(LangItem::F32Rt),
-                FloatWidth::f64 => Some(LangItem::F64Rt),
+                FloatType::f32 => Some(LangItem::F32Rt),
+                FloatType::f64 => Some(LangItem::F64Rt),
+                FloatType::f16 => Some(LangItem::F16Rt),
+                FloatType::f128 => Some(LangItem::F128Rt),
+                FloatType::bf16 => Some(LangItem::Bf16Rt),
+                FloatType::fd128 => Some(LangItem::Fd128Rt),
+                FloatType::fx80 => Some(LangItem::Fx80Rt),
                 _ => None,
             },
             _ => None,
@@ -625,8 +664,13 @@ impl Type {
                 _ => None,
             },
             Self::Float(x) => match *x {
-                FloatWidth::f32 => Some(LangItem::F32),
-                FloatWidth::f64 => Some(LangItem::F64),
+                FloatType::f32 => Some(LangItem::F32),
+                FloatType::f64 => Some(LangItem::F64),
+                FloatType::f16 => Some(LangItem::F16),
+                FloatType::f128 => Some(LangItem::F128),
+                FloatType::bf16 => Some(LangItem::Bf16),
+                FloatType::fd128 => Some(LangItem::Fd128),
+                FloatType::fx80 => Some(LangItem::Fx80),
                 _ => None,
             },
             Self::Pointer(
@@ -654,12 +698,15 @@ impl core::fmt::Display for Type {
         match self {
             Self::Bool => f.write_str("bool"),
             Self::Int(intty) => intty.fmt(f),
-            Self::Float(width) => {
-                f.write_str("f")?;
-                match width {
-                    FloatWidth::Bits(bits) => f.write_fmt(format_args!("{}", bits)),
-                    FloatWidth::Long => f.write_str("long"),
+            Self::Float(ty) => {
+                match ty.format {
+                    FloatFormat::IeeeBinary => f.write_str("f")?,
+                    FloatFormat::IeeeExtPrecision => f.write_str("fx")?,
+                    FloatFormat::IeeeExtRange => f.write_str("bf")?,
+                    FloatFormat::Dfloat => f.write_str("fd")?,
                 }
+
+                ty.width.fmt(f)
             }
             Self::Char => f.write_str("char"),
             Self::Str => f.write_str("str"),
@@ -748,11 +795,14 @@ pub fn convert_builtin_type(name: &str) -> Option<Type> {
         x if x.starts_with('f') => {
             let size = x[1..].parse::<NonZeroU16>().ok()?;
             match size.get() {
-                32 | 64 => {}
+                16 | 32 | 64 | 32 => {}
                 _ => None?,
             }
 
-            Some(Type::Float(FloatWidth::Bits(size)))
+            Some(Type::Float(FloatType {
+                format: FloatFormat::IeeeBinary,
+                width: size,
+            }))
         }
         _ => None,
     }
@@ -768,19 +818,26 @@ pub fn convert_type(
     match ty {
         ast::Type::Path(path) => match defs.find_type(curmod, &path.body, at_item, self_ty) {
             Ok((defid, generics)) => Ok(Type::UserType(defid, generics)),
-            Err(e) => match &*path.segments {
-                [Spanned {
-                    body:
-                        PathSegment {
-                            ident:
-                                Spanned {
-                                    body: ast::SimplePathSegment::Identifier(id),
-                                    ..
-                                },
-                            generics: None,
-                        },
-                    ..
-                }] => convert_builtin_type(id).ok_or(e),
+            Err(e) => match (&*path.segments, &path.root) {
+                (
+                    [Spanned {
+                        body:
+                            PathSegment {
+                                ident:
+                                    Spanned {
+                                        body: ast::SimplePathSegment::Identifier(id),
+                                        ..
+                                    },
+                                generics: None,
+                            },
+                        ..
+                    }],
+                    None
+                    | Some(Spanned {
+                        body: ast::PathRoot::Root,
+                        ..
+                    }),
+                ) => convert_builtin_type(id).ok_or(e),
                 _ => Err(e),
             },
         },
@@ -791,7 +848,7 @@ pub fn convert_type(
             Ok(Type::Pointer(*mt, Box::new(ty)))
         }
         ast::Type::Array(_, _) => todo!("array"),
-        ast::Type::FnType(_) => todo!(),
+        ast::Type::FnType(_) => todo!("fn-ptr"),
         ast::Type::Never => Ok(Type::Never),
         ast::Type::Tuple(tys) => {
             let mut tys = tys
diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
index 4cdff619..8817d808 100644
--- a/rust/src/sema/tyck.rs
+++ b/rust/src/sema/tyck.rs
@@ -322,9 +322,8 @@ pub enum ThirBlock {
     Loop(ThirSimpleBlock),
     If {
         cond: Spanned<ThirExpr>,
-        block: ThirSimpleBlock,
-        elseifs: Vec<(Spanned<ThirExpr>, ThirSimpleBlock)>,
-        elseblock: ThirSimpleBlock,
+        block: Box<Spanned<ThirBlock>>,
+        elseblock: Option<Box<Spanned<ThirBlock>>>,
     },
     Match(ThirMatch),
 }
@@ -364,6 +363,81 @@ impl ThirFunctionBody {
         Ok(())
     }
 
+    fn display_block(
+        &self,
+        block: &ThirBlock,
+        f: &mut core::fmt::Formatter,
+        tabs: TabPrinter,
+    ) -> core::fmt::Result {
+        use core::fmt::Display;
+        match &block {
+            ThirBlock::Normal(stmts) => {
+                f.write_str("{\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            ThirBlock::Unsafe(stmts) => {
+                f.write_str("unsafe {\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            ThirBlock::Loop(stmts) => {
+                f.write_str("loop {\n")?;
+                let nested = tabs.nest();
+                for stmt in stmts {
+                    self.display_statement(stmt, f, nested)?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+            ThirBlock::If {
+                cond,
+                block,
+                elseblock,
+            } => {
+                write!(f, "if {} ", cond.body)?;
+                self.display_block(block, f, tabs)?;
+                if let Some(elseblk) = elseblock {
+                    write!(f, "{}else ", tabs)?;
+                    self.display_block(elseblk, f, tabs)
+                } else {
+                    Ok(())
+                }
+            }
+            ThirBlock::Match(m) => {
+                let nested = tabs.nest();
+                write!(f, "match {} {{\n", m.discriminee.body)?;
+                for arm in &m.arms {
+                    nested.fmt(f)?;
+                    let subnested = nested.nest();
+                    arm.discrim.body.fmt(f)?;
+
+                    if let Some(guard) = &arm.guard {
+                        write!(f, "if {}", guard.body)?;
+                    }
+
+                    f.write_str(" => {\n")?;
+
+                    for stmt in &arm.expansion.body {
+                        self.display_statement(stmt, f, subnested)?;
+                    }
+                    nested.fmt(f)?;
+                    f.write_str("}\n")?;
+                }
+                tabs.fmt(f)?;
+                f.write_str("}\n")
+            }
+        }
+    }
+
     fn display_statement(
         &self,
         stmt: &ThirStatement,
@@ -391,91 +465,10 @@ impl ThirFunctionBody {
             ThirStatement::Return(expr) => {
                 f.write_fmt(format_args!("{}return {};\n", tabs, expr.body))
             }
-            ThirStatement::Block(b) => match &b.body {
-                ThirBlock::Normal(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("{\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                ThirBlock::Unsafe(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("unsafe {\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                ThirBlock::Loop(stmts) => {
-                    tabs.fmt(f)?;
-                    f.write_str("loop {\n")?;
-                    let nested = tabs.nest();
-                    for stmt in stmts {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                ThirBlock::If {
-                    cond,
-                    block,
-                    elseifs,
-                    elseblock,
-                } => {
-                    tabs.fmt(f)?;
-                    write!(f, "if {} {{\n", cond.body)?;
-                    let nested = tabs.nest();
-                    for stmt in block {
-                        self.display_statement(stmt, f, nested)?;
-                    }
-                    for (cond, block) in elseifs {
-                        tabs.fmt(f)?;
-                        write!(f, "}} else if {} {{\n", cond.body)?;
-                        for stmt in block {
-                            self.display_statement(stmt, f, nested)?;
-                        }
-                    }
-                    if elseblock.len() > 0 {
-                        tabs.fmt(f)?;
-                        f.write_str("} else {\n")?;
-                        for stmt in elseblock {
-                            self.display_statement(stmt, f, nested)?;
-                        }
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-                ThirBlock::Match(m) => {
-                    tabs.fmt(f)?;
-                    let nested = tabs.nest();
-                    write!(f, "match {} {{\n", m.discriminee.body)?;
-                    for arm in &m.arms {
-                        nested.fmt(f)?;
-                        let subnested = nested.nest();
-                        arm.discrim.body.fmt(f)?;
-
-                        if let Some(guard) = &arm.guard {
-                            write!(f, "if {}", guard.body)?;
-                        }
-
-                        f.write_str(" => {\n")?;
-
-                        for stmt in &arm.expansion.body {
-                            self.display_statement(stmt, f, subnested)?;
-                        }
-                        nested.fmt(f)?;
-                        f.write_str("}\n")?;
-                    }
-                    tabs.fmt(f)?;
-                    f.write_str("}\n")
-                }
-            },
+            ThirStatement::Block(b) => {
+                tabs.fmt(f)?;
+                self.display_block(b, f, tabs)
+            }
             ThirStatement::Discard(expr) => f.write_fmt(format_args!("{}{};\n", tabs, expr.body)),
             ThirStatement::Call {
                 retplace,
@@ -1078,6 +1071,78 @@ impl<'a> ThirConverter<'a> {
         Ok(())
     }
 
+    pub fn convert_block(
+        &mut self,
+        blk: &Spanned<hir::HirBlock>,
+    ) -> super::Result<Spanned<ThirBlock>> {
+        blk.try_copy_span(|blk| match blk {
+            hir::HirBlock::Normal(stmts) => stmts
+                .iter()
+                .map(|stmt| self.convert_statement(stmt))
+                .collect::<super::Result<Vec<_>>>()
+                .map(ThirBlock::Normal),
+            hir::HirBlock::Unsafe(stmts) => stmts
+                .iter()
+                .map(|stmt| self.convert_statement(stmt))
+                .collect::<super::Result<Vec<_>>>()
+                .map(ThirBlock::Unsafe),
+            hir::HirBlock::Loop(stmts) => stmts
+                .iter()
+                .map(|stmt| self.convert_statement(stmt))
+                .collect::<super::Result<Vec<_>>>()
+                .map(ThirBlock::Loop),
+            hir::HirBlock::If {
+                cond,
+                block,
+                elseblock,
+            } => {
+                let cond = self.convert_expr(cond)?;
+                let block = self.convert_block(block)?;
+                let elseblock = elseblock
+                    .as_ref()
+                    .map(|block| self.convert_block(block))
+                    .transpose()?;
+
+                Ok(ThirBlock::If {
+                    cond,
+                    block: Box::new(block),
+                    elseblock: elseblock.map(Box::new),
+                })
+            }
+            hir::HirBlock::Match(m) => {
+                let discriminee = self.convert_expr(&m.discriminee)?;
+
+                let arms = m
+                    .arms
+                    .iter()
+                    .map(|a| {
+                        let pattern = self.convert_pattern(&a.pattern)?;
+                        let expansion = a.expansion.try_copy_span(|s| {
+                            s.iter()
+                                .map(|stmt| self.convert_statement(stmt))
+                                .collect::<super::Result<Vec<_>>>()
+                        })?;
+                        let guard = a
+                            .guard
+                            .as_ref()
+                            .map(|expr| self.convert_expr(expr))
+                            .transpose()?;
+
+                        Ok(ThirMatchArm {
+                            discrim: pattern,
+                            guard,
+                            expansion,
+                        })
+                    })
+                    .collect::<super::Result<Vec<_>>>()?;
+
+                let m = ThirMatch { discriminee, arms };
+
+                Ok(ThirBlock::Match(m))
+            }
+        })
+    }
+
     pub fn convert_statement(
         &mut self,
         stmt: &Spanned<hir::HirStatement>,
@@ -1133,90 +1198,7 @@ impl<'a> ThirConverter<'a> {
 
                 Ok(ThirStatement::Return(expr))
             }
-            hir::HirStatement::Block(b) => Ok(ThirStatement::Block(b.try_copy_span(|b| {
-                match b {
-                    hir::HirBlock::Normal(stmts) => Ok(ThirBlock::Normal(
-                        stmts
-                            .iter()
-                            .map(|stmt| self.convert_statement(stmt))
-                            .collect::<Result<_>>()?,
-                    )),
-                    hir::HirBlock::Unsafe(stmts) => Ok(ThirBlock::Unsafe(
-                        stmts
-                            .iter()
-                            .map(|stmt| self.convert_statement(stmt))
-                            .collect::<Result<_>>()?,
-                    )),
-                    hir::HirBlock::Loop(stmts) => Ok(ThirBlock::Loop(
-                        stmts
-                            .iter()
-                            .map(|stmt| self.convert_statement(stmt))
-                            .collect::<Result<_>>()?,
-                    )),
-                    hir::HirBlock::If {
-                        cond,
-                        block,
-                        elseifs,
-                        elseblock,
-                    } => Ok(ThirBlock::If {
-                        cond: self.convert_expr(cond)?,
-                        block: block
-                            .iter()
-                            .map(|stmt| self.convert_statement(stmt))
-                            .collect::<Result<_>>()?,
-                        elseifs: elseifs
-                            .iter()
-                            .map(|(cond, block)| {
-                                Ok((
-                                    self.convert_expr(cond)?,
-                                    block
-                                        .iter()
-                                        .map(|stmt| self.convert_statement(stmt))
-                                        .collect::<Result<_>>()?,
-                                ))
-                            })
-                            .collect::<Result<_>>()?,
-                        elseblock: elseblock
-                            .iter()
-                            .map(|stmt| self.convert_statement(stmt))
-                            .collect::<Result<_>>()?,
-                    }),
-                    hir::HirBlock::Match(m) => {
-                        let discriminee = self.convert_expr(&m.discriminee)?;
-
-                        let arms = m
-                            .arms
-                            .iter()
-                            .map(|arm| {
-                                let discrim = self.convert_pattern(&arm.pattern)?;
-
-                                let guard = arm
-                                    .guard
-                                    .as_ref()
-                                    .map(|guard| self.convert_expr(guard))
-                                    .transpose()?;
-
-                                let expansion = arm.expansion.try_copy_span(|expansion| {
-                                    expansion
-                                        .iter()
-                                        .map(|stmt| self.convert_statement(stmt))
-                                        .collect::<Result<_>>()
-                                })?;
-
-                                Ok(ThirMatchArm {
-                                    discrim,
-                                    guard,
-                                    expansion,
-                                })
-                            })
-                            .collect::<Result<_>>()?;
-
-                        let m = ThirMatch { discriminee, arms };
-
-                        Ok(ThirBlock::Match(m))
-                    }
-                }
-            })?)),
+            hir::HirStatement::Block(b) => Ok(ThirStatement::Block(self.convert_block(b)?)),
             hir::HirStatement::Discard(expr) => {
                 let val = self.convert_rvalue(expr)?;
 
@@ -1675,21 +1657,13 @@ impl<'a> Inferer<'a> {
             ThirBlock::If {
                 cond,
                 block,
-                elseifs,
                 elseblock,
             } => {
                 status &= self.unify_typed_expr(cond, &mut Type::Bool)?;
-                for stmt in block {
-                    status &= self.unify_statement(stmt)?;
-                }
-                for (cond, blk) in elseifs {
-                    status &= self.unify_typed_expr(cond, &mut Type::Bool)?;
-                    for stmt in blk {
-                        status &= self.unify_statement(stmt)?;
-                    }
-                }
-                for stmt in elseblock {
-                    status &= self.unify_statement(stmt)?;
+                status &= self.unify_block(block)?;
+
+                if let Some(elseblock) = elseblock {
+                    status &= self.unify_block(elseblock)?;
                 }
             }
             ThirBlock::Match(m) => {
@@ -1717,21 +1691,12 @@ impl<'a> Inferer<'a> {
             ThirBlock::If {
                 cond,
                 block,
-                elseifs,
                 elseblock,
             } => {
                 status &= self.propagate_expr(cond)?;
-                for stmt in block {
-                    status &= self.propagate_statement(stmt)?;
-                }
-                for (cond, blk) in elseifs {
-                    status &= self.propagate_expr(cond)?;
-                    for stmt in blk {
-                        status &= self.propagate_statement(stmt)?;
-                    }
-                }
-                for stmt in elseblock {
-                    status &= self.propagate_statement(stmt)?;
+                status &= self.propagate_block(block)?;
+                if let Some(elseblock) = elseblock {
+                    status &= self.propagate_block(elseblock)?;
                 }
             }
             ThirBlock::Match(m) => {

From 330cf0d8b50c63c34d909386cf9059f10d7bc3e9 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 17 May 2024 14:15:34 -0400
Subject: [PATCH 40/74] chore: Add lccc-siphashsubmodule

---
 lcrust/libraries/lccc-siphash | 1 +
 1 file changed, 1 insertion(+)
 create mode 160000 lcrust/libraries/lccc-siphash

diff --git a/lcrust/libraries/lccc-siphash b/lcrust/libraries/lccc-siphash
new file mode 160000
index 00000000..7ceecb6f
--- /dev/null
+++ b/lcrust/libraries/lccc-siphash
@@ -0,0 +1 @@
+Subproject commit 7ceecb6fb658568cc189cc5d0d5afb88f9471924

From 99dcda8607a4000f7ee4458e9628f416f4c40ea5 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 17 May 2024 14:16:00 -0400
Subject: [PATCH 41/74] feat(rust-irgen): Codegen if_else test

---
 rust/src/irgen/xir_visitor.rs | 151 +++++++++++++++++++++++++++++++++-
 1 file changed, 150 insertions(+), 1 deletion(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index cabd5ab2..4d436267 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1155,7 +1155,40 @@ impl<'a> XirTerminatorVisitor<'a> {
 
 impl<'a> TerminatorVisitor for XirTerminatorVisitor<'a> {
     fn visit_branch(&mut self) -> Option<Box<dyn BranchVisitor + '_>> {
-        todo!()
+        let (iftarg, elsetarg) = {
+            self.block.term = ir::Terminator::Branch(
+                ir::BranchCondition::NotEqual,
+                ir::JumpTarget {
+                    target: !0,
+                    flags: ir::JumpTargetFlags::empty(),
+                },
+                ir::JumpTarget {
+                    target: !0,
+                    flags: ir::JumpTargetFlags::empty(),
+                },
+            );
+
+            match &mut self.block.term {
+                ir::Terminator::Branch(_, iftarg, elsetarg) => (iftarg, elsetarg),
+                _ => unsafe { core::hint::unreachable_unchecked() },
+            }
+        };
+
+        Some(Box::new(XirBranchVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            &mut self.block.expr,
+            iftarg,
+            elsetarg,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
     }
 
     fn visit_call(&mut self) -> Option<Box<dyn CallVisitor + '_>> {
@@ -1201,6 +1234,7 @@ impl<'a> TerminatorVisitor for XirTerminatorVisitor<'a> {
             self.var_heights,
             self.var_stack,
             0,
+            false,
         )))
     }
 
@@ -1237,6 +1271,7 @@ pub struct XirJumpVisitor<'a> {
     var_stack: &'a mut Vec<SsaVarId>,
     volatile_vals: u32,
     remapped_var_count: u32,
+    skip_setting_remaps: bool,
 }
 
 impl<'a> XirJumpVisitor<'a> {
@@ -1254,6 +1289,7 @@ impl<'a> XirJumpVisitor<'a> {
         var_heights: &'a mut HashMap<SsaVarId, u32>,
         var_stack: &'a mut Vec<SsaVarId>,
         volatile_vals: u32,
+        skip_setting_remaps: bool,
     ) -> Self {
         Self {
             defs,
@@ -1270,6 +1306,7 @@ impl<'a> XirJumpVisitor<'a> {
             var_stack,
             volatile_vals,
             remapped_var_count: 0,
+            skip_setting_remaps,
         }
     }
 }
@@ -1280,6 +1317,9 @@ impl<'a> JumpVisitor for XirJumpVisitor<'a> {
     }
 
     fn visit_remap(&mut self, src: mir::SsaVarId, _: mir::SsaVarId) {
+        if self.skip_setting_remaps {
+            return;
+        }
         let height = self.var_heights.remove(&src).unwrap().1;
         let i = self
             .var_stack
@@ -1318,6 +1358,110 @@ impl<'a> Drop for XirJumpVisitor<'a> {
     }
 }
 
+pub struct XirBranchVisitor<'a> {
+    defs: &'a Definitions,
+    names: &'a NameMap,
+    properties: &'a TargetProperties<'a>,
+    deftys: &'a HashMap<DefId, ir::Type>,
+    cur_fnty: &'a mut ir::FnType,
+    exprs: &'a mut Vec<ir::Expr>,
+    iftarg: &'a mut ir::JumpTarget,
+    elsetarg: &'a mut ir::JumpTarget,
+    locals: &'a mut Vec<ir::Type>,
+    ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+    stack_height: &'a mut u32,
+    var_heights: &'a mut HashMap<SsaVarId, u32>,
+    var_stack: &'a mut Vec<SsaVarId>,
+}
+
+impl<'a> XirBranchVisitor<'a> {
+    pub fn new(
+        defs: &'a Definitions,
+        names: &'a NameMap,
+        properties: &'a TargetProperties<'a>,
+        deftys: &'a HashMap<DefId, ir::Type>,
+        cur_fnty: &'a mut ir::FnType,
+        exprs: &'a mut Vec<ir::Expr>,
+        iftarg: &'a mut ir::JumpTarget,
+        elsetarg: &'a mut ir::JumpTarget,
+        locals: &'a mut Vec<ir::Type>,
+        ssa_tys: &'a mut HashMap<SsaVarId, ir::Type>,
+        stack_height: &'a mut u32,
+        var_heights: &'a mut HashMap<SsaVarId, u32>,
+        var_stack: &'a mut Vec<SsaVarId>,
+    ) -> Self {
+        Self {
+            defs,
+            names,
+            properties,
+            deftys,
+            cur_fnty,
+            exprs,
+            iftarg,
+            elsetarg,
+            locals,
+            ssa_tys,
+            stack_height,
+            var_heights,
+            var_stack,
+        }
+    }
+}
+
+impl<'a> BranchVisitor for XirBranchVisitor<'a> {
+    fn visit_cond(&mut self) -> Option<Box<dyn ExprVisitor + '_>> {
+        Some(Box::new(XirExprVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+        )))
+    }
+    fn visit_if_arm(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
+        Some(Box::new(XirJumpVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.iftarg,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+            1,
+            false,
+        )))
+    }
+    fn visit_else(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
+        Some(Box::new(XirJumpVisitor::new(
+            self.defs,
+            self.names,
+            self.properties,
+            self.deftys,
+            self.cur_fnty,
+            self.exprs,
+            self.elsetarg,
+            self.locals,
+            self.ssa_tys,
+            self.stack_height,
+            self.var_heights,
+            self.var_stack,
+            1,
+            true,
+        )))
+    }
+}
+
 pub struct XirCallVisitor<'a> {
     defs: &'a Definitions,
     names: &'a NameMap,
@@ -1433,6 +1577,7 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
             self.var_heights,
             self.var_stack,
             self.param_count + 1,
+            false,
         )))
     }
 
@@ -2208,6 +2353,10 @@ impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
             BinaryOp::Mul => ir::BinaryOp::Mul,
             BinaryOp::Div => ir::BinaryOp::Div,
             BinaryOp::Rem => ir::BinaryOp::Mod,
+            BinaryOp::Less => ir::BinaryOp::CmpLt,
+            BinaryOp::Greater => ir::BinaryOp::CmpGt,
+            BinaryOp::Equal => ir::BinaryOp::CmpEq,
+            BinaryOp::BitAnd => ir::BinaryOp::BitAnd,
             x => todo!("{:?}", x),
         });
     }

From eba9b927fdc4d16f71211f96c856536573aff09a Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 17 May 2024 14:32:52 -0400
Subject: [PATCH 42/74] feat: There's a lot of work being done here. I'm not
 sure what's severable or not.

---
 autobuild                                     |   2 +-
 codegen-x86/src/lib.rs                        |  31 ++++-
 lc-binutils                                   |   2 +-
 lccc/src/session.rs                           |   2 +-
 lccc/targets/{ => arch}/x86/builtins.toml     |   0
 lccc/targets/arch/x86/features.toml           |  71 +++++++++++
 lccc/targets/{ => arch}/x86/machines.toml     |   0
 lccc/targets/arch/x86_64-llp64-windows.toml   |  16 +++
 lccc/targets/arch/x86_64-llp64.toml           |  16 +++
 lccc/targets/arch/x86_64-lp64.toml            |  16 +++
 lccc/targets/arch/x86_64.toml                 |  10 ++
 lccc/targets/os/linux.toml                    |  13 ++
 lccc/targets/os/linux/x86_64-gnu-link.toml    |  11 ++
 lccc/targets/x86_64-linux-gnu.toml            |   5 +
 lccc/targets/x86_64.toml                      |   2 -
 .../lcrust_panic/src/panicking/unwind.rs      |   4 +-
 lcrust/libraries/libcore/src/cmp.rs           |  69 ++++++++++-
 lcrust/libraries/libcore/src/hash.rs          |  52 +++++++-
 lcrust/libraries/libcore/src/hash/siphash.rs  |  87 --------------
 .../libcore/src/hash/siphash/clever.rs        | 105 ----------------
 .../libcore/src/hash/siphash/generic.rs       |  61 ----------
 .../libraries/libcore/src/hash/siphash/x86.rs | 113 ------------------
 lcrust/libraries/libcore/src/hint.rs          |  33 +++--
 lcrust/libraries/libcore/src/intrinsics.rs    |  18 +--
 lcrust/libraries/libcore/src/mem.rs           |  28 +++--
 lcrust/libraries/libstd/src/panic.rs          |  16 ++-
 xlang/xlang_abi/src/alloc.rs                  |  59 +++------
 xlang/xlang_abi/src/ptr.rs                    |   2 +-
 xlang/xlang_abi/src/vec.rs                    |  22 +++-
 xlang/xlang_backend/src/ssa.rs                |  45 ++++++-
 xlang/xlang_host/src/lib.rs                   |   1 +
 xlang/xlang_host/src/primitives.rs            |  38 ------
 xlang/xlang_struct/src/lib.rs                 |  36 +++++-
 xlang/xlang_struct/src/validate.rs            |   1 +
 34 files changed, 466 insertions(+), 521 deletions(-)
 rename lccc/targets/{ => arch}/x86/builtins.toml (100%)
 create mode 100644 lccc/targets/arch/x86/features.toml
 rename lccc/targets/{ => arch}/x86/machines.toml (100%)
 create mode 100644 lccc/targets/arch/x86_64-llp64-windows.toml
 create mode 100644 lccc/targets/arch/x86_64-llp64.toml
 create mode 100644 lccc/targets/arch/x86_64-lp64.toml
 create mode 100644 lccc/targets/arch/x86_64.toml
 create mode 100644 lccc/targets/os/linux.toml
 create mode 100644 lccc/targets/os/linux/x86_64-gnu-link.toml
 create mode 100644 lccc/targets/x86_64-linux-gnu.toml
 delete mode 100644 lccc/targets/x86_64.toml
 delete mode 100644 lcrust/libraries/libcore/src/hash/siphash.rs
 delete mode 100644 lcrust/libraries/libcore/src/hash/siphash/clever.rs
 delete mode 100644 lcrust/libraries/libcore/src/hash/siphash/generic.rs
 delete mode 100644 lcrust/libraries/libcore/src/hash/siphash/x86.rs
 create mode 100644 xlang/xlang_struct/src/validate.rs

diff --git a/autobuild b/autobuild
index d13ec442..b65ef674 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit d13ec44269711b6a71d5789204f7f6114dae28db
+Subproject commit b65ef674bf42fef3b7966fbfa1b945a7c2047a31
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 684b512f..c4a312c1 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -31,6 +31,7 @@ pub enum X86ValLocation {
     Register(X86Register),
 }
 
+#[derive(Clone, Debug)]
 pub struct LocationAssignment {
     foreign_location: X86ValLocation,
     owning_bb: u32,
@@ -50,7 +51,12 @@ pub struct X86Assignments {
     assigns: HashMap<u32, LocationAssignment>,
 }
 
-pub struct X86Clobbers {}
+pub struct X86Clobbers {
+    reg_owners: HashMap<X86Register, u32>,
+    clobbered_at: HashMap<u32, usize>,
+}
+
+impl X86Clobbers {}
 
 fn xor_opcode(class: X86RegisterClass, hint_vec_is_int: bool) -> X86CodegenOpcode {
     match class {
@@ -229,7 +235,22 @@ impl Machine for X86Machine {
         incoming_set: &HashMap<u32, xlang::abi::vec::Vec<xlang_backend::ssa::OpaqueLocation>>,
         tys: &TypeInformation,
     ) -> Self::BlockClobbers {
-        let mut clobbers = X86Clobbers {};
+        let mut clobbers = X86Clobbers {
+            reg_owners: HashMap::new(),
+            clobbered_at: HashMap::new(),
+        };
+
+        for loc in incoming {
+            let id = loc.num;
+            if let Some(loc) = assignments.assigns.get(&id) {
+                match &loc.foreign_location {
+                    X86ValLocation::Register(reg) => {
+                        clobbers.reg_owners.insert(*reg, id);
+                    }
+                    X86ValLocation::Null => {}
+                }
+            }
+        }
         for (num, insn) in insns.iter().enumerate() {
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
@@ -293,6 +314,8 @@ impl Machine for X86Machine {
                 | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
+                    eprintln!("{:?}", foreign_locs);
+
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
                         match (
                             assignments
@@ -330,9 +353,7 @@ impl Machine for X86Machine {
                                     },
                                 );
                             }
-                            (None, None) => {
-                                todo!("Allocate register {} => {}", old_loc, new_loc);
-                            }
+                            (None, None) => {}
                         }
                     }
                 }
diff --git a/lc-binutils b/lc-binutils
index 4665334c..fc968a49 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 4665334c544d00046c4b309d998e3813c99dabf5
+Subproject commit fc968a4985c0a8396e09d22e413590de78b0fa64
diff --git a/lccc/src/session.rs b/lccc/src/session.rs
index 86a647c1..dad9b568 100644
--- a/lccc/src/session.rs
+++ b/lccc/src/session.rs
@@ -53,7 +53,7 @@ impl<'a> DriverSession<'a> {
     pub fn find_msvc(&mut self) {
         #[cfg(target_os_family = "windows")]
         {
-            if self.is_crosscompiling {
+            if !self.is_crosscompiling {
                 // Find msvc install
                 self.msvc = Some(MsvcSysroot {})
             }
diff --git a/lccc/targets/x86/builtins.toml b/lccc/targets/arch/x86/builtins.toml
similarity index 100%
rename from lccc/targets/x86/builtins.toml
rename to lccc/targets/arch/x86/builtins.toml
diff --git a/lccc/targets/arch/x86/features.toml b/lccc/targets/arch/x86/features.toml
new file mode 100644
index 00000000..981bb706
--- /dev/null
+++ b/lccc/targets/arch/x86/features.toml
@@ -0,0 +1,71 @@
+
+[x87.meta]
+description="""
+Enables use of the x87 Floating-point unix.
+Required for the calling conventions of most 32-bit non-softfloat x86 targets
+"""
+
+
+[mmx.meta]
+description="""
+Multimedia Extension Technologies.
+Not generally used, except via intrinsics
+"""
+
+
+[sse.meta]
+description="""
+Streaming SIMD Extensions.
+Required for the calling conventions of most 64-bit non-softfloat x86 targets 
+"""
+
+[sse2.meta]
+description="""
+Streaming SIMD Extensions 2
+"""
+
+[sse3.meta]
+description="""
+Streaming SIMD Extensions 3
+"""
+
+[ssse3.meta]
+description="""
+Supplemental Streaming SIMD Extensions 3
+"""
+
+[sse4.meta]
+description="""
+Streaming SIMD Extensions 4
+"""
+
+[sse4a.meta]
+description="""
+Streaming SIMD Extensions 4 (AMD Additional Instructions)
+"""
+
+['sse4.1'.meta]
+description="""
+Streaming SIMD Extensions 4.1
+"""
+
+['sse4.2'.meta]
+description="""
+Streaming SIMD Extensions 4.2 (String and Text New Instructions)
+"""
+
+[avx.meta]
+description="""
+Advanced Vector Extensions
+"""
+
+[avx2.meta]
+description="""
+Advanced Vector Extensions 2
+"""
+
+[avx512f.meta]
+description="""
+Advanced Vector Extensions (512-bit) Floating-point instructions
+"""
+
diff --git a/lccc/targets/x86/machines.toml b/lccc/targets/arch/x86/machines.toml
similarity index 100%
rename from lccc/targets/x86/machines.toml
rename to lccc/targets/arch/x86/machines.toml
diff --git a/lccc/targets/arch/x86_64-llp64-windows.toml b/lccc/targets/arch/x86_64-llp64-windows.toml
new file mode 100644
index 00000000..5980f41a
--- /dev/null
+++ b/lccc/targets/arch/x86_64-llp64-windows.toml
@@ -0,0 +1,16 @@
+intbits=32
+longbits=32
+llongbits=64
+max-align=16
+intmaxbits=64
+sizebits=64
+lock-free-atomics=[8,16,32,64]
+max-atomic-align=16
+ldbl-align=8
+ldbl-format="ieee64"
+
+[ptr]
+nearbits=64
+farbits=64
+data-width="near"
+fn-width="near"
\ No newline at end of file
diff --git a/lccc/targets/arch/x86_64-llp64.toml b/lccc/targets/arch/x86_64-llp64.toml
new file mode 100644
index 00000000..456060d9
--- /dev/null
+++ b/lccc/targets/arch/x86_64-llp64.toml
@@ -0,0 +1,16 @@
+intbits=32
+longbits=32
+llongbits=64
+max-align=16
+intmaxbits=64
+sizebits=64
+lock-free-atomics=[8,16,32,64]
+max-atomic-align=16
+ldbl-align=16
+ldbl-format="x87-double-extended"
+
+[ptr]
+nearbits=64
+farbits=64
+data-width="near"
+fn-width="near"
\ No newline at end of file
diff --git a/lccc/targets/arch/x86_64-lp64.toml b/lccc/targets/arch/x86_64-lp64.toml
new file mode 100644
index 00000000..9736348a
--- /dev/null
+++ b/lccc/targets/arch/x86_64-lp64.toml
@@ -0,0 +1,16 @@
+intbits=32
+longbits=64
+llongbits=64
+max-align=16
+intmaxbits=64
+sizebits=64
+lock-free-atomics=[8,16,32,64]
+max-atomic-align=16
+ldbl-align=16
+ldbl-format="x87-double-extended"
+
+[ptr]
+nearbits=64
+farbits=64
+data-width="near"
+fn-width="near"
\ No newline at end of file
diff --git a/lccc/targets/arch/x86_64.toml b/lccc/targets/arch/x86_64.toml
new file mode 100644
index 00000000..56747b48
--- /dev/null
+++ b/lccc/targets/arch/x86_64.toml
@@ -0,0 +1,10 @@
+lock-free-atomics = [8, 16, 32, 64]
+builtins.include="x86/builtins"
+machines.include="x86/machine"
+default-machine="x86-64"
+width=64
+abi-properties.include="x86/abi"
+
+[meta]
+in-tree-backend="x86"
+backend-maintainers=["Connor Horman <chorman@lcdev.xyz>"]
diff --git a/lccc/targets/os/linux.toml b/lccc/targets/os/linux.toml
new file mode 100644
index 00000000..4ca17e11
--- /dev/null
+++ b/lccc/targets/os/linux.toml
@@ -0,0 +1,13 @@
+unix-like = true
+windows-like = true
+os-family = ["linux", "unix"]
+static-prefix = "lib"
+static-suffix = ".a"
+dynamic-prefix = "lib"
+dynamic-suffix=".so"
+exec-suffix=""
+obj-suffix=".o"
+ld-flavour="ld"
+ar-flavour="ar"
+base-dirs=["/", "/usr", "/usr/local"]
+so-kind="linkable"
\ No newline at end of file
diff --git a/lccc/targets/os/linux/x86_64-gnu-link.toml b/lccc/targets/os/linux/x86_64-gnu-link.toml
new file mode 100644
index 00000000..aa9e5898
--- /dev/null
+++ b/lccc/targets/os/linux/x86_64-gnu-link.toml
@@ -0,0 +1,11 @@
+libdirs = ["lib", "lib64"]
+default-libs=["c"]
+startfiles=["crt1.o", "crti.o"]
+endfiles=["crtn.o"]
+available-formats=[]
+interp="ld-linux-x86-64.so.2"
+obj-binfmt="elf64-x86_64"
+lib-binfmt="elf64-x86_64"
+exec-binfmt="elf64-x86_64"
+stack-attribute-control="gnu-stack"
+uwtable-method="itanium"
\ No newline at end of file
diff --git a/lccc/targets/x86_64-linux-gnu.toml b/lccc/targets/x86_64-linux-gnu.toml
new file mode 100644
index 00000000..e21720b2
--- /dev/null
+++ b/lccc/targets/x86_64-linux-gnu.toml
@@ -0,0 +1,5 @@
+primitives.include="arch/x86_64-lp64"
+os.include="os/linux"
+arch.include="arch/x86_64"
+default-tag-name="SysV64"
+system-tag-name="SysV64"
\ No newline at end of file
diff --git a/lccc/targets/x86_64.toml b/lccc/targets/x86_64.toml
deleted file mode 100644
index 514a48a6..00000000
--- a/lccc/targets/x86_64.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[arch]
-lock-free-atomics = [8, 16, 32, 64]
diff --git a/lcrust/libraries/lcrust_panic/src/panicking/unwind.rs b/lcrust/libraries/lcrust_panic/src/panicking/unwind.rs
index 02455e5c..8ed5f27c 100644
--- a/lcrust/libraries/lcrust_panic/src/panicking/unwind.rs
+++ b/lcrust/libraries/lcrust_panic/src/panicking/unwind.rs
@@ -115,14 +115,12 @@ pub unsafe fn begin_unwind(o: *mut PanicUnwindInfo) -> !{
 
 
 #[cfg_attr(define_lang_items, lang = "lcrust_catch_unwind_landing_pad_symbol")]
-pub unsafe fn catch_unwind_landing_pad(_: *mut dyn FnOnce()->*mut !, p: *mut ForeignExceptionType) -> Result<*mut !,Box<dyn Any>>{
+pub unsafe fn catch_unwind_landing_pad(_: *mut dyn FnOnce(), p: *mut c_void) -> Result<(),Box<dyn Any>>{
     Err(__catch_unwind_landing_pad(p))
 }
 
 
 
-
-
 #[cfg_attr(define_lang_items, lang = "lcrust_begin_panic_symbol")]
 #[cfg_attr(define_lang_items, lcrust::weak_def)]
 #[cfg_attr(not(define_lang_items), panic_handler)]
diff --git a/lcrust/libraries/libcore/src/cmp.rs b/lcrust/libraries/libcore/src/cmp.rs
index 1c3f70ac..ed91589e 100644
--- a/lcrust/libraries/libcore/src/cmp.rs
+++ b/lcrust/libraries/libcore/src/cmp.rs
@@ -30,10 +30,12 @@ pub trait PartialEq<Rhs = Self> {
     }
 }
 
+#[repr(i8)]
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Ordering {
-    Less,
-    Equal,
-    Greater,
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
 }
 
 #[lang = "partial_ord"]
@@ -134,3 +136,64 @@ pub macro Ord($item:item) {}
 #[rustc_builtin_macro]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro Eq($item:item) {}
+
+macro_rules! cmp_int {
+    ($($ty:ty),* $(,)?) => {
+        $(
+            impl PartialEq for $ty{
+                #[inline(always)]
+                fn eq(&self, other: &Self) -> bool{
+                    *self == *other
+                }
+            }
+
+            impl Eq for $ty{}
+
+            impl Ord for $ty{
+                #[inline(always)]
+                fn cmp(&self, other: &Self) -> Ordering{
+                    let ord = core::intrinsics::__builtin_cmp::<$ty, i32>(*self, *other);
+
+                    // Safety:
+                    // `__builtin_cmp` returns `-1`, `0`, or `1` ordering to comparison b/c this is an integer type
+                    unsafe{core::mem::transmute_copy(&ord)}
+                }
+            }
+            impl PartialOrd for $ty{
+                #[inline(always)]
+                fn partial_cmp(&self, other: &Self) -> Option<Ordering>{
+                    Some(<$ty>::cmp(self, other))
+                }
+            }
+        )*
+    }
+}
+
+cmp_int!(i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);
+
+macro_rules! cmp_float {
+    ($($ty:ty),* $(,)?) => {
+        $(
+            impl PartialEq for $ty{
+                #[inline(always)]
+                fn eq(&self, other: &Self) -> bool{
+                    *self == *other
+                }
+            }
+            impl PartialOrd for $ty{
+                #[inline]
+                fn partial_cmp(&self, other: &Self) -> Option<Ordering>{
+                    let ord = core::intrinsics::__builtin_cmp::<$ty, core::mem::MaybeUninit<i32>>(*self, *other);
+                    match (self.is_nan(), other.is_nan()){
+                        // SAFETY:
+                        // `__builtin_cmp` returns `-1`, `0`, or `1` ordering to comparison b/c this is an integer type
+                        (false, false) => Some(unsafe{core::mem::transmute_copy(&ord)}),
+                        _ => None
+                    }
+                }
+            }
+        )*
+    }
+}
+
+cmp_float!(f32, f64);
diff --git a/lcrust/libraries/libcore/src/hash.rs b/lcrust/libraries/libcore/src/hash.rs
index c63a4da1..5d0262ee 100644
--- a/lcrust/libraries/libcore/src/hash.rs
+++ b/lcrust/libraries/libcore/src/hash.rs
@@ -1,6 +1,39 @@
 #[unstable(feature = "lcrust_siphash_impl")]
+#[path = "../../lccc-siphash/src/lib.rs"]
 pub mod siphash;
 
+#[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
+pub struct SipHasher(siphash::siphash::SipHasher<2, 4>);
+
+impl Hasher for SipHasher {
+    fn finish(&self) -> u64 {
+        self.0.finish()
+    }
+    fn write_bytes(&mut self, bytes: &[u8]) {
+        self.0.write_bytes(bytes)
+    }
+}
+
+impl SipHasher {
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
+    #[lcrust::const_unstable(feature = "const_hash", issue = "104061")]
+    #[must_use]
+    pub const fn new() -> Self {
+        Self::new_with_keys(0, 0)
+    }
+
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[deprecated(since = "1.13.0", note = "use `std::hash::DefaultHasher` instead")]
+    #[lcrust::const_unstable(feature = "const_hash", issue = "104061")]
+    #[must_use]
+    pub const fn new_with_keys(k0: u64, k1: u64) -> Self {
+        Self(siphash::siphash::SipHasher::<2, 4>::with_keys(k0, k1))
+    }
+}
+
 pub trait Hasher {
     fn finish(&self) -> u64;
     fn write_bytes(&mut self, bytes: &[u8]);
@@ -14,31 +47,40 @@ pub trait Hasher {
         self.write_bytes(i.as_ne_bytes())
     }
     fn write_i16(&mut self, i: i16) {
-        self.write_bytes(i.as_ne_bytes())
+        self.write_u16(i as u16)
     }
     fn write_u32(&mut self, i: u32) {
         self.write_bytes(i.as_ne_bytes())
     }
     fn write_i32(&mut self, i: i32) {
-        self.write_bytes(i.as_ne_bytes())
+        self.write_u32(i as u32)
     }
     fn write_u64(&mut self, i: u64) {
         self.write_bytes(i.as_ne_bytes())
     }
     fn write_i64(&mut self, i: i64) {
-        self.write_bytes(i.as_ne_bytes())
+        self.write_u64(i as u64)
     }
     fn write_u128(&mut self, i: u128) {
         self.write_bytes(i.as_ne_bytes())
     }
     fn write_i128(&mut self, i: i128) {
-        self.write_bytes(i.as_ne_bytes())
+        self.write_u128(i as u128)
     }
     fn write_usize(&mut self, i: usize) {
         self.write_bytes(i.as_ne_bytes())
     }
     fn write_isize(&mut self, i: isize) {
-        self.write_bytes(i.as_ne_bytes())
+        self.write_usize(i as usize)
+    }
+    #[unstable(feature = "hasher_prefixfree_extras", issue = "96762")]
+    fn write_length_prefix(&self, len: usize) {
+        self.write_usize(len)
+    }
+    #[unstable(feature = "hasher_prefixfree_extras", issue = "96762")]
+    fn write_str(&mut self, s: &str) {
+        self.write(s.as_bytes());
+        self.write_u8(0xff);
     }
 }
 
diff --git a/lcrust/libraries/libcore/src/hash/siphash.rs b/lcrust/libraries/libcore/src/hash/siphash.rs
deleted file mode 100644
index 2452fe4a..00000000
--- a/lcrust/libraries/libcore/src/hash/siphash.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-const SIPHASH_MAG1: u64 = 0x736f6d6570736575;
-const SIPHASH_MAG2: u64 = 0x646f72616e646f6d;
-const SIPHASH_MAG3: u64 = 0x6c7967656e657261;
-const SIPHASH_MAG4: u64 = 0x7465646279746573;
-
-#[cfg_attr(target_arch = "clever", path = "siphash/clever.rs")]
-#[cfg_attr(any(target_arch = "x86", target_arch = "x86_64")), path = "siphash/x86.rs"]
-#[cfg_attr(not(any(target_arch = "clever", target_arch = "x86", target_arch = "x86_64")), path = "siphash/generic.rs")]
-mod sys;
-
-pub struct SipHasher<const C: usize, const D: usize>{state: SipHashState, tail: u64, ntail: usize};
-
-impl<const C: usize, const D: usize> SipHasher<C, D> {
-    pub fn new_with_keys(k0: u64, k1: u64) -> Self {
-        Self(sys::SipHashState::from_keys(k0, k1))
-    }
-
-    fn update(&mut self, word: u64) {
-        self.0.update_before_rounds(word);
-        for _ in 0..C {
-            self.0.round();
-        }
-        self.0.update_after_rounds(word);
-    }
-}
-
-impl<const C: usize, const D: usize> Hasher for SipHasher<C, D> {
-    #[inline]
-    fn write(&mut self, mut s: &[u8]) {
-
-        if ntail > 0{
-            let required = s.len().min(8-ntail);
-            let (l,r) = s.split_at(required);
-
-            crate::mem::transmute(&self.tail)[ntail..][..required].copy_from_slice(l);
-
-            s = r;
-            if required+ntail==8{
-                self.update(self.tail.to_le());
-                self.ntail = 0;
-            }
-        }
-
-        let chunks_exact = s.chunks_exact(8);
-        let remainder = chunks_exact.remainder();
-        for c in chunks_exact {
-            let word = u64::from_ne_bytes(unsafe { *(c as *const [u8] as *const [u8; 8]) });
-
-            self.update(word);
-        }
-
-        if !remainder.is_empty() {
-            let mut bytes = [0u8; 8];
-            self.ntail = remainder.len();
-            bytes[..self.ntail].copy_from_slice(remainder);
-            self.tail = u64::from_ne_bytes(bytes);
-            
-        }
-    }
-
-    #[inline]
-    fn finish(&self) -> u64 {
-        let mut state = self.0;
-
-        if self.ntail >= 0{
-            let mut val = self.tail.to_le();
-
-            if cfg!(target_endian = "big"){
-                val >>= ((8-ntail)<<3);
-            }
-
-            state.update_before_rounds(word);
-            for _ in 0..C {
-                state.round();
-            }
-            state.update_after_rounds(word);
-        }
-
-        state.update_before_final();
-
-        for _ in 0..D {
-            state.round();
-        }
-
-        state.finish().to_le()
-    }
-}
\ No newline at end of file
diff --git a/lcrust/libraries/libcore/src/hash/siphash/clever.rs b/lcrust/libraries/libcore/src/hash/siphash/clever.rs
deleted file mode 100644
index c0b5bafe..00000000
--- a/lcrust/libraries/libcore/src/hash/siphash/clever.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-
-#[cfg(target_feature = "vec")]
-use super::*;
-
-use crate::arch::clever::*;
-
-#[cfg(target_feature = "vec-ext")]
-#[inline(always)]
-fn vec_load(x: u64, y: u64) -> __v128{
-    unsafe{__vload(x,y)}
-}
-
-#[cfg(all(target_feature = "vec", not(target_feature = "vec-ext")))]
-#[inline(always)]
-fn vec_load(x: u64, y: u64) -> __v128{
-    let val = ((y as u128)<<64) | (x as u128);
-    unsafe{core::mem::transmute(val)}
-}
-
-
-#[inline(always)]
-fn collect_by_place(mut s0: __v128, mut s1: __v128) -> (__v128, __v128){
-    __xchg(hi_u64(&mut s0), lo_u64(&mut s1));
-
-    (s0,s1)
-}
-
-
-#[cfg(target_feature = "vec")]
-pub struct SipHashState(__v128, __v128);
-
-#[cfg(target_feature = "vec")]
-impl SipHashState{
-    #[inline]
-    pub fn from_keys(k0: u64, k1: u64) -> Self{
-        let keys = vec_load(k0,k1)
-        let mut s0 =  vec_load(SIPHASH_MAG1,SIPHASH_MAG2);
-        let mut s1 = vec_load(SIPHASH_MAG3, SIPHASH_MAG4);
-
-        s0 = unsafe{__vec_binary::<BinaryOp::Xor,8>(s0, keys)};
-        s1 = unsafe{__vec_binary::<BinaryOp::Xor,8>(s1, keys)};
-
-        (s0, s1) = collect_by_place(s0, s1);
-        Self(s0,s1)
-    }
-
-    #[inline]
-    pub fn update_before_rounds(&mut self, word: u64){
-        *hi_u64(&mut self.1) ^= word;
-    }
-
-    #[inline]
-    pub fn update_after_rounds(&mut self, word: u64){
-        *lo_u64(&mut self.0) ^= word;
-    }
-
-    #[inline]
-    pub fn update_before_final(&mut self){
-        *lo_u64(&mut self.1) ^= 0xff;
-    }
-
-    #[inline]
-    pub fn finish(&self) -> u64{
-        let s0 = self.0;
-        let s1 = self.1;
-
-        let s0 = unsafe{__vec_binary::<BinaryOp::Xor,8>(s0,s1)};
-
-        unsafe{__vec_binary::<BinaryOp::Xor,8>(collect, s0)}
-    }
-}
-
-#[cfg(all(target_feature = "vec", target_feature = "hash-accel"))]
-impl SipHashState{
-    #[inline]
-    pub fn round(&mut self){
-        unsafe{__sipround(&mut self,0, &mut self.1)}
-    }
-}
-
-#[cfg(all(target_feature = "vec", not(target_feature = "hash-accel")))]
-impl SipHashState{
-
-    #[inline]
-    fn halfround(&mut self, rotate: __v128){
-        self.0 = unsafe{__vec_binary::<BinaryOp::Add,8>(self.0,self.1)};
-        self.1 = unsafe{__vec_binary::<BinaryOp::Lrot,8>(self.1,rotate)};
-        self.1 = unsafe{__vec_binary::<BinaryOp::Xor,8>(self.1,self.0)};
-        self.0 = unsafe{__vec_permute::<4, 0x1023>(self.0)};
-    }
-
-    #[inline]
-    pub fn round(&mut self){
-
-        let rotate1 = vec_load(13,16);
-        let rotate2 = vec_load(17,21);
-
-        self.halfround(rotate1);
-        self.halfround(rotate2);
-
-    }
-}
-
-#[cfg(not(target_feature = "vec"))]
-include!("generic.rs");
\ No newline at end of file
diff --git a/lcrust/libraries/libcore/src/hash/siphash/generic.rs b/lcrust/libraries/libcore/src/hash/siphash/generic.rs
deleted file mode 100644
index 4874d834..00000000
--- a/lcrust/libraries/libcore/src/hash/siphash/generic.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use super::*;
-
-#[derive(Copy, Clone, Debug)]
-pub struct SipHashState(u64, u64, u64, u64);
-
-impl SipHashState {
-    #[inline]
-    pub fn from_keys(k0: u64, k1: u64) -> Self {
-        Self(
-            k0 ^ SIPHASH_MAG1,
-            k1 ^ SIPHASH_MAG2,
-            k0 ^ SIPHASH_MAG3,
-            k1 ^ SIPHASH_MAG4,
-        )
-    }
-
-    #[inline]
-    fn halfround(
-        mut v0: u64,
-        mut v1: u64,
-        mut v2: u64,
-        mut v3: u64,
-        rotate1: u32,
-        rotate2: u32,
-    ) -> (u64, u64, u64, u64) {
-        v0 = v0.wrapping_add(v1);
-        v2 = v2.wrapping_add(v3);
-        v1 = v1.rotate_left(rotate1) ^ v0;
-        v3 = v3.rotate_left(rotate2) ^ v2;
-
-        v0 = v0.rotate_left(32);
-
-        (v2, v1, v0, v3)
-    }
-
-    #[inline]
-    pub fn round(&mut self) {
-        let (v2, v1, v0, v3) = Self::halfround(self.0, self.1, self.2, self.3, 13, 16);
-        (self.0, self.1, self.2, self.3) = Self::halfround(v2, v1, v0, v3, 17, 21);
-    }
-
-    #[inline]
-    pub fn update_before_rounds(&mut self, word: u64) {
-        self.3 ^= word;
-    }
-
-    #[inline]
-    pub fn update_after_rounds(&mut self, word: u64) {
-        self.0 ^= word;
-    }
-
-    #[inline]
-    pub fn update_before_final(&mut self) {
-        self.2 ^= 0xff;
-    }
-
-    #[inline]
-    pub fn finish(&self) -> u64 {
-        self.0 ^ self.1 ^ self.2 ^ self.3
-    }
-}
diff --git a/lcrust/libraries/libcore/src/hash/siphash/x86.rs b/lcrust/libraries/libcore/src/hash/siphash/x86.rs
deleted file mode 100644
index bf8e4763..00000000
--- a/lcrust/libraries/libcore/src/hash/siphash/x86.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-#[cfg(target_arch = "x86")]
-use crate::arch::x86::*;
-
-#[cfg(target_arch = "x86_64")]
-use crate::arch::x86_64::*;
-
-#[cfg(target_feature = "sse3")]
-mod sse {
-    use core::hash::Hasher;
-
-    use super::super::*;
-    
-    use core::arch::x86_64::*;
-
-    #[cfg(target_feature = "avx2")]
-    #[inline]
-    pub extern "sysv64" fn rotate_lanes_epi64(v: __m128i, count: __m128i) -> __m128i {
-        let lshift = count;
-        let rshift = unsafe { _mm_sub_epi64(_mm_set_epi64x(64, 64), count) };
-
-        let left = unsafe { _mm_sllv_epi64(v, lshift) };
-        let right = unsafe { _mm_srlv_epi64(v, rshift) };
-
-        unsafe { _mm_or_si128(left, right) }
-    }
-
-    #[cfg(not(target_feature = "avx2"))]
-    #[inline]
-    pub extern "sysv64" fn rotate_lanes_epi64(v: __m128i, count: __m128i) -> __m128i {
-        let lshift = count;
-        let rshift = unsafe { _mm_sub_epi64(_mm_set_epi64x(64, 64), count) };
-
-        let l0 = unsafe { _mm_unpacklo_epi64(v, v) };
-        let l1 = unsafe { _mm_unpackhi_epi64(v, v) };
-
-        let r0 = l0;
-        let r1 = l1;
-
-        let l0 = unsafe { _mm_sll_epi64(l0, lshift) };
-        let r0 = unsafe { _mm_sll_epi64(l0, lshift) };
-        let lshift = unsafe { `shuffle_epi32(lshift, 0b01_00_11_10) };
-        let rshift = unsafe { _mm_shuffle_epi32(lshift, 0b01_00_11_10) };
-        let l1 = unsafe { _mm_sll_epi64(l1, lshift) };
-        let r1 = unsafe { _mm_sll_epi64(l1, lshift) };
-
-        unsafe { _mm_or_si128(_mm_unpacklo_epi64(l0, l1), _mm_unpacklo_epi64(r0, r1)) }
-    }
-
-    #[derive(Copy, Clone, Debug)]
-    pub struct SipHashState(__m128i, __m128i);
-
-    impl SipHashState {
-        #[inline]
-        fn from_keys(k0: u64, k1: u64) -> Self {
-            let mut s0: __m128i = unsafe { _mm_set_epi64x(SIPHASH_MAG2, SIPHASH_MAG1) };
-            let mut s1: __m128i = unsafe { _mm_set_epi64x(SIPHASH_MAG4, SIPHASH_MAG3) };
-            let keys: __m128i = unsafe { _mm_set_epi64x(k1 as i64, k0 as i64) };
-            s0 = unsafe { _mm_xor_si128(s0, keys) };
-            s1 = unsafe { _mm_xor_si128(s1, keys) };
-
-            Self(unsafe { _mm_unpacklo_epi64(s0, s1) }, unsafe {
-                _mm_unpackhi_epi64(s0, s1)
-            })
-        }
-
-        #[inline]
-        fn update_before_rounds(&mut self, word: u64) {
-            let val: __m128i = unsafe { core::mem::transmute([0, word]) };
-            self.1 = unsafe { _mm_xor_si128(self.1, val) };
-        }
-
-        #[inline]
-        fn update_after_rounds(&mut self, word: u64) {
-            let val: __m128i = unsafe { _mm_loadu_si64(&word as *const u64 as *const _) };
-            self.0 = unsafe { _mm_xor_si128(self.0, val) };
-        }
-
-        #[inline]
-        fn update_before_final(&mut self) {
-            let val: __m128i = unsafe { core::mem::transmute([0xffu64, 0]) };
-            self.1 = unsafe { _mm_xor_si128(self.1, val) };
-        }
-
-        #[inline]
-        fn finish(mut self) -> u64 {
-            self.0 = unsafe { _mm_xor_si128(self.0, self.1) };
-            let [l, h]: [u64; 2] = unsafe { core::mem::transmute(self.0) };
-            l ^ h
-        }
-
-        #[inline]
-        fn halfround(mut s0: __m128i, mut s1: __m128i, rotate: __m128i) -> (__m128i, __m128i) {
-            s0 = unsafe { _mm_add_epi64(s0, s1) };
-            s1 = rotate_lanes_epi64(s1, rotate);
-            s1 = unsafe { _mm_xor_si128(s1, s0) };
-            s0 = unsafe { _mm_shuffle_epi32(s0, 0b0_01_11_10) };
-
-            (s0, s1)
-        }
-
-        #[inline]
-        fn round(&mut self) {
-            (self.0, self.1) = Self::halfround(self.0, self.1, unsafe { _mm_set_epi64x(16, 13) });
-            (self.0, self.1) = Self::halfround(self.0, self.1, unsafe { _mm_set_epi64x(21, 17) });
-        }
-    }
-}
-
-#[cfg(target_feature = "sse3")]
-use sse::*;
-
-#[cfg(not(target_feature = "sse3"))]
-include!("generic.rs");
diff --git a/lcrust/libraries/libcore/src/hint.rs b/lcrust/libraries/libcore/src/hint.rs
index d6c822be..a991125a 100644
--- a/lcrust/libraries/libcore/src/hint.rs
+++ b/lcrust/libraries/libcore/src/hint.rs
@@ -5,49 +5,48 @@
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
- * 
+ *
  * Like all libraries as part of the lccc project,
- *  the lcrust standard libraries are additionally dual licensed under the terms of the MIT and Apache v2 license. 
+ *  the lcrust standard libraries are additionally dual licensed under the terms of the MIT and Apache v2 license.
  * When dealing in this software, you may, at your option, do so under only those terms,
- *  or only under the terms of the GNU Lesser General Public License, or under both sets of terms. 
+ *  or only under the terms of the GNU Lesser General Public License, or under both sets of terms.
  */
 
 #[inline(always)]
 pub unsafe fn unreachable_unchecked() -> ! {
-    k#__xir("const undef invalid uint nonzero(0)"::[yield: !])
+    core::intrinsics::__builtin_unreachable()
 }
 
 #[inline(always)]
 #[unstable(feature = "test", issue = "50297")]
 pub fn black_box<T>(x: T) -> T {
-    ::__lccc::xlang::deoptimize(x)
+    core::intrinsics::black_box(x)
 }
 
 #[inline(always)]
 pub fn spin_loop() {
-    
+    core::intirnsics::spin_loop_hint()
 }
 
 #[inline(always)]
-#[unstable(feature = "lccc_non_intrinsic_assume", issue = "none")]
-pub fn assume(#[__lccc::xlang_scalar_attributes(nonzero)] val: bool) {
-    ::__lccc::builtins::rust::__builtin_assume(val)
+#[unstable(feature = "hint_assert_unchecked", issue = "rust#119131")]
+pub fn assert_unchecked(val: bool) {
+    core::intirnsics::__builtin_assume(val)
 }
 
 #[inline(always)]
-#[unstable(feature="lccc_non_intrinsic_likely", issue = "none")]
-pub fn likely(b: bool) -> bool{
-    ::__lccc::builtins::rust::__builtin_likely(b)
+#[unstable(feature = "lccc_non_intrinsic_likely", issue = "none")]
+pub fn likely(b: bool) -> bool {
+    core::intirnsics::__builtin_likely(b)
 }
 
 #[inline(always)]
-#[unstable(feature="lccc_non_intrinsic_likely", issue = "none")]
-pub fn unlikely(b: bool) -> bool{
-    ::__lccc::builtins::rust::__builtin_unlikely(b)
+#[unstable(feature = "lccc_non_intrinsic_likely", issue = "none")]
+pub fn unlikely(b: bool) -> bool {
+    core::intirnsics::__builtin_unlikely(b)
 }
-
diff --git a/lcrust/libraries/libcore/src/intrinsics.rs b/lcrust/libraries/libcore/src/intrinsics.rs
index 8fe31110..9fdd195a 100644
--- a/lcrust/libraries/libcore/src/intrinsics.rs
+++ b/lcrust/libraries/libcore/src/intrinsics.rs
@@ -19,19 +19,11 @@
 
 #![unstable(feature = "core_intrinsics", issue = "none")]
 
-#[stable]
-pub use __lccc::builtins::rust::copy;
-#[stable]
-pub use __lccc::builtins::rust::copy_nonoverlapping;
-#[stable]
-pub use __lccc::builtins::rust::transmute;
-#[stable]
-pub use __lccc::builtins::rust::transmute_copy;
-
-pub use __lccc::builtins::C::__builtin_trap;
-pub use __lccc::builtins::C::__builtin_trap as abort;
-
-use __lccc::builtins::Rust::*;
+extern "rust-intrinsics"{
+    pub unsafe fn transmute<T,U>(x: T) -> U;
+    pub unsafe fn construct_in_place<T, F: FnOnce<Args> + FnPointer, Args: Tuple>(*mut T, F, Args);
+    pub fn __builtin_cmp<T: core::marker::Copy + core::cmp::PartialEq, U>(T, T) -> U;
+}
 
 #[track_caller]
 #[inline]
diff --git a/lcrust/libraries/libcore/src/mem.rs b/lcrust/libraries/libcore/src/mem.rs
index 16432e52..27df7590 100644
--- a/lcrust/libraries/libcore/src/mem.rs
+++ b/lcrust/libraries/libcore/src/mem.rs
@@ -5,16 +5,16 @@
  * it under the terms of the GNU Lesser General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
- * 
+ *
  * Like all libraries as part of the lccc project,
- *  the lcrust standard libraries are additionally dual licensed under the terms of the MIT and Apache v2 license. 
+ *  the lcrust standard libraries are additionally dual licensed under the terms of the MIT and Apache v2 license.
  * When dealing in this software, you may, at your option, do so under only those terms,
- *  or only under the terms of the GNU Lesser General Public License, or under both sets of terms. 
+ *  or only under the terms of the GNU Lesser General Public License, or under both sets of terms.
  */
 use crate::default::Default;
 use crate::intrinsics;
@@ -33,7 +33,9 @@ pub union MaybeUninit<T> {
 
 impl<T> MaybeUninit<T> {
     pub const fn new(x: T) -> Self {
-        Self { valid: ManuallyDrop::new(x) }
+        Self {
+            valid: ManuallyDrop::new(x),
+        }
     }
     pub const fn uninit() -> Self {
         Self { uninit: () }
@@ -153,15 +155,19 @@ unsafe impl<T: ?Sized> TrivialDestruction for ManuallyDrop<T> {}
 
 #[deprecated("use MaybeUninit instead")]
 pub unsafe fn uninitialized<T>() -> T {
-    __lccc::xir!("const undef uninit %0"::[yield: T])
+    MaybeUninit::uninit().assume_init()
 }
 
 #[__lccc::allow_constant_promotion]
-pub const fn size_of<T>() -> T{
-    ::__lccc::builtins::rust::size_of::<T>()
+pub const fn size_of<T>() -> usize {
+    intrinsics::__builtin_size_of::<T>()
 }
 
 #[__lccc::allow_constant_promotion]
-pub const fn align_of<T>() -> T{
-    ::__lccc::builtins::rust::align_of::<T>()
-}
\ No newline at end of file
+pub const fn align_of<T>() -> usize {
+    intrinsics::__builtin_align_of::<T>()
+}
+
+pub const fn size_of_val<T: ?Sized>(x: &T) -> usize {
+    intrinsics::__builtin_size_of_val(x)
+}
diff --git a/lcrust/libraries/libstd/src/panic.rs b/lcrust/libraries/libstd/src/panic.rs
index 89f78faa..a7084a66 100644
--- a/lcrust/libraries/libstd/src/panic.rs
+++ b/lcrust/libraries/libstd/src/panic.rs
@@ -12,12 +12,20 @@ fn unwrap_erased_unchecked<T>(p: *mut !) -> T {
 
 pub fn catch_unwind<F: UnwindSafe + FnOnce() -> T>(f: F) -> Result<T, Box<dyn Any>> {
     let mut slot = MaybeUninit::new()
-    let mut wrapper = ManuallyDrop::new(move || box_erased(f));
+    let mut wrapper = ManuallyDrop::new(move || 
+        unsafe{
+            core::intrinsics::construct_in_place(
+                slot.as_mut_ptr(), 
+                FnOnce::call_once, 
+                (f,),)
+        }
+    );
+    let (raw, metadata) = (addr_of_mut!(wrapper) as *mut ManuallyDrop<dyn FnOnce()>).to_raw_parts();
     catch_unwind_erased(
-        core::mem::transmute(addr_of_mut!(wrapper) as *mut ManuallyDrop<dyn FnOnce() -> *mut !>),
+        core::ptr::from_raw_parts_mut(raw, metadata),
         core::ptr::null_mut(),
     )
-    .map(unwrap_erased_unchecked)
+    .map(|()| unsafe{slot.assume_init()})
 }
 
 /**
@@ -31,7 +39,7 @@ pub fn catch_unwind<F: UnwindSafe + FnOnce() -> T>(f: F) -> Result<T, Box<dyn An
  */
 #[lang = "lcrust_catch_unwind_fn"]
 #[inline(never)]
-fn catch_unwind_erased(f: *mut dyn FnOnce() -> *mut !, _: *mut !) -> Result<*mut !, Box<dyn Any>> {
+fn catch_unwind_erased(f: *mut dyn FnOnce(), _: *mut !) -> Result<(), Box<dyn Any>> {
     Ok(FnOnce::call_once_unsized(f, ()))
 }
 
diff --git a/xlang/xlang_abi/src/alloc.rs b/xlang/xlang_abi/src/alloc.rs
index b40546db..737d9262 100644
--- a/xlang/xlang_abi/src/alloc.rs
+++ b/xlang/xlang_abi/src/alloc.rs
@@ -23,7 +23,7 @@ extern "C" {
     ///
     /// # Safety
     /// size, rounded to the next multiple of the alignment used by this function, must not be greater than `isize::MAX`
-    pub fn xlang_allocate(size: xlang_host::primitives::size_t) -> *mut core::ffi::c_void;
+    pub fn xlang_allocate(size: usize) -> *mut core::ffi::c_void;
     /// Function that allocates memory suitable for storing an object of size `size`, with at least the alignment given by `align`.
     ///
     /// This function permits allocations of size `0`, returning a pointer that is aligned to at least the given alignment
@@ -33,37 +33,25 @@ extern "C" {
     ///
     /// # Safety
     /// `align` must be a power of two. size, rounded to the next multiple of `align`, must not be greater than `isize::MAX`
-    pub fn xlang_allocate_aligned(
-        size: xlang_host::primitives::size_t,
-        align: xlang_host::primitives::size_t,
-    ) -> *mut core::ffi::c_void;
+    pub fn xlang_allocate_aligned(size: usize, align: usize) -> *mut core::ffi::c_void;
     /// Deallocates memory allocated using [`xlang_allocate`]
     ///
     /// # Safety
     /// ptr must be a null pointer, or have been allocated using [`xlang_allocate`] with `size`
-    pub fn xlang_deallocate(ptr: *mut core::ffi::c_void, size: xlang_host::primitives::size_t);
+    pub fn xlang_deallocate(ptr: *mut core::ffi::c_void, size: usize);
     /// Deallocates memory allocated using [`xlang_allocate`]
     ///
     /// # Safety
     /// ptr must be a null pointer, or have been allocated using [`xlang_allocate_aligned`] with `size` and `align`
-    pub fn xlang_deallocate_aligned(
-        ptr: *mut core::ffi::c_void,
-        size: xlang_host::primitives::size_t,
-        align: xlang_host::primitives::size_t,
-    );
+    pub fn xlang_deallocate_aligned(ptr: *mut core::ffi::c_void, size: usize, align: usize);
 
     /// Function to call when allocation fails.
-    pub fn xlang_on_allocation_failure(
-        size: xlang_host::primitives::size_t,
-        align: xlang_host::primitives::size_t,
-    ) -> !;
+    pub fn xlang_on_allocation_failure(size: usize, align: usize) -> !;
 }
 
 #[cfg(any(miri, test))]
 #[no_mangle]
-pub unsafe extern "C" fn xlang_allocate(
-    size: xlang_host::primitives::size_t,
-) -> *mut core::ffi::c_void {
+pub unsafe extern "C" fn xlang_allocate(size: usize) -> *mut core::ffi::c_void {
     if size == 0 {
         return 32usize as *mut core::ffi::c_void;
     }
@@ -80,8 +68,8 @@ pub unsafe extern "C" fn xlang_allocate(
 #[cfg(any(miri, test))]
 #[no_mangle]
 pub unsafe extern "C" fn xlang_allocate_aligned(
-    size: xlang_host::primitives::size_t,
-    align: xlang_host::primitives::size_t,
+    size: usize,
+    align: usize,
 ) -> *mut core::ffi::c_void {
     if size == 0 {
         return align as *mut core::ffi::c_void;
@@ -93,10 +81,7 @@ pub unsafe extern "C" fn xlang_allocate_aligned(
 
 #[cfg(any(miri, test))]
 #[no_mangle]
-pub unsafe extern "C" fn xlang_deallocate(
-    ptr: *mut core::ffi::c_void,
-    size: xlang_host::primitives::size_t,
-) {
+pub unsafe extern "C" fn xlang_deallocate(ptr: *mut core::ffi::c_void, size: usize) {
     if size == 0 {
         return;
     }
@@ -118,8 +103,8 @@ pub unsafe extern "C" fn xlang_deallocate(
 #[no_mangle]
 pub unsafe extern "C" fn xlang_deallocate_aligned(
     ptr: *mut core::ffi::c_void,
-    size: xlang_host::primitives::size_t,
-    align: xlang_host::primitives::size_t,
+    size: usize,
+    align: usize,
 ) {
     if size == 0 || ptr.is_null() {
         return;
@@ -131,10 +116,7 @@ pub unsafe extern "C" fn xlang_deallocate_aligned(
 
 #[cfg(any(miri, test))]
 #[no_mangle]
-pub extern "C" fn xlang_on_allocation_failure(
-    size: xlang_host::primitives::size_t,
-    align: xlang_host::primitives::size_t,
-) -> ! {
+pub extern "C" fn xlang_on_allocation_failure(size: usize, align: usize) -> ! {
     eprintln!(
         "Failed to allocate with size: {}, and alignment: {}",
         size, align
@@ -633,19 +615,15 @@ impl Default for XLangAlloc {
 unsafe impl Allocator for XLangAlloc {
     fn allocate(&self, layout: Layout) -> Option<NonNull<u8>> {
         NonNull::new(unsafe {
-            xlang_allocate_aligned(
-                layout.size() as xlang_host::primitives::size_t,
-                layout.align() as xlang_host::primitives::size_t,
-            )
-            .cast::<u8>()
+            xlang_allocate_aligned(layout.size() as usize, layout.align() as usize).cast::<u8>()
         })
     }
 
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
         xlang_deallocate_aligned(
             ptr.as_ptr().cast(),
-            layout.size() as xlang_host::primitives::size_t,
-            layout.align() as xlang_host::primitives::size_t,
+            layout.size() as usize,
+            layout.align() as usize,
         );
     }
 }
@@ -1106,12 +1084,7 @@ where
 /// Called when allocation returns an unhandled error
 pub fn handle_alloc_error(layout: Layout) -> ! {
     #![cfg_attr(test, allow(unused_unsafe))]
-    unsafe {
-        xlang_on_allocation_failure(
-            layout.size() as xlang_host::primitives::size_t,
-            layout.align() as xlang_host::primitives::size_t,
-        )
-    }
+    unsafe { xlang_on_allocation_failure(layout.size() as usize, layout.align() as usize) }
 }
 
 #[cfg(all(test, miri))]
diff --git a/xlang/xlang_abi/src/ptr.rs b/xlang/xlang_abi/src/ptr.rs
index 4a28839b..09996fd5 100644
--- a/xlang/xlang_abi/src/ptr.rs
+++ b/xlang/xlang_abi/src/ptr.rs
@@ -20,7 +20,7 @@ impl<T: ?Sized> core::hash::Hash for Unique<T> {
 
 impl<T: ?Sized> core::cmp::PartialEq for Unique<T> {
     fn eq(&self, other: &Self) -> bool {
-        self.ptr == other.ptr
+        core::ptr::eq(self.as_ptr(), other.as_ptr())
     }
 }
 
diff --git a/xlang/xlang_abi/src/vec.rs b/xlang/xlang_abi/src/vec.rs
index 6ba70f29..c7b168bb 100644
--- a/xlang/xlang_abi/src/vec.rs
+++ b/xlang/xlang_abi/src/vec.rs
@@ -295,7 +295,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// This will permanently leak the allocation and its elements.
     ///
-    /// This function is a convience over `SpanMut::new(self.leak())
+    /// This function is a convience over `SpanMut::new(self.leak())`
     pub fn leak_span<'a>(self) -> SpanMut<'a, T> {
         let this = ManuallyDrop::new(self);
         let ptr = this.ptr.as_ptr();
@@ -404,6 +404,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// Panics if `n` is greater than `len()`
     ///
+    #[allow(clippy::manual_assert)] // I don't want the extra "assertion failed" message.
     pub fn drain_back(&mut self, n: usize) -> DrainBack<T> {
         if n > self.len {
             panic!(
@@ -444,6 +445,7 @@ impl<T, A: Allocator> Vec<T, A> {
     }
 
     /// Inserts `val` into `pos`, shifting all elements after `pos` to the right
+    #[allow(clippy::manual_assert)] // I don't want the extra "assertion failed" message.
     pub fn insert(&mut self, val: T, pos: usize) {
         if pos > self.len {
             panic!(
@@ -454,9 +456,9 @@ impl<T, A: Allocator> Vec<T, A> {
 
         if self.len == self.cap {
             if self.cap == 0 {
-                self.reallocate(16)
+                self.reallocate(16);
             } else {
-                self.reallocate(self.cap << 2)
+                self.reallocate(self.cap << 2);
             }
         }
 
@@ -472,7 +474,7 @@ impl<T, A: Allocator> Vec<T, A> {
                 core::ptr::write(loc, val);
             }
         } else {
-            core::mem::forget(val)
+            core::mem::forget(val);
         }
 
         self.len += 1;
@@ -485,6 +487,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ## Panics
     ///
     /// Panics if `i` is greater than or equal to `self.len()`
+    #[allow(clippy::manual_assert)] // I don't want the extra "assertion failed" message.
     pub fn remove(&mut self, i: usize) -> T {
         if i >= self.len {
             panic!(
@@ -509,6 +512,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ## Panics
     ///
     /// Panics if `i` is greater than or equal to `self.len()`
+    #[allow(clippy::manual_assert)] // I don't want the extra "assertion failed" message.
     pub fn swap_remove(&mut self, i: usize) -> T {
         if i >= self.len {
             panic!(
@@ -532,6 +536,10 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// If `self` is not already properly sorted, or the `Ord` impl of `T` is not transitive and total, then the position is unspecified.
     /// Regardless, no element already preent in the list will be reordered relative to any other element
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the new capacity exceeds `usize::MAX`, or `isize::MAX` bytes
     pub fn insert_sorted(&mut self, val: T) -> usize
     where
         T: Ord,
@@ -545,6 +553,9 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// If `self` is not already properly sorted, or the `Ord` impl of `U` is not transitive and total, then the position is unspecified.
     /// Regardless, no element already preent in the list will be reordered relative to any other element
+    /// ## Panics
+    ///
+    /// Panics if the new capacity exceeds `usize::MAX`, or `isize::MAX` bytes
     pub fn insert_sorted_by_key<U: Ord, F: Fn(&T) -> U>(&mut self, val: T, map: F) -> usize {
         self.insert_sorted_by(val, |a, b| map(a).cmp(&map(b)))
     }
@@ -555,6 +566,9 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// If `self` is not already properly sorted according to `cmp`, or if `F` is not transitive and total, then the position is unspecified.
     /// Regardless, no element already preent in the list will be reordered relative to any other element
+    /// ## Panics
+    ///
+    /// Panics if the new capacity exceeds `usize::MAX`, or `isize::MAX` bytes
     pub fn insert_sorted_by<F: Fn(&T, &T) -> core::cmp::Ordering>(
         &mut self,
         val: T,
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 9385f654..9e562c3f 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -16,7 +16,9 @@ use xlang::{ir::JumpTarget, targets::properties::TargetProperties};
 
 use xlang::ir;
 
-use xlang::abi::{boxed::Box as XLangBox, collection::HashMap, vec::Vec};
+use xlang::abi::{
+    boxed::Box as XLangBox, collection::HashMap, option::None as XLangNone, vec::Vec,
+};
 
 struct SharedCounter(Cell<u32>);
 
@@ -676,6 +678,47 @@ impl<M: Machine> BasicBlockBuilder<M> {
                         ty: ir::Type::Pointer(new_ty.clone()),
                     }));
                 }
+                (
+                    VStackValue::Constant(ir::Value::Integer {
+                        ty:
+                            ir::ScalarType {
+                                header:
+                                    ir::ScalarTypeHeader {
+                                        vectorsize: XLangNone,
+                                        ..
+                                    },
+                                kind: ir::ScalarTypeKind::Integer { .. },
+                            },
+                        val,
+                    }),
+                    _,
+                    ir::Type::Scalar(
+                        sty @ ir::ScalarType {
+                            header:
+                                ir::ScalarTypeHeader {
+                                    bitsize: b2,
+                                    vectorsize: XLangNone,
+                                    ..
+                                },
+                            kind: ir::ScalarTypeKind::Integer { signed: s2, .. },
+                        },
+                    ),
+                ) => {
+                    let mask = !0u128 >> (128 - *b2);
+
+                    let signext = *s2;
+                    let signmask = !0u128 << *b2;
+                    let mut val = val & mask;
+
+                    if *b2 != 0 && signext {
+                        let sbit = (!(val >> (*b2 - 1))).wrapping_add(1);
+                        val |= sbit & signmask;
+                    }
+
+                    let val = ir::Value::Integer { ty: *sty, val };
+
+                    self.push(VStackValue::Constant(val));
+                }
                 x => todo!("{:?}", x),
             },
             ir::Expr::Derive(_, _) => todo!("derive"),
diff --git a/xlang/xlang_host/src/lib.rs b/xlang/xlang_host/src/lib.rs
index bedc5b90..d8a213e5 100644
--- a/xlang/xlang_host/src/lib.rs
+++ b/xlang/xlang_host/src/lib.rs
@@ -1,4 +1,5 @@
 #![deny(warnings, clippy::all, clippy::pedantic, clippy::nursery, missing_docs)]
+#![allow(unexpected_cfgs, unknown_lints)] // This is a dumbass lint we can't work arround in general
 
 //!
 //! The `xlang_host` crate provides access to the host target's apis, depending on the interfaces available from the OS
diff --git a/xlang/xlang_host/src/primitives.rs b/xlang/xlang_host/src/primitives.rs
index f5d1ae86..12f098bc 100644
--- a/xlang/xlang_host/src/primitives.rs
+++ b/xlang/xlang_host/src/primitives.rs
@@ -1,43 +1,5 @@
 #![allow(non_camel_case_types)]
 
-#[cfg(doc)]
-mod unspecified {
-    pub struct unspecified_int;
-    pub struct unspecified_uint;
-}
-
-cfg_match::cfg_match! {
-    doc => #[doc = ""] pub type uintptr = unspecified::unspecified_uint;
-    target_pointer_width = "16" => #[doc = ""] pub type uintptr = u16;
-    target_pointer_width = "32" => #[doc = ""] pub type uintptr = u32;
-    target_pointer_width = "64" => #[doc = ""] pub type uintptr = u64;
-    target_pointer_width = "128" => #[doc = ""] pub type uintptr = u128;
-}
-
-cfg_match::cfg_match! {
-    doc => #[doc = ""] pub type size_t = unspecified::unspecified_uint;
-    target_pointer_width = "16" => #[doc = ""] pub type size_t = u16;
-    target_pointer_width = "32" => #[doc = ""] pub type size_t = u32;
-    target_pointer_width = "64" => #[doc = ""] pub type size_t = u64;
-    target_pointer_width = "128" => #[doc = ""] pub type size_t = u128;
-}
-
-cfg_match::cfg_match! {
-    doc => #[doc = ""] pub type intptr = unspecified::unspecified_int;
-    target_pointer_width = "16" => #[doc = ""] pub type intptr = i16;
-    target_pointer_width = "32" => #[doc = ""] pub type intptr = i32;
-    target_pointer_width = "64" => #[doc = ""] pub type intptr = i64;
-    target_pointer_width = "128" => #[doc = ""] pub type intptr = i128;
-}
-
-cfg_match::cfg_match! {
-    doc => #[doc = ""] pub type ptrdiff_t = unspecified::unspecified_int;
-    target_pointer_width = "16" => #[doc = ""] pub type ptrdiff_t = i16;
-    target_pointer_width = "32" => #[doc = ""] pub type ptrdiff_t = i32;
-    target_pointer_width = "64" => #[doc = ""] pub type ptrdiff_t = i64;
-    target_pointer_width = "128" => #[doc = ""] pub type ptrdiff_t = i128;
-}
-
 /// A type that has the maximum fundamental alignment
 #[repr(C, align(16))]
 pub struct max_align_t(u128);
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 51dcd552..afd86c67 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -29,6 +29,8 @@ pub mod macros;
 
 pub mod fmt;
 
+pub mod validate;
+
 ///
 /// A component of a [`Path`], the name of a global object in xlang.
 ///
@@ -1576,7 +1578,6 @@ fake_enum::fake_enum! {
         Rsh = 8,
         Lsh = 9,
 
-        CmpInt = 10,
         CmpLt = 11,
         CmpGt = 12,
         CmpEq = 13,
@@ -1599,7 +1600,6 @@ impl core::fmt::Display for BinaryOp {
             Self::BitOr => f.write_str("bit_or"),
             Self::BitXor => f.write_str("bit_xor"),
             Self::Rsh => f.write_str("rsh"),
-            Self::CmpInt => f.write_str("cmp_int"),
             Self::CmpLt => f.write_str("cmp_lt"),
             Self::CmpGt => f.write_str("cmp_gt"),
             Self::CmpLe => f.write_str("cmp_le"),
@@ -2177,7 +2177,39 @@ pub enum Expr {
     /// * As a value used as an incoming value for a jump target
     Member(String),
     MemberIndirect(String),
+    /// Assigns a value to an lvalue according to `class`
+    ///
+    /// ## Stack
+    /// Type Checking: `[.., T, lvalue T]`=>`[..]`
+    ///
+    /// Operands: `[..,v, t]`=>`[..]`.
+    ///
+    /// ## Syntax:
+    /// ```abnf
+    /// expr /= "assign" <access-class>
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// Assigns the value `v` to the object designated by `t`, performing the memory operation according to `class`.
     Assign(AccessClass),
+
+    /// Reads the value designated by an lvalue according to `class`
+    ///
+    /// ## Stack
+    /// Type Checking: `[.., lvalue T]`=>`[..,T]`
+    ///
+    /// Operands: `[.., t]`=>`[.., v]`.
+    ///
+    /// ## Syntax
+    ///```abnf
+    /// expr /= "as_rvalue" <access-class>
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// Reads the value of the object designated by `t`, performing the memory operation according to `class`.
+    ///
     AsRValue(AccessClass),
     CompoundAssign(BinaryOp, OverflowBehaviour, AccessClass),
     FetchAssign(BinaryOp, OverflowBehaviour, AccessClass),
diff --git a/xlang/xlang_struct/src/validate.rs b/xlang/xlang_struct/src/validate.rs
new file mode 100644
index 00000000..2b50cb71
--- /dev/null
+++ b/xlang/xlang_struct/src/validate.rs
@@ -0,0 +1 @@
+pub struct XirValidator {}

From caf760ba79a8415df6a1652abed8efd91fa95c81 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 2 Jun 2024 16:25:42 -0400
Subject: [PATCH 43/74] feat(rust-sema): Enum discriminant changes

---
 rust/src/sema.rs    | 30 ++++++++++++-------------
 rust/src/sema/ty.rs | 53 ++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 67 insertions(+), 16 deletions(-)

diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index d2649e6d..c0eeebd4 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -1493,7 +1493,7 @@ impl Definitions {
                 Type::Bool => ty::TypeLayout {
                     size: Some(1),
                     align: Some(1),
-                    enum_discriminant: None,
+                    enum_layout: None,
                     wide_ptr_metadata: None,
                     field_offsets: HashMap::new(),
                     mutable_fields: HashSet::new(),
@@ -1521,7 +1521,7 @@ impl Definitions {
                         size: Some(size),
                         align: Some(align),
                         wide_ptr_metadata: None,
-                        enum_discriminant: None,
+                        enum_layout: None,
                         field_offsets: HashMap::new(),
                         mutable_fields: HashSet::new(),
                         niches: None,
@@ -1542,7 +1542,7 @@ impl Definitions {
                         size: Some(size),
                         align: Some(align),
                         wide_ptr_metadata: None,
-                        enum_discriminant: None,
+                        enum_layout: None,
                         field_offsets: HashMap::new(),
                         mutable_fields: HashSet::new(),
                         niches: None,
@@ -1551,7 +1551,7 @@ impl Definitions {
                 Type::Char => ty::TypeLayout {
                     size: Some(4),
                     align: Some(self.properties.primitives.max_align.min(4) as u64),
-                    enum_discriminant: None,
+                    enum_layout: None,
                     wide_ptr_metadata: None,
                     field_offsets: HashMap::new(),
                     mutable_fields: HashSet::new(),
@@ -1564,7 +1564,7 @@ impl Definitions {
                     size: None,
                     align: Some(1),
                     wide_ptr_metadata: Some(ty::Type::Int(ty::IntType::usize)),
-                    enum_discriminant: None,
+                    enum_layout: None,
                     field_offsets: HashMap::new(),
                     mutable_fields: HashSet::new(),
                     niches: None,
@@ -1572,7 +1572,7 @@ impl Definitions {
                 Type::Never => ty::TypeLayout {
                     size: Some(0),
                     align: Some(1),
-                    enum_discriminant: None,
+                    enum_layout: None,
                     wide_ptr_metadata: None,
                     field_offsets: HashMap::new(),
                     mutable_fields: HashSet::new(),
@@ -1631,7 +1631,7 @@ impl Definitions {
                     ty::TypeLayout {
                         size: Some(size),
                         align: Some(align),
-                        enum_discriminant: None,
+                        enum_layout: None,
                         wide_ptr_metadata: metadata,
                         field_offsets,
                         mutable_fields: HashSet::new(),
@@ -1649,7 +1649,7 @@ impl Definitions {
                     ty::TypeLayout {
                         size: Some(size as u64),
                         align: Some(align as u64),
-                        enum_discriminant: None,
+                        enum_layout: None,
                         wide_ptr_metadata: None,
                         field_offsets: HashMap::new(),
                         mutable_fields: HashSet::new(),
@@ -1659,7 +1659,7 @@ impl Definitions {
                 Type::FnItem(_, _, _) => ty::TypeLayout {
                     size: Some(0),
                     align: Some(1),
-                    enum_discriminant: None,
+                    enum_layout: None,
                     wide_ptr_metadata: None,
                     field_offsets: HashMap::new(),
                     mutable_fields: HashSet::new(),
@@ -1778,7 +1778,7 @@ impl Definitions {
                             ty::TypeLayout {
                                 size,
                                 align,
-                                enum_discriminant: None,
+                                enum_layout: None,
                                 wide_ptr_metadata,
                                 field_offsets,
                                 mutable_fields: HashSet::new(),
@@ -1834,7 +1834,7 @@ impl Definitions {
                         ty::TypeLayout {
                             size: Some(size),
                             align: Some(align),
-                            enum_discriminant: None,
+                            enum_layout: None,
                             wide_ptr_metadata: None,
                             field_offsets: fields,
                             mutable_fields: HashSet::new(),
@@ -1847,7 +1847,7 @@ impl Definitions {
                         ty::TypeLayout {
                             size: Some(size),
                             align: Some(align),
-                            enum_discriminant: None,
+                            enum_layout: None,
                             wide_ptr_metadata: None,
                             field_offsets: HashMap::new(),
                             mutable_fields: HashSet::new(),
@@ -1870,7 +1870,7 @@ impl Definitions {
                     ty::TypeLayout {
                         size: Some(array_size),
                         align: Some(align),
-                        enum_discriminant: None,
+                        enum_layout: None,
                         wide_ptr_metadata: None,
                         field_offsets: HashMap::new(),
                         mutable_fields: HashSet::new(),
@@ -1932,7 +1932,7 @@ impl Definitions {
                         ty::TypeLayout {
                             size: Some(size),
                             align: Some(align),
-                            enum_discriminant: None,
+                            enum_layout: None,
                             wide_ptr_metadata: None,
                             field_offsets: fields,
                             mutable_fields: HashSet::new(),
@@ -1945,7 +1945,7 @@ impl Definitions {
                         ty::TypeLayout {
                             size: Some(size),
                             align: Some(align),
-                            enum_discriminant: None,
+                            enum_layout: None,
                             wide_ptr_metadata: None,
                             field_offsets: HashMap::new(),
                             mutable_fields: HashSet::new(),
diff --git a/rust/src/sema/ty.rs b/rust/src/sema/ty.rs
index e831b5a3..bdeca9e2 100644
--- a/rust/src/sema/ty.rs
+++ b/rust/src/sema/ty.rs
@@ -898,11 +898,62 @@ pub enum Niches {
     Aggregate(Vec<(FieldName, Niches)>),
 }
 
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct NicheOptEnum {
+    /// The DefId of the construct for which niche optimization applies
+    pub niche_ctor: DefId,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum DiscrimPlacement {
+    /// Offset into the type - in lcrust v0, this is always `0`
+    Offset(u64),
+    /// The Discrimant is elided into niche-opt
+    FillNiche(NicheOptEnum),
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct EnumDiscriminant {
+    pub discrim_type: IntType,
+    pub discrim_placement: DiscrimPlacement,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct EnumLayout {
+    pub discrim: EnumDiscriminant,
+    pub variant_layouts: HashMap<DefId, VariantLayout>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct VariantLayout {
+    /// The value of the discriminant for this variant
+    pub discrim_val: u128,
+    /// The layout of the variant, including the discriminant (if not elided)
+    pub variant_layout: TypeLayout,
+    /// If the variant is a niche-ellision variant, indicate how the niche is filled
+    pub variant_niche_fill: Option<NicheFill>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct NicheFill {
+    pub niche_offset: u64,
+    pub niche_size: u64,
+    /// The value to put in the niche.
+    /// `None` means the niched field is uninhabited
+    pub niche_value: Option<NicheValue>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum NicheValue {
+    IntValue(u128),
+    NullPointer,
+}
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct TypeLayout {
     pub size: Option<u64>,
     pub align: Option<u64>,
-    pub enum_discriminant: Option<Type>,
+    pub enum_layout: Option<EnumLayout>,
     pub wide_ptr_metadata: Option<Type>,
     pub field_offsets: HashMap<FieldName, u64>,
     pub mutable_fields: HashSet<FieldName>,

From ff4f42e171dc6e1ca5f6615c59eba787015da427 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 2 Jun 2024 15:57:08 -0500
Subject: [PATCH 44/74] feat!: update to 2021

---
 Cargo.toml                            | 1 +
 autobuild                             | 2 +-
 autobuild.toml                        | 2 +-
 c/Cargo.toml                          | 2 +-
 codegen-clever/Cargo.toml             | 2 +-
 codegen-w65/Cargo.toml                | 2 +-
 codegen-x86/Cargo.toml                | 2 +-
 lc-binutils                           | 2 +-
 lccc-mangle/Cargo.toml                | 2 +-
 lccc/Cargo.toml                       | 2 +-
 lcrust/abi-proc-macro/Cargo.toml      | 2 +-
 m4/lcrust_prog_rustc.m4               | 2 +-
 rust/interning-static-syms/Cargo.toml | 2 +-
 rust/lcrustc/Cargo.toml               | 2 +-
 rust/rlib/Cargo.toml                  | 2 +-
 rust/rust_mir_macro/Cargo.toml        | 2 +-
 rust/src/interning.rs                 | 1 -
 rust/src/irgen/xir_visitor.rs         | 1 -
 rust/src/sema.rs                      | 1 -
 xir/Cargo.toml                        | 2 +-
 xlang/Cargo.toml                      | 2 +-
 xlang/xlang_abi/Cargo.toml            | 2 +-
 xlang/xlang_abi_macro/Cargo.toml      | 2 +-
 xlang/xlang_backend/Cargo.toml        | 2 +-
 xlang/xlang_backend/src/ty.rs         | 2 --
 xlang/xlang_frontend/Cargo.toml       | 2 +-
 xlang/xlang_frontend/src/parse.rs     | 2 +-
 xlang/xlang_frontend/src/symbol.rs    | 1 -
 xlang/xlang_host/Cargo.toml           | 2 +-
 xlang/xlang_interface/Cargo.toml      | 2 +-
 xlang/xlang_opt/Cargo.toml            | 2 +-
 xlang/xlang_struct/Cargo.toml         | 2 +-
 xlang/xlang_struct/src/lib.rs         | 1 -
 xlang/xlang_targets/Cargo.toml        | 2 +-
 xlangtransparent/Cargo.toml           | 2 +-
 35 files changed, 29 insertions(+), 35 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 13bb7a81..e2d5923c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,3 +15,4 @@ members = [
     "rust/rust_mir_macro",
 ]
 exclude = []
+resolver = "2"
diff --git a/autobuild b/autobuild
index b65ef674..03185c52 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit b65ef674bf42fef3b7966fbfa1b945a7c2047a31
+Subproject commit 03185c52a7562065eed8e41bdd911c7f6940b169
diff --git a/autobuild.toml b/autobuild.toml
index 8a0593c7..0999c2fe 100644
--- a/autobuild.toml
+++ b/autobuild.toml
@@ -36,7 +36,7 @@ deps=["xlang"]
 subdir="lccc"
 
 [defaults.rust]
-edition="2018"
+edition="2021"
 
 [stages.host]
 build=["xlang","languages","backends","lccc"]
diff --git a/c/Cargo.toml b/c/Cargo.toml
index 5b68a042..411b14d7 100644
--- a/c/Cargo.toml
+++ b/c/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "frontend-c"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/codegen-clever/Cargo.toml b/codegen-clever/Cargo.toml
index d0416af8..ee7b8e8f 100644
--- a/codegen-clever/Cargo.toml
+++ b/codegen-clever/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "codegen-clever"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/codegen-w65/Cargo.toml b/codegen-w65/Cargo.toml
index 6341fabe..b085da84 100644
--- a/codegen-w65/Cargo.toml
+++ b/codegen-w65/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "codegen-w65"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/codegen-x86/Cargo.toml b/codegen-x86/Cargo.toml
index 38c836ff..07f148d8 100644
--- a/codegen-x86/Cargo.toml
+++ b/codegen-x86/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "codegen-x86"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/lc-binutils b/lc-binutils
index fc968a49..34c704eb 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit fc968a4985c0a8396e09d22e413590de78b0fa64
+Subproject commit 34c704eb9b5c0604b87ee56e61e91adca4dbec92
diff --git a/lccc-mangle/Cargo.toml b/lccc-mangle/Cargo.toml
index e21d74a1..25473342 100644
--- a/lccc-mangle/Cargo.toml
+++ b/lccc-mangle/Cargo.toml
@@ -2,7 +2,7 @@
 name = "lccc-mangle"
 version = "0.1.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/lccc/Cargo.toml b/lccc/Cargo.toml
index 62b4c89b..a9499f6f 100644
--- a/lccc/Cargo.toml
+++ b/lccc/Cargo.toml
@@ -2,7 +2,7 @@
 name = "lccc"
 version = "0.1.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/lcrust/abi-proc-macro/Cargo.toml b/lcrust/abi-proc-macro/Cargo.toml
index b2acc2fe..c5868a97 100644
--- a/lcrust/abi-proc-macro/Cargo.toml
+++ b/lcrust/abi-proc-macro/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "abi-proc-macro"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/m4/lcrust_prog_rustc.m4 b/m4/lcrust_prog_rustc.m4
index cca98645..3f8a5c4c 100644
--- a/m4/lcrust_prog_rustc.m4
+++ b/m4/lcrust_prog_rustc.m4
@@ -466,7 +466,7 @@ AC_DEFUN([LCRUST_PROG_CARGO],[
 [package]
 name = "cargotest"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/rust/interning-static-syms/Cargo.toml b/rust/interning-static-syms/Cargo.toml
index f0f08ebf..67df036f 100644
--- a/rust/interning-static-syms/Cargo.toml
+++ b/rust/interning-static-syms/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "interning-static-syms"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/rust/lcrustc/Cargo.toml b/rust/lcrustc/Cargo.toml
index 27400af4..5a13e774 100644
--- a/rust/lcrustc/Cargo.toml
+++ b/rust/lcrustc/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lcrustc"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/rust/rlib/Cargo.toml b/rust/rlib/Cargo.toml
index e74864b6..364b8079 100644
--- a/rust/rlib/Cargo.toml
+++ b/rust/rlib/Cargo.toml
@@ -2,7 +2,7 @@
 name = "rlib"
 version = "0.1.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/rust/rust_mir_macro/Cargo.toml b/rust/rust_mir_macro/Cargo.toml
index 8a746ea0..c3f8b249 100644
--- a/rust/rust_mir_macro/Cargo.toml
+++ b/rust/rust_mir_macro/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "rust_mir_macro"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/rust/src/interning.rs b/rust/src/interning.rs
index d96ed3ab..c00d75a2 100644
--- a/rust/src/interning.rs
+++ b/rust/src/interning.rs
@@ -1,6 +1,5 @@
 use core::borrow::Borrow;
 use core::convert::AsRef;
-use core::convert::TryInto;
 use core::num::NonZeroU32;
 use core::ops::Deref;
 use core::sync::atomic::{AtomicUsize, Ordering};
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index 4d436267..f7ddbcd4 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -1,4 +1,3 @@
-use core::convert::TryInto;
 use core::fmt::Write;
 
 use xlang::ir::{
diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index c0eeebd4..ba3ec832 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -1,5 +1,4 @@
 use std::cell::RefCell;
-use std::convert::TryInto;
 
 use ast::Mutability;
 use ast::Safety;
diff --git a/xir/Cargo.toml b/xir/Cargo.toml
index ecb69670..cb6d6ddf 100644
--- a/xir/Cargo.toml
+++ b/xir/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "frontend-xir"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/xlang/Cargo.toml b/xlang/Cargo.toml
index e3c05071..50fe0a44 100644
--- a/xlang/Cargo.toml
+++ b/xlang/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang"
 version = "0.1.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/xlang/xlang_abi/Cargo.toml b/xlang/xlang_abi/Cargo.toml
index 14f4d7ad..e0e4e1dd 100644
--- a/xlang/xlang_abi/Cargo.toml
+++ b/xlang/xlang_abi/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_abi"
 version = "0.2.0"
 authors = ["Connor Horman <chorman64@gmail.com>", "Ray Redondo <rdredondo@lcdev.xyz>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 description = """
 ABI safe interfaces used by xlang
diff --git a/xlang/xlang_abi_macro/Cargo.toml b/xlang/xlang_abi_macro/Cargo.toml
index 3102108f..edc95b91 100644
--- a/xlang/xlang_abi_macro/Cargo.toml
+++ b/xlang/xlang_abi_macro/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_abi_macro"
 version = "0.1.1"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/xlang/xlang_backend/Cargo.toml b/xlang/xlang_backend/Cargo.toml
index 1bd03874..64ead967 100644
--- a/xlang/xlang_backend/Cargo.toml
+++ b/xlang/xlang_backend/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "xlang_backend"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/xlang/xlang_backend/src/ty.rs b/xlang/xlang_backend/src/ty.rs
index ee7e0e6e..79f7a65a 100644
--- a/xlang/xlang_backend/src/ty.rs
+++ b/xlang/xlang_backend/src/ty.rs
@@ -1,5 +1,3 @@
-use std::convert::TryInto;
-
 use xlang::{
     ir::{
         AggregateDefinition, AggregateKind, AnnotationItem, Path, PointerAliasingRule, PointerKind,
diff --git a/xlang/xlang_frontend/Cargo.toml b/xlang/xlang_frontend/Cargo.toml
index 2f037e1b..71c14ba3 100644
--- a/xlang/xlang_frontend/Cargo.toml
+++ b/xlang/xlang_frontend/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "xlang_frontend"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/xlang/xlang_frontend/src/parse.rs b/xlang/xlang_frontend/src/parse.rs
index 9c48265e..3ba7d7a5 100644
--- a/xlang/xlang_frontend/src/parse.rs
+++ b/xlang/xlang_frontend/src/parse.rs
@@ -412,7 +412,7 @@ macro_rules! punctuation {
 #[macro_export]
 macro_rules! keywords{
     {
-        type $($pat:pat)|+ in $ident_ty:ty;
+        type $pat:pat in $ident_ty:ty;
         $($tok:tt => $name:ident),* $(,)?
     } => {
         #[derive(Clone, Copy, Hash, PartialEq, Eq)]
diff --git a/xlang/xlang_frontend/src/symbol.rs b/xlang/xlang_frontend/src/symbol.rs
index 6e69c1eb..2eec3ffd 100644
--- a/xlang/xlang_frontend/src/symbol.rs
+++ b/xlang/xlang_frontend/src/symbol.rs
@@ -1,6 +1,5 @@
 use std::{
     borrow::Borrow,
-    convert::TryInto,
     hash::Hash,
     num::NonZeroU32,
     ops::Deref,
diff --git a/xlang/xlang_host/Cargo.toml b/xlang/xlang_host/Cargo.toml
index 9bdd1c06..3aa1d33c 100644
--- a/xlang/xlang_host/Cargo.toml
+++ b/xlang/xlang_host/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_host"
 version = "0.2.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 description = """
 Interface for determining and using platform-specific properties of the host system
diff --git a/xlang/xlang_interface/Cargo.toml b/xlang/xlang_interface/Cargo.toml
index d0783d93..854a24de 100644
--- a/xlang/xlang_interface/Cargo.toml
+++ b/xlang/xlang_interface/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_interface"
 version = "0.1.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 description = """
 Minimal cdylib that exposes interfaces to be shared by the xlang environment (backend, frontend, plugins, driver)
diff --git a/xlang/xlang_opt/Cargo.toml b/xlang/xlang_opt/Cargo.toml
index e3dd1dc9..cf41f939 100644
--- a/xlang/xlang_opt/Cargo.toml
+++ b/xlang/xlang_opt/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "xlang_opt"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/xlang/xlang_struct/Cargo.toml b/xlang/xlang_struct/Cargo.toml
index 252a6599..eebf146c 100644
--- a/xlang/xlang_struct/Cargo.toml
+++ b/xlang/xlang_struct/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_struct"
 version = "0.2.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 description = """
 ABI Safe structures for representing xlang's intermediate representation
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index afd86c67..20a26c4d 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -19,7 +19,6 @@
 //! ````
 //!
 
-use std::convert::TryFrom;
 use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign};
 
 use xlang_abi::prelude::v1::*;
diff --git a/xlang/xlang_targets/Cargo.toml b/xlang/xlang_targets/Cargo.toml
index d992eafd..5c38233e 100644
--- a/xlang/xlang_targets/Cargo.toml
+++ b/xlang/xlang_targets/Cargo.toml
@@ -2,7 +2,7 @@
 name = "xlang_targets"
 version = "0.2.0"
 authors = ["Connor Horman <chorman64@gmail.com>"]
-edition = "2018"
+edition = "2021"
 license = "BSD-2-Clause-Patent"
 description = """
 ABI Safe Interfaces for target triples and discovering compiler-required information about targets
diff --git a/xlangtransparent/Cargo.toml b/xlangtransparent/Cargo.toml
index 4eaca214..14232171 100644
--- a/xlangtransparent/Cargo.toml
+++ b/xlangtransparent/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "transparent"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

From f9998aa553af3f49cd89f4ff8ca10c37a2c610fd Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sun, 2 Jun 2024 16:03:30 -0500
Subject: [PATCH 45/74] chore: update lc-binutils

---
 lc-binutils | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lc-binutils b/lc-binutils
index 34c704eb..b3bd5235 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 34c704eb9b5c0604b87ee56e61e91adca4dbec92
+Subproject commit b3bd5235475ace7c7dcbed8482d2fba27fb86443

From bb5e39c69a964e6ec76cb47ed069b60cac88d960 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 2 Jun 2024 17:29:05 -0400
Subject: [PATCH 46/74] feat(x86-codegen): Implement clobbers

---
 codegen-x86/src/callconv.rs |  16 ++++
 codegen-x86/src/lib.rs      | 149 +++++++++++++++++++++++++++++++++++-
 lc-binutils                 |   2 +-
 3 files changed, 162 insertions(+), 5 deletions(-)

diff --git a/codegen-x86/src/callconv.rs b/codegen-x86/src/callconv.rs
index 2bae052c..a1b923b8 100644
--- a/codegen-x86/src/callconv.rs
+++ b/codegen-x86/src/callconv.rs
@@ -24,6 +24,22 @@ pub enum X86Tag {
     SysV64,
 }
 
+impl X86Tag {
+    pub fn volatile_regs(&self) -> &'static [X86Register] {
+        match self {
+            X86Tag::SysV64 => &[
+                X86Register::Rax,
+                X86Register::Rcx,
+                X86Register::Rdx,
+                X86Register::Rsi,
+                X86Register::Rdi,
+                X86Register::R8,
+                X86Register::R9,
+            ],
+        }
+    }
+}
+
 impl Tag for X86Tag {
     type Register = X86Register;
     type TypeClass = X86TypeClass;
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index c4a312c1..5a0d644b 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -29,6 +29,7 @@ mod callconv;
 pub enum X86ValLocation {
     Null,
     Register(X86Register),
+    StackDisp(i32),
 }
 
 #[derive(Clone, Debug)]
@@ -48,6 +49,7 @@ pub struct X86Assignments {
     available_int_registers: Vec<X86Register>,
     return_reg: Option<X86Register>,
     stack_width: i32,
+    stack_align: u64,
     assigns: HashMap<u32, LocationAssignment>,
 }
 
@@ -56,7 +58,35 @@ pub struct X86Clobbers {
     clobbered_at: HashMap<u32, usize>,
 }
 
-impl X86Clobbers {}
+impl X86Clobbers {
+    pub fn mark_used(
+        &mut self,
+        val: u32,
+        assign: &mut LocationAssignment,
+        stack_width: &mut i32,
+        ty_size: u64,
+        ty_align: u64,
+    ) {
+        if let Some(Pair(_, pos)) = self.clobbered_at.remove(&val) {
+            let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
+            *stack_width = (*stack_width + align_minus1) & align_minus1;
+            let offset = -*stack_width;
+            *stack_width += i32::try_from(ty_size).unwrap();
+            assign
+                .change_owner
+                .push((pos, X86ValLocation::StackDisp(offset)));
+        }
+    }
+    pub fn mark_clobbered(&mut self, reg: X86Register, which: usize, for_val: Option<u32>) {
+        if let Some(Pair(_, val)) = self.reg_owners.remove(&reg) {
+            if for_val == Some(val) {
+                self.reg_owners.insert(reg, val);
+            } else {
+                self.clobbered_at.insert(val, which);
+            }
+        }
+    }
+}
 
 fn xor_opcode(class: X86RegisterClass, hint_vec_is_int: bool) -> X86CodegenOpcode {
     match class {
@@ -151,12 +181,15 @@ impl X86Machine {
         writer: &mut X86Encoder<W>,
         dest: &X86ValLocation,
         src: &X86ValLocation,
+        assigns: &X86Assignments,
     ) -> std::io::Result<()> {
         if dest == src {
             return Ok(());
         }
         match (dest, src) {
-            (X86ValLocation::Null, X86ValLocation::Null) => Ok(()),
+            (X86ValLocation::Null, X86ValLocation::Null)
+            | (X86ValLocation::Null, X86ValLocation::StackDisp(_))
+            | (X86ValLocation::StackDisp(_), X86ValLocation::Null) => Ok(()),
             (X86ValLocation::Register(dest), X86ValLocation::Register(src)) => {
                 if dest.class() != src.class() {
                     panic!("Cannot move between register classes")
@@ -175,10 +208,51 @@ impl X86Machine {
                     }
                 }
             }
+            (X86ValLocation::StackDisp(off), X86ValLocation::Register(reg)) => {
+                let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
+                let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
+
+                writer.write_insn(X86Instruction::new(
+                    opcode,
+                    vec![
+                        X86Operand::Memory(
+                            reg.class(),
+                            None,
+                            X86MemoryOperand::Indirect {
+                                reg: assigns.sp,
+                                disp: Some(arch_ops::x86::codegen::X86Displacement::Offset(*off)),
+                            },
+                        ),
+                        X86Operand::Register(*reg),
+                    ],
+                ))
+            }
+            (X86ValLocation::Register(reg), X86ValLocation::StackDisp(off)) => {
+                let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
+                let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
+
+                writer.write_insn(X86Instruction::new(
+                    opcode,
+                    vec![
+                        X86Operand::Register(*reg),
+                        X86Operand::Memory(
+                            reg.class(),
+                            None,
+                            X86MemoryOperand::Indirect {
+                                reg: assigns.sp,
+                                disp: Some(arch_ops::x86::codegen::X86Displacement::Offset(*off)),
+                            },
+                        ),
+                    ],
+                ))
+            }
             (X86ValLocation::Null, X86ValLocation::Register(_))
             | (X86ValLocation::Register(_), X86ValLocation::Null) => {
                 panic!("Cannot move a register to/from null")
             }
+            (X86ValLocation::StackDisp(_), X86ValLocation::StackDisp(_)) => {
+                todo!("memory to memory")
+            }
         }
     }
 }
@@ -222,6 +296,7 @@ impl Machine for X86Machine {
             available_int_registers: int_registers,
             return_reg: None,
             stack_width: 0,
+            stack_align: 16,
             assigns: HashMap::new(),
         }
     }
@@ -247,7 +322,7 @@ impl Machine for X86Machine {
                     X86ValLocation::Register(reg) => {
                         clobbers.reg_owners.insert(*reg, id);
                     }
-                    X86ValLocation::Null => {}
+                    X86ValLocation::Null | X86ValLocation::StackDisp(_) => {}
                 }
             }
         }
@@ -270,6 +345,19 @@ impl Machine for X86Machine {
                         match call_loc {
                             CallConvLocation::Null => {}
                             CallConvLocation::Register(reg) => {
+                                let ty_size = tys.type_size(&loc.ty).unwrap();
+                                let ty_align = tys.type_align(&loc.ty).unwrap();
+                                if let Some(assign) = assignments.assigns.get_mut(&loc.num) {
+                                    clobbers.mark_used(
+                                        loc.num,
+                                        assign,
+                                        &mut assignments.stack_width,
+                                        ty_size,
+                                        ty_align,
+                                    );
+                                }
+
+                                clobbers.mark_clobbered(*reg, num, Some(loc.num));
                                 assignments
                                     .assigns
                                     .get_or_insert_with_mut(loc.num, |_| LocationAssignment {
@@ -284,6 +372,10 @@ impl Machine for X86Machine {
                         }
                     }
 
+                    for reg in callconv.tag().volatile_regs() {
+                        clobbers.mark_clobbered(*reg, num, None);
+                    }
+
                     if let Some(ret) = &locations.ret {
                         match callconv.ret_location() {
                             CallConvLocation::Null => {
@@ -325,6 +417,15 @@ impl Machine for X86Machine {
                             assignments.assigns.get_mut(&old_loc.num),
                         ) {
                             (Some(foreign), Some(old)) => {
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
                                 old.change_owner.push((num, foreign));
                             }
                             (Some(foreign), None) => {
@@ -343,6 +444,15 @@ impl Machine for X86Machine {
                                     .last()
                                     .map_or(&old.foreign_location, |(_, x)| x)
                                     .clone();
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
 
                                 assignments.assigns.insert(
                                     new_loc.num,
@@ -362,7 +472,19 @@ impl Machine for X86Machine {
                     [retval] => {
                         let reg = assignments.return_reg;
                         if let Some(reg) = reg {
+                            let ty_size = tys.type_size(&retval.ty).unwrap();
+                            let ty_align = tys.type_align(&retval.ty).unwrap();
+                            if let Some(assign) = assignments.assigns.get_mut(&retval.num) {
+                                clobbers.mark_used(
+                                    retval.num,
+                                    assign,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
+                            }
                             let loc = X86ValLocation::Register(reg);
+
                             assignments
                                 .assigns
                                 .get_or_insert_with_mut(retval.num, |_| LocationAssignment {
@@ -387,6 +509,17 @@ impl Machine for X86Machine {
                         match call_loc {
                             CallConvLocation::Null => {}
                             CallConvLocation::Register(reg) => {
+                                let ty_size = tys.type_size(&loc.ty).unwrap();
+                                let ty_align = tys.type_align(&loc.ty).unwrap();
+                                if let Some(assign) = assignments.assigns.get_mut(&loc.num) {
+                                    clobbers.mark_used(
+                                        loc.num,
+                                        assign,
+                                        &mut assignments.stack_width,
+                                        ty_size,
+                                        ty_align,
+                                    );
+                                }
                                 assignments
                                     .assigns
                                     .get_or_insert_with_mut(loc.num, |_| LocationAssignment {
@@ -432,7 +565,12 @@ impl Machine for X86Machine {
                 if loc.owning_bb == which {
                     for (at, new_loc) in &loc.change_owner {
                         if *at == num {
-                            self.write_move(&mut encoder, new_loc, &cur_locations[addr])?;
+                            self.write_move(
+                                &mut encoder,
+                                new_loc,
+                                &cur_locations[addr],
+                                assignments,
+                            )?;
                             break;
                         }
                     }
@@ -496,6 +634,7 @@ impl Machine for X86Machine {
                                 ))?;
                             }
                             X86ValLocation::Null => {}
+                            X86ValLocation::StackDisp(_) => todo!("memory"),
                         }
                     }
                 }
@@ -519,6 +658,7 @@ impl Machine for X86Machine {
                                 ))?;
                             }
                             X86ValLocation::Null => {}
+                            X86ValLocation::StackDisp(_) => todo!("memory"),
                         }
                     }
                 }
@@ -543,6 +683,7 @@ impl Machine for X86Machine {
                                 ))?;
                             }
                             X86ValLocation::Null => {}
+                            X86ValLocation::StackDisp(_) => todo!("memory"),
                         }
                     }
                 }
diff --git a/lc-binutils b/lc-binutils
index b3bd5235..3d34de46 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit b3bd5235475ace7c7dcbed8482d2fba27fb86443
+Subproject commit 3d34de46365defa4fa1931e7d7466ae5889f4ce4

From af07600c8c2f55825fdbcb411fd3de7cfa1cf949 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 13 Jun 2024 19:04:56 -0400
Subject: [PATCH 47/74] feat(rust-mir): Support default expansion for
 intrinsics

---
 rust/rust_mir_macro/src/ast.rs   | 152 ----------------
 rust/rust_mir_macro/src/lib.rs   |   3 +-
 rust/rust_mir_macro/src/parse.rs | 287 ++++++++++++++++++++++++++++++-
 rust/src/sema/intrin.rs          | 173 +++++++++++++++++--
 rust/src/sema/intrin_defs.rs     |  40 -----
 rust/src/sema/mir/mir_macro.rs   |   6 +-
 6 files changed, 452 insertions(+), 209 deletions(-)
 delete mode 100644 rust/rust_mir_macro/src/ast.rs
 delete mode 100644 rust/src/sema/intrin_defs.rs

diff --git a/rust/rust_mir_macro/src/ast.rs b/rust/rust_mir_macro/src/ast.rs
deleted file mode 100644
index 95135fe8..00000000
--- a/rust/rust_mir_macro/src/ast.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use std::hash::Hash;
-
-use xlang_frontend::symbol::Symbol;
-
-use proc_macro::Span;
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum InferId {} // No inference vars in `mir!{}`
-
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-pub struct DefId(pub(crate) u32);
-
-impl core::fmt::Display for DefId {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_fmt(format_args!("#{}", self.0))
-    }
-}
-
-impl core::fmt::Debug for DefId {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_fmt(format_args!("#{}", self.0))
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Spanned<T> {
-    pub span: Span,
-    pub body: T,
-}
-
-impl<T: Hash> Hash for Spanned<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.body.hash(state)
-    }
-}
-
-impl<T: PartialEq> PartialEq for Spanned<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.body == other.body
-    }
-}
-
-impl<T: Eq> Eq for Spanned<T> {}
-
-#[allow(dead_code)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum BinaryOp {
-    Add,
-    Sub,
-    Mul,
-    Div,
-    Rem,
-    BitAnd,
-    BitOr,
-    BitXor,
-    BoolAnd,
-    BoolOr,
-    Less,
-    Greater,
-    Equal,
-    NotEqual,
-    LessEqual,
-    GreaterEqual,
-    Assign,
-    AddAssign,
-    SubAssign,
-    MulAssign,
-    DivAssign,
-    RemAssign,
-    BitAndAssign,
-    BitOrAssign,
-    BitXorAssign,
-    BoolAndAssign,
-    BoolOrAssign,
-    LeftShift,
-    RightShift,
-    LeftShiftAssign,
-    RightShiftAssign,
-    Range,
-    RangeInclusive,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum UnaryOp {
-    RawAddrOf(Spanned<Mutability>),
-    AddrOf(Option<Spanned<Mutability>>),
-    Deref,
-    Neg,
-    Not,
-    RangeFrom,
-    RangeTo,
-    RangeToInclusive,
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Mutability {
-    Const,
-    Mut,
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum Safety {
-    Unsafe,
-    Safe,
-}
-
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub enum ConstExpr {
-    IntConst(IntType, u128),
-}
-
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub enum StringType {
-    Default,
-    Raw(u8), // number of #s
-    Byte,
-    RawByte(u8), // see above
-}
-
-macro_rules! def_intrinsics {
-    {
-        $($(unsafe $(@$_vol:tt)?)? intrin $name:ident $(<$($gen_param:ident),* $(,)?>)?($($param:ty),* $(,)?) -> $retty:ty;)*
-    } => {
-        #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-        #[allow(non_camel_case_types)]
-        pub enum IntrinsicDef {
-            $($name),*
-        }
-
-        impl IntrinsicDef {
-            pub fn from_name(s: &str) -> Option<IntrinsicDef> {
-                match s{
-                    $(::core::stringify!($name) => Some(Self::$name),)*
-                    _ => None
-                }
-            }
-
-            pub fn name(&self) -> &'static str {
-                match self{
-                    $(Self::$name => ::core::stringify!($name)),*
-                }
-            }
-
-        }
-    }
-}
-
-include!("../../src/sema/intrin_defs.rs");
-
-include!("../../src/sema/ty_defs.rs");
-include!("../../src/sema/mir_defs.rs");
diff --git a/rust/rust_mir_macro/src/lib.rs b/rust/rust_mir_macro/src/lib.rs
index f8792590..b609124f 100644
--- a/rust/rust_mir_macro/src/lib.rs
+++ b/rust/rust_mir_macro/src/lib.rs
@@ -55,7 +55,8 @@ fn write_error(e: Error) -> TokenStream {
     let mut bang = Punct::new('!', Spacing::Alone);
     bang.set_span(e.span);
     let mut inner = TokenStream::new();
-    let st = Literal::string(&e.text);
+    let mut st = Literal::string(&e.text);
+    st.set_span(e.span);
     inner.extend([TokenTree::Literal(st)]);
 
     ts.extend([
diff --git a/rust/rust_mir_macro/src/parse.rs b/rust/rust_mir_macro/src/parse.rs
index 8a6595aa..2400bb3a 100644
--- a/rust/rust_mir_macro/src/parse.rs
+++ b/rust/rust_mir_macro/src/parse.rs
@@ -130,6 +130,21 @@ pub fn do_keyword<I: Iterator<Item = TokenTree>>(
     })
 }
 
+pub fn do_keywords<'a, I: Iterator<Item = TokenTree>, K: IntoIterator<Item = &'a str>>(
+    tree: &mut PeekMoreIterator<I>,
+    kws: K,
+) -> Result<(&'a str, Span)> {
+    let mut err = None;
+    for kw in kws {
+        match do_keyword(tree, kw) {
+            Ok(span) => return Ok((kw, span)),
+            Err(e) => err = Some(e),
+        }
+    }
+
+    Err(err.expect("Required at least one keyword in `do_keywords`"))
+}
+
 pub fn do_group<I: Iterator<Item = TokenTree>>(
     tree: &mut PeekMoreIterator<I>,
     gtype: Option<Delimiter>,
@@ -163,6 +178,8 @@ pub fn do_type<I: Iterator<Item = TokenTree>>(
             do_never,
             do_type_interpolation,
             do_type_fnptr,
+            do_type_pointer,
+            do_type_var,
         ],
         take_right,
         dollar_crate,
@@ -232,7 +249,7 @@ fn write_spanned(
 }
 
 fn write_interpolation_for_type<'a, I: IntoIterator<Item = &'a str>>(
-    ty_path: I,
+    ty_crate_path: I,
     dollar_crate: &TokenStream,
     interp: Ident,
 ) -> TokenStream {
@@ -249,7 +266,7 @@ fn write_interpolation_for_type<'a, I: IntoIterator<Item = &'a str>>(
 
     inner_stream.extend([letkw, id, colon]);
 
-    write_crate_path(&mut inner_stream, idspan, dollar_crate, ty_path);
+    write_crate_path(&mut inner_stream, idspan, dollar_crate, ty_crate_path);
 
     let eq = TokenTree::Punct(Punct::new('=', Spacing::Alone));
 
@@ -750,6 +767,88 @@ pub fn do_fnty_no_interp<I: Iterator<Item = TokenTree>>(
     })
 }
 
+pub fn do_type_pointer<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let base_span = do_punct(tree, "*")?;
+
+        let (mt, span) = match do_keywords(tree, ["mut", "const"])? {
+            ("mut", span) => {
+                let mut ts = TokenStream::new();
+                write_crate_path(
+                    &mut ts,
+                    span,
+                    dollar_crate,
+                    ["sema", "ty", "Mutability", "Mut"],
+                );
+                (ts, span)
+            }
+            ("const", span) => {
+                let mut ts = TokenStream::new();
+                write_crate_path(
+                    &mut ts,
+                    span,
+                    dollar_crate,
+                    ["sema", "ty", "Mutability", "Mut"],
+                );
+                (ts, span)
+            }
+            _ => unreachable!(),
+        };
+
+        let inner_ty = do_type(tree, dollar_crate)?;
+
+        let mut stream = TokenStream::new();
+        write_crate_path(
+            &mut stream,
+            base_span,
+            dollar_crate,
+            ["sema", "ty", "Type", "Pointer"],
+        );
+
+        let mut inner_stream = write_spanned(mt, span, false, dollar_crate);
+        inner_stream.extend([TokenTree::Punct(Punct::new(',', Spacing::Alone))]);
+        inner_stream.extend(write_spanned(inner_ty, base_span, true, dollar_crate));
+
+        stream.extend([TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            inner_stream,
+        ))]);
+        Ok(stream)
+    })
+}
+
+pub fn do_type_var<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let base_span = do_punct(tree, "%")?;
+
+        let lit = do_unsuffixed_u32_literal(tree)?;
+
+        let mut inner_stream = TokenStream::new();
+        inner_stream.extend([TokenTree::Literal(lit)]);
+
+        let mut stream = TokenStream::new();
+        write_crate_path(
+            &mut stream,
+            base_span,
+            dollar_crate,
+            ["sema", "ty", "Type", "Param"],
+        );
+
+        stream.extend([TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            inner_stream,
+        ))]);
+
+        Ok(stream)
+    })
+}
+
 pub fn do_expr<I: Iterator<Item = TokenTree>>(
     tokens: &mut PeekMoreIterator<I>,
     dollar_crate: &TokenStream,
@@ -762,6 +861,9 @@ pub fn do_expr<I: Iterator<Item = TokenTree>>(
             do_expr_const_or_constructor,
             do_expr_const_lit,
             do_expr_ssa_var,
+            do_expr_read,
+            do_expr_tuple,
+            do_expr_get_symbol,
         ],
         take_right,
         dollar_crate,
@@ -965,6 +1067,111 @@ pub fn do_ssa_var<I: Iterator<Item = TokenTree>>(
     })
 }
 
+pub fn do_expr_read<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let base_span = do_keyword(tree, "read")?;
+        let group = do_group(tree, Some(Delimiter::Parenthesis))?;
+
+        let mut inner_tree = group.stream().into_iter().peekmore();
+
+        let inner_base_span = do_punct(&mut inner_tree, "*")?;
+
+        let inner_expr = do_expr(&mut inner_tree, dollar_crate)?;
+
+        let mut ts = TokenStream::new();
+        write_crate_path(
+            &mut ts,
+            base_span,
+            dollar_crate,
+            ["sema", "mir", "MirExpr", "Read"],
+        );
+        let inner_stream = write_spanned(inner_expr, inner_base_span, true, dollar_crate);
+        ts.extend([TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            inner_stream,
+        ))]);
+        Ok(ts)
+    })
+}
+
+pub fn do_expr_tuple<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let group = do_group(tree, Some(Delimiter::Parenthesis))?;
+        let mut inner_tree = group.stream().into_iter().peekmore();
+        let base_span = group.span();
+
+        let mut inner_stream = TokenStream::new();
+
+        loop {
+            match do_eof(&mut inner_tree) {
+                Ok(()) => break,
+                Err(_) => {
+                    let expr = do_expr(&mut inner_tree, dollar_crate)?;
+                    inner_stream.extend(write_spanned(expr, base_span, false, dollar_crate));
+                }
+            }
+            match do_punct(&mut inner_tree, ",") {
+                Ok(_) => inner_stream.extend([TokenTree::Punct(Punct::new(',', Spacing::Alone))]),
+                Err(_) => {
+                    do_eof(&mut inner_tree)?;
+                    break;
+                }
+            }
+        }
+
+        let mut exprs_stream = TokenStream::new();
+        write_global_path(&mut exprs_stream, base_span, ["std", "vec"]);
+        exprs_stream.extend([TokenTree::Group(Group::new(
+            Delimiter::Bracket,
+            inner_stream,
+        ))]);
+        let mut ts = TokenStream::new();
+        write_crate_path(
+            &mut ts,
+            base_span,
+            dollar_crate,
+            ["sema", "mir", "MirExpr", "Tuple"],
+        );
+        ts.extend([TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            exprs_stream,
+        ))]);
+
+        Ok(ts)
+    })
+}
+
+pub fn do_expr_get_symbol<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let base_span = do_keyword(tree, "get_symbol")?;
+
+        let group = do_group(tree, Some(Delimiter::Parenthesis))?;
+
+        let mut inner_tree = group.stream().into_iter().peekmore();
+
+        let defid = do_defid(&mut inner_tree, dollar_crate)?;
+
+        let mut ts = TokenStream::new();
+        write_crate_path(
+            &mut ts,
+            base_span,
+            dollar_crate,
+            ["sema", "mir", "MirExpr", "GetSymbol"],
+        );
+        ts.extend([TokenTree::Group(Group::new(Delimiter::Parenthesis, defid))]);
+        Ok(ts)
+    })
+}
+
 pub fn do_terminator<I: Iterator<Item = TokenTree>>(
     tokens: &mut PeekMoreIterator<I>,
     dollar_crate: &TokenStream,
@@ -987,7 +1194,12 @@ pub fn do_statement<I: Iterator<Item = TokenTree>>(
     tokens: &mut PeekMoreIterator<I>,
     dollar_crate: &TokenStream,
 ) -> Result<TokenStream> {
-    do_alternation(tokens, [do_stmt_store_dead], take_right, dollar_crate)
+    do_alternation(
+        tokens,
+        [do_stmt_store_dead, do_stmt_write],
+        take_right,
+        dollar_crate,
+    )
 }
 
 pub fn do_stmt_store_dead<I: Iterator<Item = TokenTree>>(
@@ -1015,9 +1227,78 @@ pub fn do_stmt_store_dead<I: Iterator<Item = TokenTree>>(
     })
 }
 
+pub fn do_stmt_write<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        let base_span = do_keyword(tree, "write")?;
+
+        let group = do_group(tree, Some(Delimiter::Parenthesis))?;
+
+        let inner_span = do_punct(tree, "*")?;
+
+        let ptr_expr = do_expr(tree, dollar_crate)?;
+
+        do_punct(tree, ",")?;
+
+        let val_expr = do_expr(tree, dollar_crate)?;
+
+        let mut ts = TokenStream::new();
+        write_crate_path(
+            &mut ts,
+            base_span,
+            dollar_crate,
+            ["sema", "mir", "MirStatement", "Write"],
+        );
+
+        let mut inner_stream = write_spanned(ptr_expr, inner_span, false, dollar_crate);
+        inner_stream.extend(
+            [TokenTree::Punct(Punct::new(',', Spacing::Joint))]
+                .into_iter()
+                .chain(write_spanned(val_expr, inner_span, false, dollar_crate)),
+        );
+
+        ts.extend([TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            inner_stream,
+        ))]);
+        Ok(ts)
+    })
+}
+
 pub fn do_basic_block_id<I: Iterator<Item = TokenTree>>(
     tokens: &mut PeekMoreIterator<I>,
     dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    do_alternation(
+        tokens,
+        [do_basic_block_id_interp, do_basic_block_id_no_interp],
+        take_right,
+        dollar_crate,
+    )
+}
+
+pub fn do_basic_block_id_interp<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
+) -> Result<TokenStream> {
+    with_rewinder_accept_on_continue(tokens, |tree| {
+        do_punct(tree, "@")?;
+
+        let interp = do_interpolation(tree)?;
+
+        Ok(write_interpolation_for_type(
+            ["sema", "mir", "BasicBlockId"],
+            dollar_crate,
+            interp,
+        ))
+    })
+}
+
+pub fn do_basic_block_id_no_interp<I: Iterator<Item = TokenTree>>(
+    tokens: &mut PeekMoreIterator<I>,
+    dollar_crate: &TokenStream,
 ) -> Result<TokenStream> {
     with_rewinder_accept_on_continue(tokens, |tree| {
         let span = do_punct(tree, "@")?;
diff --git a/rust/src/sema/intrin.rs b/rust/src/sema/intrin.rs
index a914b3cf..25874304 100644
--- a/rust/src/sema/intrin.rs
+++ b/rust/src/sema/intrin.rs
@@ -6,6 +6,8 @@ use super::{DefId, DefinitionInner, Definitions};
 
 use crate::span::{Span, Spanned};
 
+use crate::lang::LangItem;
+
 macro_rules! spanned {
     (box $expr:expr) => {
         Box::new(Spanned {
@@ -96,17 +98,17 @@ macro_rules! parse_type_inner {
     ($ident:ident) => {
         super::ty::convert_builtin_type(::core::stringify!($ident)).unwrap() // TODO: also support lang item types and generics
     };
-    (&$($inner:ty)*) => {
-        {Type::Reference(None, spanned!(Mutability::Const), spanned!(box parse_type!($($inner)*)))}
+    (&$inner:ty) => {
+        {Type::Reference(None, spanned!(Mutability::Const), spanned!(box parse_type!($inner)))}
     };
-    (&mut $($inner:ty)*) => {
-        {Type::Reference(None, spanned!(Mutability::Mut), spanned!(box parse_type!($($inner)*)))}
+    (&mut $inner:ty) => {
+        {Type::Reference(None, spanned!(Mutability::Mut), spanned!(box parse_type!($inner)))}
     };
-    (*const $($inner:ty)*) => {
-        {Type::Pointer(spanned!(Mutability::Const), spanned!(box parse_type!($($inner)*)))}
+    (*const $inner:ty) => {
+        {Type::Pointer(spanned!(Mutability::Const), spanned!(box parse_type!($inner)))}
     };
-    (*mut $($inner:ty)*) => {
-        {Type::Pointer(spanned!(Mutability::Mut), spanned!(box parse_type!($($inner)*)))}
+    (*mut $inner:ty) => {
+        {Type::Pointer(spanned!(Mutability::Mut), spanned!(box parse_type!($inner)))}
     };
     (($($inner:ty),* $(,)?)) => {
         {{Type::Tuple(vec![$(spanned!(parse_type!($inner))),*])}}
@@ -162,9 +164,39 @@ macro_rules! parse_intrinsic_generics {
     }
 }
 
+macro_rules! parse_default_body {
+    (;) => {
+        None
+    };
+    ({$($tt:tt)*}) => {
+        Some($crate::sema::mir::mir_basic_block!{$($tt)*})
+    };
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum IntrinsicAttribute {
+    /// Set for intrinsics that do not explicitly diverge and do not produce any AM Results other than UB and non-determinisic operations
+    /// This allows lifting to [`InvokeIntrinsic`][crate::sema::mir::MirExpr::InvokeIntrinsic].
+    ///
+    /// Note that the intrinsic may perform (non-volatile) writes but cannot, for example, abort or panic.
+    Unobservable,
+    /// Set for intrinsics that can be inlined as an expression
+    InlineAsExpr,
+}
+
+macro_rules! parse_attribute {
+    (unobservable) => {
+        $crate::sema::intrin::IntrinsicAttribute::Unobservable
+    };
+    (inline_as_expr) => {
+        $crate::sema::intrin::IntrinsicAttribute::InlineAsExpr
+    };
+}
+
 macro_rules! def_intrinsics {
     {
-        $($(unsafe $(@$_vol:tt)?)? intrin $name:ident $(<$($gen_param:ident),* $(,)?>)?($($param:ty),* $(,)?) -> $retty:ty;)*
+        default |$this_block:ident, $next_block:ident, $unwind_block:ident|;
+        $($(#[$meta:ident])* $(unsafe $(@$_vol:tt)?)? intrin $name:ident $(<$($gen_param:ident),* $(,)?>)?($($param:ty),* $(,)?) -> $retty:ty $($([$($lang_name:ident = $lang_item:expr),*])? {$($inner_tt:tt)*})? $(; $(@$_vol2:tt)?)?)*
     } => {
         #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
         #[allow(non_camel_case_types)]
@@ -198,8 +230,129 @@ macro_rules! def_intrinsics {
                     $(Self::$name => parse_intrinsic_generics!($($($gen_param),*)?)),*
                 }
             }
+
+            #[allow(dead_code, unused_variables)]
+            pub fn default_body(&self, defs: &$crate::sema::Definitions, $this_block: $crate::sema::mir::BasicBlockId, $next_block: $crate::sema::mir::BasicBlockId, $unwind_block: $crate::sema::mir::BasicBlockId) -> Option<$crate::sema::mir::MirBasicBlock>{
+                match self{
+                    $(Self::$name => {
+                        $($($(let $lang_name = defs.get_lang_item($lang_item)?;)*)?)?
+                        parse_default_body!($({$($inner_tt)*})? $(; $(@$_vol2)?)?)
+                    }),*
+                }
+            }
+
+            #[allow(dead_code)]
+            pub fn attributes(&self) -> &'static [$crate::sema::intrin::IntrinsicAttribute]{
+                match self{
+                    $(Self::$name => &[$(parse_attribute!($meta)),*]),*
+                }
+            }
         }
     }
 }
 
-include!("intrin_defs.rs");
+def_intrinsics! {
+    default |this,next,unwind|;
+    #[unobservable]
+    unsafe intrin __builtin_unreachable() -> !{
+        @0: { []
+            unreachable
+        }
+    }
+    #[unobservable]
+    unsafe intrin __builtin_assume(bool) -> ();
+    intrin __builtin_abort() -> !;
+    #[unobservable]
+    intrin impl_id() -> &str;
+    unsafe intrin __builtin_allocate<type>(Var<0>) -> *mut u8;
+    unsafe intrin __builtin_deallocate<type>(Var<0>, *mut u8) -> ();
+    #[unobservable]
+    intrin type_id<type>() -> (*const u8, usize);
+    #[unobservable]
+    intrin type_name<type>() -> &str;
+    intrin destroy_at<type>(*mut Var<0>) -> ();
+    #[unobservable]
+    intrin discriminant<type, type>(&Var<0>) -> Var<1>;
+    #[unobservable]
+    unsafe intrin transmute<type, type>(Var<0>) -> Var<1>;
+    intrin black_box<type>(Var<0>) -> Var<1>;
+
+    unsafe intrin construct_in_place<type, type, type>(*mut Var<0>, Var<1>, Var<2>) -> ();
+
+    #[unobservable]
+    unsafe intrin __builtin_read<type>(*const Var<0>) -> Var<0>{
+        @<this>: { [_0: *const %0]
+            return read(*_0)
+        }
+    }
+    #[unobservable]
+    unsafe intrin __builtin_read_freeze<type>(*const Var<0>) -> Var<0>;
+    unsafe intrin __builtin_read_volatile<type>(*const Var<0>) -> Var<0>;
+    #[unobservable]
+    unsafe intrin __builtin_write<type>(*mut Var<0>,Var<0>) -> ();
+    unsafe intrin __builtin_write_volatile<type>(*mut Var<0>, Var<0>) -> ();
+
+    #[unobservable]
+    intrin __builtin_size_of<type>() -> usize;
+    #[unobservable]
+    intrin __builtin_align_of<type>() -> usize;
+
+    #[unobservable]
+    intrin __builtin_size_of_val<type>(*const Var<0>) -> usize;
+    #[unobservable]
+    intrin __builtin_align_of_val<type>(*const Var<0>) -> usize;
+
+    #[unobservable]
+    intrin __builtin_likely(bool) -> bool;
+    #[unobservable]
+    intrin __builtin_unlikely(bool) -> bool;
+
+    #[unobservable]
+    intrin __builtin_cmp<type, type>(Var<0>, Var<0>) -> Var<1>;
+    #[unobservable]
+    intrin __builtin_max<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_min<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_clamp<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
+
+    #[unobservable]
+    intrin __builtin_fadd_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_fsub_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_fmul_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_fdiv_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_frem_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_ffma_fast<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    intrin __builtin_fneg_fast<type>(Var<0>) -> Var<0>;
+
+    #[unobservable]
+    unsafe intrin __atomic_load<type, const>(*mut Var<0>) -> Var<0>;
+    #[unobservable]
+    unsafe intrin __atomic_store<type, const>(*mut Var<0>, Var<0>) -> ();
+    #[unobservable]
+    unsafe intrin __atomic_compare_exchange_strong<type, const, const>(*mut Var<0>, *mut Var<0>, Var<0>) -> bool;
+    #[unobservable]
+    unsafe intrin __atomic_compare_exchange_weak<type, const, const>(*mut Var<0>, *mut Var<0>, Var<0>) -> bool;
+    #[unobservable]
+    unsafe intrin __atomic_swap<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    unsafe intrin __atomic_fetch_add<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+    #[unobservable]
+    unsafe intrin __atomic_fetch_sub<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+
+    #[unobservable]
+    unsafe intrin __atomic_begin_transaction<type>(*mut Var<0>) -> bool;
+
+    #[unobservable]
+    unsafe intrin __atomic_read_in_transaction<type, const>(*mut Var<0>) -> Var<0>;
+    #[unobservable]
+    unsafe intrin __atomic_write_in_transaction<type, const>(*mut Var<0>, Var<0>) -> ();
+    #[unobservable]
+    unsafe intrin __atomic_commit_transaction<type>(*mut Var<0>) -> i32;
+}
diff --git a/rust/src/sema/intrin_defs.rs b/rust/src/sema/intrin_defs.rs
deleted file mode 100644
index 1f7a5ff8..00000000
--- a/rust/src/sema/intrin_defs.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-def_intrinsics! {
-    unsafe intrin __builtin_unreachable() -> !;
-    intrin __builtin_abort() -> !;
-    intrin impl_id() -> &str;
-    unsafe intrin __builtin_allocate<type>(Var<0>) -> *mut u8;
-    unsafe intrin __builtin_deallocate<type>(Var<0>, *mut u8) -> ();
-    intrin type_id<type>() -> (*const u8, usize);
-    intrin type_name<type>() -> &str;
-    intrin destroy_at<type>(*mut Var<0>) -> ();
-    intrin discriminant<type, type>(&Var<0>) -> Var<1>;
-    unsafe intrin transmute<type, type>(Var<0>) -> Var<1>;
-    intrin black_box<type>(Var<0>) -> Var<1>;
-
-    unsafe intrin construct_in_place<type, type, type>(*mut Var<0>, Var<1>, Var<2>) -> ();
-
-    unsafe intrin __builtin_read<type>(*const Var<0>) -> Var<0>;
-    unsafe intrin __builtin_read_freeze<type>(*const Var<0>) -> Var<0>;
-    unsafe intrin __builtin_read_volatile<type>(*const Var<0>) -> Var<0>;
-    unsafe intrin __builtin_write<type>(*mut Var<0>,Var<0>) -> ();
-    unsafe intrin __builtin_write_volatile<type>(*mut Var<0>, Var<0>) -> ();
-
-    intrin __builtin_size_of<type>() -> usize;
-    intrin __builtin_align_of<type>() -> usize;
-
-    intrin __builtin_size_of_val<type>(*const Var<0>) -> usize;
-    intrin __builtin_align_of_val<type>(*const Var<0>) -> usize;
-
-    intrin __builtin_likely(bool) -> bool;
-    intrin __builtin_unlikely(bool) -> bool;
-
-    intrin __builtin_cmp<type, type>(Var<0>, Var<0>) -> Var<1>;
-
-    intrin __builtin_fadd_fast<type>(Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_fsub_fast<type>(Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_fmul_fast<type>(Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_fdiv_fast<type>(Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_frem_fast<type>(Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_ffma_fast<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
-    intrin __builtin_fneg_fast<type>(Var<0>) -> Var<0>;
-}
diff --git a/rust/src/sema/mir/mir_macro.rs b/rust/src/sema/mir/mir_macro.rs
index 70a7817f..0ea90e91 100644
--- a/rust/src/sema/mir/mir_macro.rs
+++ b/rust/src/sema/mir/mir_macro.rs
@@ -1,8 +1,8 @@
 #[doc(hidden)]
 pub use rust_mir_macro::{
-    mir_expr_impl as __mir_expr_impl, mir_fnty_impl as __mir_fnty_impl, mir_impl as __mir_impl,
-    mir_stmt_impl as __mir_stmt_impl, mir_term_impl as __mir_term_impl,
-    mir_type_impl as __mir_type_impl,
+    mir_basic_block_impl as __mir_basic_block_impl, mir_expr_impl as __mir_expr_impl,
+    mir_fnty_impl as __mir_fnty_impl, mir_impl as __mir_impl, mir_stmt_impl as __mir_stmt_impl,
+    mir_term_impl as __mir_term_impl, mir_type_impl as __mir_type_impl,
 };
 
 #[macro_export]

From d4484ba5dcf7120f676090a5e75fe05686c88eca Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 13 Jun 2024 19:05:26 -0400
Subject: [PATCH 48/74] feat(rust-stdlib): Start atomics support and optimize
 `Ordering`

---
 lcrust/libraries/libcore/src/cmp.rs         |  34 +-
 lcrust/libraries/libcore/src/intrinsics.rs  |  81 ++-
 lcrust/libraries/libcore/src/slice.rs       |  74 +++
 lcrust/libraries/libcore/src/sync/atomic.rs | 607 ++++++++------------
 4 files changed, 411 insertions(+), 385 deletions(-)

diff --git a/lcrust/libraries/libcore/src/cmp.rs b/lcrust/libraries/libcore/src/cmp.rs
index ed91589e..4669b4d6 100644
--- a/lcrust/libraries/libcore/src/cmp.rs
+++ b/lcrust/libraries/libcore/src/cmp.rs
@@ -121,19 +121,23 @@ pub trait Ord: PartialOrd<Self> + Eq {
     }
 }
 
-#[rustc_builtin_macro]
+#[lcrust::builtin_macro_def]
+#[lcrust::decl_macro_derive]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro PartialEq($item:item) {}
 
-#[rustc_builtin_macro]
+#[lcrust::builtin_macro_def]
+#[lcrust::decl_macro_derive]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro PartialOrd($item:item) {}
 
-#[rustc_builtin_macro]
+#[lcrust::builtin_macro_def]
+#[lcrust::decl_macro_derive]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro Ord($item:item) {}
 
-#[rustc_builtin_macro]
+#[lcrust::builtin_macro_def]
+#[lcrust::decl_macro_derive]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro Eq($item:item) {}
 
@@ -158,6 +162,26 @@ macro_rules! cmp_int {
                     // `__builtin_cmp` returns `-1`, `0`, or `1` ordering to comparison b/c this is an integer type
                     unsafe{core::mem::transmute_copy(&ord)}
                 }
+
+                #[inline]
+                fn max(self, other: Self) -> Self{
+                    core::intrinsics::__builtin_max_val(self, other)
+                }
+
+                #[inline]
+                fn min(self, other: Self) -> Self{
+                    core::intrinsics::__builtin_min_val(self, other)
+                }
+
+                #[inline]
+                fn clamp(self, lower: Self, upper: Self) -> Self{
+
+                    if lower > upper{
+                        panic!("Cannot clamp between {lower} and {upper} (lower must be less than or equal to upper)")
+                    }
+
+                    core::intrinsics::__builtin_clamp_val(self, lower, upper)
+                }
             }
             impl PartialOrd for $ty{
                 #[inline(always)]
@@ -186,7 +210,7 @@ macro_rules! cmp_float {
                     let ord = core::intrinsics::__builtin_cmp::<$ty, core::mem::MaybeUninit<i32>>(*self, *other);
                     match (self.is_nan(), other.is_nan()){
                         // SAFETY:
-                        // `__builtin_cmp` returns `-1`, `0`, or `1` ordering to comparison b/c this is an integer type
+                        // `__builtin_cmp` returns `-1`, `0`, or `1` ordering to b/c the floating-point comparison is ordered (neither value is NaN)
                         (false, false) => Some(unsafe{core::mem::transmute_copy(&ord)}),
                         _ => None
                     }
diff --git a/lcrust/libraries/libcore/src/intrinsics.rs b/lcrust/libraries/libcore/src/intrinsics.rs
index 9fdd195a..4eea2d42 100644
--- a/lcrust/libraries/libcore/src/intrinsics.rs
+++ b/lcrust/libraries/libcore/src/intrinsics.rs
@@ -19,10 +19,83 @@
 
 #![unstable(feature = "core_intrinsics", issue = "none")]
 
-extern "rust-intrinsics"{
-    pub unsafe fn transmute<T,U>(x: T) -> U;
-    pub unsafe fn construct_in_place<T, F: FnOnce<Args> + FnPointer, Args: Tuple>(*mut T, F, Args);
-    pub fn __builtin_cmp<T: core::marker::Copy + core::cmp::PartialEq, U>(T, T) -> U;
+extern "rust-intrinsics" {
+    pub unsafe fn transmute<T, U>(x: T) -> U;
+    pub unsafe fn construct_in_place<T, F: FnOnce<Args> + FnPointer, Args: Tuple>(
+        dest: *mut T,
+        func: F,
+        args: Args,
+    );
+    pub fn __builtin_cmp<T: core::marker::Copy + core::cmp::PartialOrd, U>(a: T, b: T) -> U;
+
+    /// Same as [`Ord::max`][core::cmp::Ord::max] but only on primitives, and generally more efficient.
+    /// Also functions on `f32` and `f64`, see the corresponding function on those types for behaviour surrounding NaNs.
+    /// This may avoid a branch that may be present on the default function
+    pub fn __builtin_max_val<T: core::marker::Copy + core::cmp::PartialOrd>(a: T, b: T) -> T;
+    /// Same as [`Ord::min`][core::cmp::Ord::min] but only on primitives, and generally more efficient.
+    /// Also functions on `f32` and `f64`, see the corresponding function on those types for behaviour surrounding NaNs.
+    /// This may avoid a branch that may be present on the default function
+    pub fn __builtin_min_val<T: core::marker::Copy + core::cmp::PartialOrd>(a: T, b: T) -> T;
+    /// Same as [`Ord::clamp`][core::cmp::Ord::clamp] but only on primitives, and generally more efficient.
+    /// Also functions on `f32` and `f64`, see the corresponding function on those types for behaviour surrounding NaNs.
+    /// This may avoid a branch that may be present on the default function.
+    /// 
+    /// Note: This function may have unpredictable results, but does not have undefined behaviour, if `lower` > `upper`.
+    pub fn __builtin_clamp_val<T: core::marker::Copy + core::cmp::PartialOrd>(
+        val: T,
+        lower: T,
+        upper: T,
+    ) -> T;
+
+    pub unsafe fn __atomic_load<T: core::marker::Copy, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+    ) -> T;
+    pub unsafe fn __atomic_store<T: core::marker::Copy, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val: T,
+    );
+    pub unsafe fn __atomic_compare_exchange_strong<
+        T: core::marker::Copy,
+        const Ord: core::sync::atomic::Ordering,
+    >(
+        dest: *mut T,
+        expected: *mut T,
+        new: T,
+    ) -> bool;
+    pub unsafe fn __atomic_compare_exchange_weak<
+        T: core::marker::Copy,
+        const Ord: core::sync::atomic::Ordering,
+    >(
+        dest: *mut T,
+        expected: *mut T,
+        new: T,
+    ) -> bool;
+
+    pub fn __atomic_interthread_fence<const Ord: core::sync::atomic::Ordering>();
+    pub fn __atomic_intrathread_fence<const Ord: core::sync::atomic::Ordering>();
+
+    pub unsafe fn __atomic_swap<T, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val: T,
+    ) -> T;
+    pub unsafe fn __atomic_fetch_add<T, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val: T,
+    ) -> T;
+    pub unsafe fn __atomic_fetch_sub<T, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val: T,
+    ) -> T;
+
+    pub unsafe fn __atomic_read_transactional<T, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val_out: *mut T,
+    ) -> bool;
+    pub unsafe fn __atomic_write_commit<T, const Ord: core::sync::atomic::Ordering>(
+        dest: *mut T,
+        val: T,
+    ) -> i32;
+    pub unsafe fn __atomic_abort_transaction<T>(dest: *mut T);
 }
 
 #[track_caller]
diff --git a/lcrust/libraries/libcore/src/slice.rs b/lcrust/libraries/libcore/src/slice.rs
index 1f28d937..ac56e221 100644
--- a/lcrust/libraries/libcore/src/slice.rs
+++ b/lcrust/libraries/libcore/src/slice.rs
@@ -18,6 +18,11 @@
  */
 use crate::intrinsics::transmute;
 
+use crate::iter::{
+    DoubleEndedIterator, ExactSizeIterator, FusedIterator, IntoIterator, Iterator, TrustedLen,
+};
+use crate::ptr::NonNull;
+
 // lcrust implementation detail. Might open an RFC to make this part of rust
 #[doc(hidden)]
 #[unstable(feature = "lccc_slice_layout")]
@@ -179,3 +184,72 @@ impl<T> SliceIndex<[T]> for usize {
         }
     }
 }
+
+pub(crate) struct RawSliceIter<T> {
+    base: core::ptr::NonNull<T>,
+    end_or_len: *const T,
+}
+
+impl<T> core::iter::Iterator for RawSliceIter<T> {
+    type Item = core::ptr::NonNull<T>;
+
+    fn next(&mut self) -> Option<core::ptr::NonNull<T>> {
+        if const { core::mem::size_of::<T>() == 0 } {
+            if self.end_or_len.addr() == 0 {
+                None
+            } else {
+                self.end_or_len = self.end_or_len.wrapping_sub(1);
+                Some(self.base)
+            }
+        } else {
+            if self.base == self.end_or_len {
+                None
+            } else {
+                let val = self.base;
+                self.base = unsafe { val.add(1) };
+                Some(val)
+            }
+        }
+    }
+
+    fn advance_by(&mut self, n: usize) -> Result<(), core::num::NonZero<usize>> {
+        if const { core::mem::size_of::<T>() == 0 } {
+            if self.end_or_len.addr() < n {
+                Err(unsafe { NonZero::new_unchecked(n - self.end_or_len.addr()) })
+            } else {
+                self.end_or_len = self.end_or_len.wrapping_sub(n);
+                Ok(())
+            }
+        } else {
+            let cur_len = unsafe { self.end_or_len.offset_from(self.base.as_ptr()) };
+            if cur_len < n {
+                Err(unsafe { NonZero::new_unchecked(n - cur_len) })
+            } else {
+                self.base = unsafe { self.base.add(n) };
+                Ok(())
+            }
+        }
+    }
+
+    fn count(self) -> usize {
+        self.len()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len(), Some(self.len()))
+    }
+}
+
+impl<T> FusedIterator for RawSliceIter<T> {}
+
+impl<T> ExactSizeIterator for RawSliceIter<T> {
+    fn len(&self) -> usize {
+        if const { core::mem::size_of::<T>() == 0 } {
+            self.end_or_len.addr()
+        } else {
+            unsafe { self.end_or_len.offset_from(self.base.as_ptr()) }
+        }
+    }
+}
+
+unsafe impl<T> TrustedLen for RawSliceIter<T> {}
diff --git a/lcrust/libraries/libcore/src/sync/atomic.rs b/lcrust/libraries/libcore/src/sync/atomic.rs
index 5768f9c1..95a6d529 100644
--- a/lcrust/libraries/libcore/src/sync/atomic.rs
+++ b/lcrust/libraries/libcore/src/sync/atomic.rs
@@ -20,445 +20,300 @@ use crate::prelude::v1::*;
 
 use crate::cell::UnsafeCell;
 use crate::default::Default;
-use crate::intrinsics::transmute;
+use crate::intrinsics::{
+    __atomic_compare_exchange_strong, __atomic_compare_exchange_weak, __atomic_interthread_fence,
+    __atomic_intrathread_fence, __atomic_load, __atomic_store,
+};
+use crate::mem::MaybeUninit;
 use crate::{Result, Sync};
 
 #[non_exhaustive]
 #[derive(Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub enum Ordering {
-    Relaxed,
-    Release,
-    Acquire,
-    AcqRel,
-    SeqCst,
+    Relaxed = 0,
+    Release = 1,
+    Acquire = 2,
+    AcqRel = 3,
+    SeqCst = 4,
 }
 
-#[inline]
-#[__lccc::xlang_opt_hint(contains_sequence)]
+macro_rules! call_atomic_intrinsics{
+    ($dyn_ord:expr @ [$($valid_ords:ident),* $(,)?]  => $atomic_intrin:ident ($($params:expr),* $(,)?)) => {
+        (match $dyn_ord{
+            $($crate::sync::atomic::Ordering::$valid_ords => $atomic_intrin :: <$crate::sync::atomic::Ordering::$valid_ords> ($($params),*),)
+            ord => crate::panic!(crate::concat!("Invalid ordering for ", crate::stringify!($atomic_intrin), " {ord:?}."))
+        })
+    };
+
+    ($dyn_ord:expr  => $atomic_intrin:ident ($($params:expr),* $(,)?)) => {
+        call_atomic_intrinsics!($dyn_ord @ [Relaxed, Release, Acquire, AcqRel, SeqCst] => $atomic_intrin ($($params),*))
+    };
+}
+
+macro_rules! call_atomic_cmpxchg_intrinsic{
+    (($dyn_ord_success:expr, $dyn_ord_fail:expr) => $atomic_intrin:ident ($($params:expr),* $(,)?)) => {
+        (match ($dyn_ord_success, $dyn_ord_fail){
+            ($crate::sync::atomic::Ordering::Relaxed, $crate::sync::atomic::Ordering::Relaxed) => $atomic_intrin :: <$crate::sync::atomic::Ordering::Relaxed, $crate::sync::atomic::Ordering::Relaxed> ($($params),*),
+            ($crate::sync::atomic::Ordering::Release, $crate::sync::atomic::Ordering::Relaxed) => $atomic_intrin :: <$crate::sync::atomic::Ordering::Release, $crate::sync::atomic::Ordering::Relaxed> ($($params),*),
+            ($crate::sync::atomic::Ordering::Acquire, $crate::sync::atomic::Ordering::Relaxed) => $atomic_intrin :: <$crate::sync::atomic::Ordering::Acquire, $crate::sync::atomic::Ordering::Relaxed> ($($params),*),
+            ($crate::sync::atomic::Ordering::Acquire, $crate::sync::atomic::Ordering::Acquire) => $atomic_intrin :: <$crate::sync::atomic::Ordering::Acquire, $crate::sync::atomic::Ordering::Acquire> ($($params),*),
+            ($crate::sync::atomic::Ordering::AcqRel, $crate::sync::atomic::Ordering::Relaxed) => $atomic_intrin :: <$crate::sync::atomic::Ordering::AcqRel, $crate::sync::atomic::Ordering::Relaxed> ($($params),*),
+            ($crate::sync::atomic::Ordering::AcqRel, $crate::sync::atomic::Ordering::Acquire) => $atomic_intrin :: <$crate::sync::atomic::Ordering::AcqRel, $crate::sync::atomic::Ordering::Acquire> ($($params),*),
+            ($crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::Relaxed) => $atomic_intrin :: <$crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::Relaxed> ($($params),*),
+            ($crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::Acquire) => $atomic_intrin :: <$crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::Acquire> ($($params),*),
+            ($crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::SeqCst) => $atomic_intrin :: <$crate::sync::atomic::Ordering::SeqCst, $crate::sync::atomic::Ordering::SeqCst> ($($params),*),
+            (ord_success, ord_fail) => crate::panic!(crate::concat!("Invalid orderings for ", crate::stringify!($atomic_intrin), " success: {ord_success:?}, fail: {ord_fail:?}."))
+        })
+    };
+}
+
+#[inline(always)]
 pub fn compiler_fence(ord: Ordering) {
-    unsafe {
-        match ord {
-            Ordering::Release => {
-                k#__xir("sequence atomic release")
-            }
-            Ordering::Acquire => {
-                k#__xir("sequence atomic acquire")
-            }
-            Ordering::AcqRel => {
-                k#__xir("sequence atomic acqrel")
-            }
-            Ordering::SeqCst => {
-                k#__xir("sequence atomic seq_cst")
-            }
-            ord => panic!("Invalid ordering {}", ord),
-        }
-    }
+    call_atomic_intrinsics!(ord @ [Release, Acquire, AcqRel, SeqCst] => __atomic_intrathread_fence())
 }
 
-#[inline]
-#[__lccc::xlang_opt_hint(contains_fence)]
+#[inline(always)]
 pub fn fence(ord: Ordering) {
-    unsafe {
-        match ord {
-            Ordering::Release => {
-                k#__xir("fence atomic release")
-            }
-            Ordering::Acquire => {
-                k#__xir("fence atomic acquire")
-            }
-            Ordering::AcqRel => {
-                k#__xir("fence atomic acqrel")
-            }
-            Ordering::SeqCst => {
-                k#__xir("fence atomic seq_cst")
-            }
-            _ => panic!("Invalid ordering {}"),
-        }
-    }
+    call_atomic_intrinsics!(ord @ [Release, Acquire, AcqRel, SeqCst] => __atomic_interthread_fence())
 }
 
-#[cfg(target_has_atomic = "8")]
-#[repr(C, align(1))]
-pub struct AtomicBool {
-    inner: UnsafeCell<u8>,
+mod sealed {
+    pub trait Sealed {}
+
+    #[repr(align(1))]
+    #[derive(Copy, Clone)]
+    pub struct Align1;
+    #[repr(align(2))]
+    #[derive(Copy, Clone)]
+    pub struct Align2;
+    #[repr(align(4))]
+    #[derive(Copy, Clone)]
+    pub struct Align4;
+    #[repr(align(8))]
+    #[derive(Copy, Clone)]
+    pub struct Align8;
+    #[repr(align(16))]
+    #[derive(Copy, Clone)]
+    pub struct Align16;
 }
 
-#[cfg(target_has_atomic = "8")]
-impl Default for AtomicBool {
-    fn default() -> Self {
-        AtomicBool::new(false)
-    }
+#[unstable(
+    feature = "lccc_generic_atomic_type",
+    reason = "Implementation Detail of lccc's implementation of `Atomic`"
+)]
+pub unsafe trait AtomicAccessTy: Sized + Copy + sealed::Sealed {
+    type Align: Sized + Copy;
 }
 
-#[cfg(target_has_atomic = "8")]
-unsafe impl Sync for AtomicBool {}
+#[unstable(
+    feature = "lccc_generic_atomic_type",
+    reason = "Implementation Detail of lccc's implementation of `Atomic`"
+)]
+pub unsafe trait AtomicAccessTySameAlign: AtomicAccessTy {}
+
+#[unstable(
+    feature = "lccc_generic_atomic_type",
+    reason = "Implementation Detail of lccc's implementation of `Atomic`"
+)]
+#[repr(C)]
+pub struct Atomic<T: AtomicAccessTy> {
+    align: MaybeUninit<T::Align>,
+    cell: UnsafeCell<T>,
+}
 
-#[cfg(target_has_atomic = "8")]
-impl AtomicBool {
-    pub const fn new(x: bool) -> Self {
+impl<T: AtomicAccessTy> Atomic<T> {
+    pub const fn new(val: T) -> Self {
         Self {
-            inner: UnsafeCell::new(x as u8),
+            cell: UnsafeCell::new(val),
+            align: MaybeUninit::uninit(),
         }
     }
 
-    pub fn get_mut(&mut self) -> &mut bool {
-        // SAFETY:
-        // This is valid because self is uniquely borrowed for the implicit lifetime
-        unsafe { transmute(self.inner.get_mut()) }
+    #[lcrust::const_unstable(feature = "const_cell_into_inner")]
+    pub const fn into_inner(self) -> T {
+        self.cell.into_inner()
     }
 
-    #[unstable(feature = "atomic_from_mut", issue = "76314")]
-    pub fn from_mut(x: &mut bool) -> &Self {
-        unsafe { &*(x as *mut bool as *mut Self as *const Self) }
+    pub fn get_mut(&mut self) -> &mut T {
+        self.cell.get_mut()
     }
 
-    pub fn into_inner(self) -> bool {
-        // SAFETY:
-        // This is valid because self is uniquely owned here,
-        // So there is a static guarantee that no race occurs.
-        unsafe { *(self.inner.get() as *mut bool) }
+    #[unstable(feature = "atomic_from_mut")]
+    pub fn from_mut(r: &mut T) -> &mut Self
+    where
+        T: AtomicAccessTySameAlign,
+    {
+        unsafe { &mut *(r as *mut T as *mut Self) }
     }
 
-    pub fn load(&self, ord: Ordering) -> bool {
-        // SAFETY:
-        // self.inner.get() is valid because it is contained within &self, which is valid
-        // AtomicBool has a "validity" invariant equivalent to the one for bool
-        unsafe { transmute(ops::atomic_load(self.inner.get(), ord)) }
+    pub unsafe fn from_ptr<'a>(ptr: *mut T) -> &'a Self {
+        unsafe { &*ptr.cast_mut() }
     }
 
-    pub fn store(&self, val: bool, ord: Ordering) {
-        // SAFETY:
-        // self.inner.get() is valid because it is contained within &self, which is valid
-        // self.inner.get() is valid for writing because it points to a mutable subobject of *self
-        unsafe { ops::atomic_store(self.inner.get(), val as u8, ord) }
+    pub const fn as_ptr(&self) -> *mut T {
+        self.cell.get()
     }
 
-    pub fn swap(&self, mut val: bool, ord: Ordering) -> bool {
-        // SAFETY:
-        // Same as load and store
-        unsafe { ops::atomic_swap(self.inner.get(), &mut val as *mut bool as *mut u8, ord) }
-        val
+    #[inline(always)]
+    pub fn load(&self, ord: Ordering) -> T {
+        unsafe {
+            call_atomic_intrinsics!(ord @ [Relaxed, Acquire, SeqCst] => __atomic_load (self.as_ptr()))
+        }
     }
 
-    pub fn compare_and_swap(&self, mut current: bool, val: bool, ord: Ordering) -> bool {
+    #[inline(always)]
+    pub fn store(&self, val: T, ord: Ordering) {
         unsafe {
-            ops::atomic_compare_exchange(
-                self.inner.get(),
-                &mut current as *mut bool as *mut u8,
-                val,
-                ord,
-            )
+            call_atomic_intrinsics!(ord @ [Relaxed, Release, SeqCst] => __atomic_store (self.as_ptr(), val))
         }
-        current
     }
 
-    pub fn compare_exchange_weak(
-        &self,
-        mut expected: bool,
-        update: bool,
-        success_ord: Ordering,
-        failure_ord: Ordering,
-    ) -> Result<bool, bool> {
-        if match (success_ord, failure_ord) {
-            (o @ Ordering::SeqCst, Ordering::Acquire | Ordering::SeqCst) => unsafe {
-                ops::atomic_compare_exchange_weak(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            (o @ Ordering::AcqRel | Ordering::Acquire, Ordering::Acquire) => unsafe {
-                ops::atomic_compare_exchange_weak(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            (o, Ordering::Relaxed) => unsafe {
-                ops::atomic_compare_exchange_weak_fail_relaxed(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            _ => panic!("Invalid ordering pair for compare_exchange_weak"),
-        } {
-            Ok(expected)
-        } else {
-            Err(expected)
-        }
+    #[inline(always)]
+    pub fn swap(&self, val: T, ord: Ordering) -> Ordering {
+        unsafe { call_atomic_intrinsics!(ord => __atomic_swap (self.as_ptr(), val)) }
     }
 
+    #[inline(always)]
     pub fn compare_exchange(
         &self,
-        mut expected: bool,
-        update: bool,
-        success_ord: Ordering,
-        failure_ord: Ordering,
-    ) -> Result<bool, bool> {
-        if match (success_ord, failure_ord) {
-            (o @ Ordering::SeqCst, Ordering::Acquire | Ordering::SeqCst) => unsafe {
-                ops::atomic_compare_exchange(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            (o @ Ordering::AcqRel | Ordering::Acquire, Ordering::Acquire) => unsafe {
-                ops::atomic_compare_exchange(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            (o, Ordering::Relaxed) => unsafe {
-                ops::atomic_compare_exchange_fail_relaxed(
-                    self.inner.get(),
-                    &mut current as *mut bool as *mut u8,
-                    val as u8,
-                    o,
-                )
-            },
-            _ => panic!("Invalid ordering pair for compare_exchange"),
+        mut expected: T,
+        new: T,
+        success: Ordering,
+        fail: Ordering,
+    ) -> Result<T, T> {
+        match unsafe {
+            call_atomic_cmpxchg_intrinsic!((success, fail) => __atomic_compare_exchange_strong(self.as_ptr(), &mut expected, new))
         } {
-            Ok(expected)
-        } else {
-            Err(expected)
+            true => Ok(expected),
+            false => Ok(expected),
         }
     }
-}
-
-#[unstable(feature = "lccc_atomic_impl")]
-pub mod ops {
-    use crate::sync::atomic::Ordering::{self, *};
 
-    pub unsafe fn atomic_load<T>(mem: *const T, ord: Ordering) {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic load")
-        }
-        match ord {
-            Acquire | AcqRel => k#__xir(r"(
-                indirect
-                as_rvalue atomic acquire
-            )":[mem]:[yield: T]),
-            SeqCst => k#__xir(r"(
-                indirect
-                as_rvalue atomic seqcst
-            )":[mem]:[yield: T]),
-            Relaxed => k#__xir(r"
-                indirect
-                as_rvalue atomic
-            ":[mem]:[yield:T]),
-            _ => panic!("Bad ordering"),
+    #[inline(always)]
+    pub fn compare_exchange_weak(
+        &self,
+        mut expected: T,
+        new: T,
+        success: Ordering,
+        fail: Ordering,
+    ) -> Result<T, T> {
+        match unsafe {
+            call_atomic_cmpxchg_intrinsic!((success, fail) => __atomic_compare_exchange_weak(self.as_ptr(), &mut expected, new))
+        } {
+            true => Ok(expected),
+            false => Ok(expected),
         }
     }
 
-    pub unsafe fn atomic_store<T>(mem: *mut T, val: T, ord: Ordering) {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
+    #[inline(always)]
+    pub fn compare_and_swap(&self, mut expected: T, new: T, order: Ordering) -> T {
+        unsafe {
+            match order {
+                Ordering::Relaxed => __atomic_compare_exchange_strong::<
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                >(self.as_ptr(), &mut expected, new),
+                Ordering::Release => __atomic_compare_exchange_strong::<
+                    Ordering::Release,
+                    Ordering::Relaxed,
+                >(self.as_ptr(), &mut expected, new),
+                Ordering::Acquire => __atomic_compare_exchange_strong::<
+                    Ordering::Acquire,
+                    Ordering::Acquire,
+                >(self.as_ptr(), &mut expected, new),
+                Ordering::AcqRel => __atomic_compare_exchange_strong::<
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                >(self.as_ptr(), &mut expected, new),
+                Ordering::SeqCst => __atomic_compare_exchange_strong::<
+                    Ordering::SeqCst,
+                    Ordering::SeqCst,
+                >(self.as_ptr(), &mut expected, new),
+            }
         }
 
-        match ord {
-            Release | AcqRel => k#__xir(r"
-                assign atomic release
-            ":[lvalue *mem,val]),
-            Relaxed => k#__xir(r"
-                assign atomic
-            ":[lvalue *mem,val]),
-            SeqCst => k#__xir(r"
-                assign atomic seq_cst
-            ":[lvalue *mem,val]),
-            _ => panic!("Bad ordering"),
-        }
+        expected
     }
 
-    pub unsafe fn atomic_compare_exchange<T>(
-        mem: *mut T,
-        expected: *mut T,
-        value: T,
-        ord: Ordering,
-    ) -> bool {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
-        }
-
-        match ord {
-            Acquire => k#__xir(r"
-                cmp_excg atomic acquire
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Release => k#__xir(r"
-                cmp_excg atomic release
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            AcqRel => k#__xir(r"
-                cmp_excg atomic acqrel
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Relaxed => k#__xir(r"
-                cmp_excg atomic relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            SeqCst => k#__xir(r"
-                cmp_excg atomic seq_cst
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-        }
+    #[inline(always)]
+    pub fn fetch_add(&self, val: T, ord: Ordering) -> T
+    where
+        T: crate::ops::Add<T>,
+    {
+        unsafe { call_atomic_intrinsics!(ord => __atomic_fetch_add(self.as_ptr(), val)) }
     }
 
-    pub unsafe fn atomic_compare_exchange_fail_relaxed<T>(
-        mem: *mut T,
-        expected: *mut T,
-        value: *const T,
-        ord: Ordering,
-    ) -> bool {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
-        }
-
-        match ord {
-            Acquire => k#__xir(r"
-                cmp_excg atomic acquire fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,core::ptr::read(val)]:[yield:bool]),
-            Release => k#__xir(r"
-                cmp_excg atomic release fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,core::ptr::read(val)]:[yield:bool]),
-            AcqRel => k#__xir(r"
-                cmp_excg atomic acqrel fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,core::ptr::read(val)]:[yield:bool]),
-            Relaxed => k#__xir(r"
-                cmp_excg atomic relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,core::ptr::read(val)]:[yield:bool]),
-            SeqCst => k#__xir(r"
-                cmp_excg atomic seq_cst fail relaxed
-                convert strong uint(1)
-            ":[lvalue unsafe{*mem},lvalue *expected,core::ptr::read(val)]:[yield:bool]),
-        }
+    #[inline(always)]
+    pub fn fetch_sub(&self, val: T, ord: Ordering) -> T
+    where
+        T: crate::ops::Sub<T>,
+    {
+        unsafe { call_atomic_intrinsics!(ord => __atomic_fetch_sub(self.as_ptr(), val)) }
     }
 
-    pub unsafe fn atomic_compare_exchange_weak<T>(
-        mem: *mut T,
-        expected: *mut T,
-        value: T,
-        ord: Ordering,
-    ) -> bool {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
+    #[inline]
+    pub fn fetch_update<F: core::ops::FnMut(T) -> Option<T>>(
+        &self,
+        set_order: Ordering,
+        fetch_order: Ordering,
+        mut f: F,
+    ) -> Result<T, T> {
+        let mut val = MaybeUninit::uninit();
+        while unsafe {
+            call_atomic_intrinsics!(fetch_order @ [Relaxed, Acquire, SeqCst] => __atomic_read_transactional(self.as_ptr(), val.as_mut_ptr()))
+        } {
+            // SAFETY:
+            // If `__atomic_read_transactional` returns `true`, it wrote to the second argument
+            let val = unsafe { val.assume_init_read() };
+            if let Some(new_val) = f(val) {
+                match unsafe {
+                    call_atomic_intrinsics!(set_order => __atomic_write_commit(self.as_ptr(), new_val))
+                } {
+                    ..0 => break,
+                    0 => return Ok(val),
+                    1.. => continue,
+                }
+            } else {
+                unsafe {
+                    __atomic_abort_transaction(self.as_ptr());
+                }
+                return Err(val);
+            }
         }
-
-        match ord {
-            Acquire => k#__xir(r"
-                cmp_excg_weak atomic acquire
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Release => k#__xir(r"
-                cmp_excg_weak atomic release
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            AcqRel => k#__xir(r"
-                cmp_excg_weak atomic acqrel
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Relaxed => k#__xir(r"
-                cmp_excg_weak atomic relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            SeqCst => k#__xir(r"
-                cmp_excg_weak atomic seq_cst
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
+        let mut val = self.load(fetch_order);
+        loop {
+            if let Some(new_val) = f(val) {
+                match self.compare_exchange_weak(val, new_val, set_order, fetch_order) {
+                    Ok(old_val) => break Ok(old_val),
+                    Err(old_val) => val = old_val,
+                }
+            } else {
+                break Err(val);
+            }
         }
     }
 
-    pub unsafe fn atomic_compare_exchange_weak_fail_relaxed<T>(
-        mem: *mut T,
-        expected: *mut T,
-        value: T,
-        ord: Ordering,
-    ) -> bool {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
-        }
-
-        match ord {
-            Acquire => k#__xir(r"
-                cmp_excg_weak atomic acquire fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Release => k#__xir(r"
-                cmp_excg_weak atomic release fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            AcqRel => k#__xir(r"
-                cmp_excg_weak atomic acqrel fail relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Relaxed => k#__xir(r"
-                cmp_excg_weak atomic relaxed
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            SeqCst => k#__xir(r"
-                cmp_excg_weak atomic seq_cst fail relaxed
-                convert strong uint(1)
-            ":[lvalue unsafe{*mem},lvalue *expected,val]:[yield:bool]),
-        }
+    #[inline(always)]
+    pub fn fetch_max(&self, new_val: T, ord: Ordering) -> T {
+        self.fetch_update(ord, Ordering::Relaxed, |val| {
+            Some(core::intrinsics::__builtin_max_val(val, new_val))
+        })
     }
+}
 
-    pub unsafe fn atomic_swap<T>(mem1: *mut T, mem2: *mut T, ord: Ordering) {
-        if ::__lccc::atomic_not_lock_free::<T>() {
-            panic!("Cannot perform non-lock free atomic store")
-        }
-
-        match ord {
-            Acquire => k#__xir(r"
-                swap atomic acquire
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected]:[yield:bool]),
-            Release => k#__xir(r"
-                swap atomic release
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected]:[yield:bool]),
-            AcqRel => k#__xir(r"
-                swap atomic acqrel
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected,val]:[yield:bool]),
-            Relaxed => k#__xir(r"
-                swap atomic 
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected]:[yield:bool]),
-            SeqCst => k#__xir(r"
-                swap atomic seq_cst
-                convert strong uint(1)
-            ":[lvalue *mem,lvalue *expected]:[yield:bool]),
-        }
-    }
+macro_rules! def_atomic_ty{
+    {$( $(#[doc($doc:meta)])* #[$cfg_atomic:meta] #[$stability:meta] type $atomic_ty:ty = $base_ty:ty @ $align:ty;)*} => {
+        $(
+            impl sealed::Sealed for $base_ty{}
+            #[$cfg_atomic]
+            unsafe impl AtomicAccessTy for $base_ty{
+                type Align = $align;
+            }
 
-    pub unsafe fn fetch_and<T: And>(mem: *mut T, value: T, ord: Ordering) -> T {
-        match ord {
-            Relaxed => k#__xir(r"
-                compound_assign fetch and atomic relaxed 
-            ":[lvalue *mem,value]:[yield:T]),
-            Acquire => k#__xir(r"
-                compound_assign fetch and atomic release 
-            ":[lvalue *mem,value]:[yield:T]),
-            Release => k#__xir(r"
-                compound_assign fetch and atomic release 
-            ":[lvalue *mem,value]:[yield:T]),
-            AcqRel => k#__xir(r"
-                compound_assign fetch and atomic acqrel 
-            ":[lvalue *mem,value]:[yield:T]),
-            SeqCst => k#__xir(r"
-                compound_assign fetch and atomic seqcst 
-            ":[lvalue *mem,value]:[yield:T]),
-        }
+            #[$$cfg_atomic]
+            #[$stability]
+            $(#[doc($doc)])*
+            pub type $atomic_ty = Atomic<$base_ty>;
+        )
     }
 }

From 1b74ac549d4d19610c5f1b21f145f6af8110272f Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 13 Jun 2024 19:06:19 -0400
Subject: [PATCH 49/74] feat(xlang-ir): Continue specification docs

---
 xlang/xlang_struct/src/lib.rs | 94 ++++++++++++++++++++++++++++++++++-
 1 file changed, 92 insertions(+), 2 deletions(-)

diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 20a26c4d..b32a4db7 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1794,7 +1794,8 @@ pub enum Expr {
     ///
     /// 1. If `access-class` contains `volatile`, the expression performs a observable side effect (`[intro.abstract]#6`).
     /// 2. If `access-class` contains `nontemporal`, then all preceeding operations weekly-sequenced-before this expression *weekly-happens-before* this expression.
-    /// 3. If `access-class` contains an atomic access class, the expression functions the same a fence expression with that atomic access class, except that the fence does not *synchronize-with* atomic operations or fence instructions performed by another thread of execution.
+    /// 3. If `access-class` contains an atomic access class, the expression functions the same a fence expression with that atomic access class,
+    ///   except that the fence does not *synchronize-with* atomic operations or fence instructions performed by another thread of execution.
     /// 4. [_Note: This is suitable for communicating with signal or interrupt handlers executed on the current thread._]
     /// 5. [_Note: The `access-class` modifier `freeze` may appear, but is ignored by this expression. _]
     /// 6. If `access-class` does not contain either `volatile`, `nontemporal`, or an atomic access class, the expression performs no operation.
@@ -2153,9 +2154,11 @@ pub enum Expr {
     /// ## Syntax
     /// ```abnf
     /// member-name := <ident> / <int-literal> / "(" <member-name> ")"
-    /// expr /= "member" <field-name>
+    /// expr /= "member" <member-name>
     /// ```
     ///
+    /// `member-name` may not be `indirect` without parenthesis.
+    ///
     /// ## Semantics
     ///
     /// Projects to a named member of an aggregate type or product type.
@@ -2175,6 +2178,29 @@ pub enum Expr {
     /// * As the operand of a `member` or `addr_of` expression
     /// * As a value used as an incoming value for a jump target
     Member(String),
+    /// Projects a Pointer to a field of an aggregate
+    ///
+    /// ## Stack
+    /// Type Checking: `[.., *A]`=> `[.., *F]`  
+    /// Operands: `[.., a]` => `[.., f]`
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= "member" "indirect" <member-name>
+    /// ```
+    ///
+    /// ## Semantics
+    /// Given `a` is a pointer to a struct, yeilds `f`, a pointer to the named member of `a`.
+    ///
+    /// If `member-name` designates a bitfield, the program is ill-formed.
+    ///
+    /// The behaviour is undefined unless:
+    /// * `a` and `f` are the same pointer, or
+    /// * `a` is a valid pointer, and `f` is inbounds of the same complete object as `a`.
+    ///
+    /// The operation is an implicit derive operation if `a` and `f` are not the same pointer, or if `A` has any non-trivial validity attributes.
+    ///
     MemberIndirect(String),
     /// Assigns a value to an lvalue according to `class`
     ///
@@ -2217,7 +2243,37 @@ pub enum Expr {
     Indirect,
     AddrOf,
 
+    /// Establishes ordering between threads of execution.
+    ///
+    /// ## Stack
+    /// `[..]`=>`[..]`
+    ///
+    /// ## Syntax
+    ///
+    /// ```abnf
+    /// expr /= "fence" <access-class>
+    /// ```
+    ///
+    /// ## Semantics
+    ///
+    /// 1. An *acquire fence* is a fence with an access-class containing an atomic-class of `atomic acquire`, `atomic acq_rel`, or `atomic seq_cst`.
+    /// 2. A *release fence* is a fence with an access-class containing an atomic-class of `atomic release`, `atomic acq_rel`, or `atomic seq_cst`.
+    /// 3. A fence with an access class containing `volatile` performs an observable side effect.
+    /// 4. An *acquire fence* M *synchronizes-with* a *release fence* N, if there exists two atomic operations A and B, such that:
+    ///   * A is *sequenced-before* M,
+    ///   * N is *sequenced-before* B,
+    ///   * A is a load, B is a store, and A takes its value from B or any store in a hypothetical release sequence that would have been headed by B if B was a release operation
+    /// 5. An *acquire fence* M *synchronizes-with* a *release operation* N, if there exists an atomic operation A, such that:
+    ///   * A is *sequenced before* M, and
+    ///   * A is a load and takes its value from a N, or any store in the release sequence headed by N.
+    /// 6. An *acquire operation* M *synchronizes-with* a *release fence* N, if there exists an atomic operation A, such that:
+    ///   * N is *sequenced before* A, and
+    ///   * A is a store, and M takes its value from A, or any store in a hypothetical release sequence that would have been headed by B if B was a release operation.
+    /// 7. A fence with an access-class containing an atomic-class of `atomic seq_cst` participates in `S`.
+    /// 8. If a fence `F` has an access-class containing `nontemporal`, then any operation which is *weekly sequenced before* `F` *happens before* `F`.
+    /// 9. [_Note: The access-class `freeze` may be present but has no effect.]
     Fence(AccessClass),
+
     BeginStorage(u32),
     EndStorage(u32),
 
@@ -2539,6 +2595,40 @@ impl core::fmt::Display for AsmExpr {
 fake_enum::fake_enum! {
     #[repr(pub u8)]
     #[derive(Hash)]
+    /// ## Access Class [expr.class]
+    ///
+    /// ### Syntax
+    /// ```abnf
+    /// atomic-class := "relaxed" / "release" / "acquire" / "acq_rel" / "seq_cst"
+    ///
+    /// access-class-modifier := "volatile" / "nontemporal" / "freeze"
+    ///
+    /// access-class := [*<access-class-modifier>] ["atomic" <atomic-class>]
+    /// ```
+    ///
+    /// ### Memory Ordering [expr.order]
+    ///
+    /// 1. This section defines the relations *weekly sequenced before*, *sequenced before*, *happens before*, and *weekly happens before*.
+    ///  These are all partial ordering relations on the evaluations of two expressions during the execution of a program. The relations are asymmetric and transitive.
+    /// 1. An expression A is *weekly sequenced before* another expression B if A and B are evaluated on the same thread of execution,
+    /// either A and B are both not evaluated during the execution of a signal handler or A and B are both evaluated during the execution of the same signal handler,
+    ///  and A is evaluated before B in program order,
+    /// 2. An expression A is *sequenced before* another expression B if A is *weekly sequenced before* B, and either,
+    ///    * Neither A nor B is a memory operation with the `nontemporal` access class,
+    ///    * A and B are both memory operations, one has the `nontemporal` access-class, one is a store to a memory location, and the other is an access to the same memory location,
+    ///    * A is a `nontemporal` memory operation, and B is a `fence` instruction with the `nontemporal` access-class, or
+    ///    * A is *sequenced before* some expression C, and C is *sequenced before* B.
+    /// 3. _Note: Absent memory operations using the nontemporal access class, *weekly sequenced before* and *sequenced before* are the same relation._
+    /// 4. An expression A *happens before* another expression B, if:
+    ///    * A is *sequenced before* B,
+    ///    * A *synchronizes-with* B, or
+    ///    * There exists an expression C, such that A *happens before* C and C *happens before* B.
+    /// 5. An expression A *weekly happens before* another expression B, if:
+    ///    * A *happens before* B,
+    ///    * A is a memory operation with a nontemporal access class, B is a `sequence` instruction, and A is *weekly sequenced before* B,
+    ///    * There exists an expression C, such that A *weekly happens before* C, and C *weekly happens before* B.
+    /// 6.
+    ///
     pub enum struct AccessClass{
         Normal = 0,
         AtomicRelaxed = 1,

From 23689fb0c07ca83f40b51cc5046fecf17972cbf7 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 13 Jun 2024 19:37:23 -0400
Subject: [PATCH 50/74] feat(xlang-ir): Handle compare instructions separately
 in xlang

---
 rust/src/irgen/xir_visitor.rs  | 41 +++++++++++++++++++++-------------
 xlang/xlang_backend/src/ssa.rs |  1 +
 xlang/xlang_struct/src/lib.rs  | 33 +++++++++++++++++++++------
 3 files changed, 53 insertions(+), 22 deletions(-)

diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index f7ddbcd4..dbc4a936 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -657,6 +657,19 @@ const CHAR: ir::Type = ir::Type::Scalar(ir::ScalarType {
     },
 });
 
+const BOOL: ir::ScalarType = ir::ScalarType {
+    kind: ir::ScalarTypeKind::Integer {
+        signed: false,
+        min: XLangNone,
+        max: XLangNone,
+    },
+    header: ir::ScalarTypeHeader {
+        bitsize: 1,
+        vectorsize: XLangNone,
+        validity: ir::ScalarValidity::empty(),
+    },
+};
+
 impl<'a> XirTypeVisitor<'a> {
     fn new(
         defs: &'a Definitions,
@@ -2310,7 +2323,7 @@ pub struct XirBinaryExprVisitor<'a> {
     stack_height: &'a mut u32,
     var_heights: &'a mut HashMap<SsaVarId, u32>,
     var_stack: &'a mut Vec<SsaVarId>,
-    op: Option<ir::BinaryOp>,
+    op: Option<ir::Expr>,
 }
 
 impl<'a> XirBinaryExprVisitor<'a> {
@@ -2347,15 +2360,17 @@ impl<'a> XirBinaryExprVisitor<'a> {
 impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
     fn visit_op(&mut self, op: BinaryOp) {
         self.op = Some(match op {
-            BinaryOp::Add => ir::BinaryOp::Add,
-            BinaryOp::Sub => ir::BinaryOp::Sub,
-            BinaryOp::Mul => ir::BinaryOp::Mul,
-            BinaryOp::Div => ir::BinaryOp::Div,
-            BinaryOp::Rem => ir::BinaryOp::Mod,
-            BinaryOp::Less => ir::BinaryOp::CmpLt,
-            BinaryOp::Greater => ir::BinaryOp::CmpGt,
-            BinaryOp::Equal => ir::BinaryOp::CmpEq,
-            BinaryOp::BitAnd => ir::BinaryOp::BitAnd,
+            BinaryOp::Add => ir::Expr::BinaryOp(ir::BinaryOp::Add, ir::OverflowBehaviour::Wrap),
+            BinaryOp::Sub => ir::Expr::BinaryOp(ir::BinaryOp::Sub, ir::OverflowBehaviour::Wrap),
+            BinaryOp::Mul => ir::Expr::BinaryOp(ir::BinaryOp::Mul, ir::OverflowBehaviour::Wrap),
+            BinaryOp::Div => ir::Expr::BinaryOp(ir::BinaryOp::Div, ir::OverflowBehaviour::Wrap),
+            BinaryOp::Rem => ir::Expr::BinaryOp(ir::BinaryOp::Mod, ir::OverflowBehaviour::Wrap),
+            BinaryOp::Less => ir::Expr::CompareOp(ir::CompareOp::CmpLt, BOOL),
+            BinaryOp::Greater => ir::Expr::CompareOp(ir::CompareOp::CmpGt, BOOL),
+            BinaryOp::Equal => ir::Expr::CompareOp(ir::CompareOp::CmpEq, BOOL),
+            BinaryOp::BitAnd => {
+                ir::Expr::BinaryOp(ir::BinaryOp::BitAnd, ir::OverflowBehaviour::Wrap)
+            }
             x => todo!("{:?}", x),
         });
     }
@@ -2396,11 +2411,7 @@ impl<'a> BinaryExprVisitor for XirBinaryExprVisitor<'a> {
 impl<'a> Drop for XirBinaryExprVisitor<'a> {
     fn drop(&mut self) {
         *self.stack_height -= 2;
-        self.exprs.push(ir::Expr::BinaryOp(
-            self.op
-                .expect("BinaryExprVisitor::visit_op was never called"),
-            ir::OverflowBehaviour::Wrap,
-        ));
+        self.exprs.push(self.op.take().unwrap());
     }
 }
 
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 9e562c3f..39914c8e 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -767,6 +767,7 @@ impl<M: Machine> BasicBlockBuilder<M> {
             ir::Expr::BeginStorage(_) => todo!("begin storage"),
             ir::Expr::EndStorage(_) => todo!("end storage"),
             ir::Expr::Select(_) => todo!("select"),
+            ir::Expr::CompareOp(_, _) => todo!("compare op"),
         }
     }
 
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index b32a4db7..da48ee2b 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1562,6 +1562,20 @@ impl core::fmt::Display for Value {
     }
 }
 
+fake_enum::fake_enum! {
+    #[repr(u16)]
+    #[derive(Hash)]
+    pub enum struct CompareOp {
+        Cmp = 0,
+        CmpLt = 1,
+        CmpGt = 2,
+        CmpEq = 3,
+        CmpNe = 4,
+        CmpGe = 5,
+        CmpLe = 6,
+    }
+}
+
 fake_enum::fake_enum! {
     #[repr(u16)]
     #[derive(Hash)]
@@ -1577,13 +1591,7 @@ fake_enum::fake_enum! {
         Rsh = 8,
         Lsh = 9,
 
-        CmpLt = 11,
-        CmpGt = 12,
-        CmpEq = 13,
-        CmpNe = 14,
-        CmpGe = 15,
-        CmpLe = 16,
-        Cmp = 17,
+
     }
 }
 
@@ -1599,6 +1607,14 @@ impl core::fmt::Display for BinaryOp {
             Self::BitOr => f.write_str("bit_or"),
             Self::BitXor => f.write_str("bit_xor"),
             Self::Rsh => f.write_str("rsh"),
+            val => todo!("Invalid Operand {:?}", val),
+        }
+    }
+}
+
+impl core::fmt::Display for CompareOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
             Self::CmpLt => f.write_str("cmp_lt"),
             Self::CmpGt => f.write_str("cmp_gt"),
             Self::CmpLe => f.write_str("cmp_le"),
@@ -2048,6 +2064,8 @@ pub enum Expr {
     /// The overflow-behaviour is ignored (overflow-behaviour cannot be `checked`)
     ///
     UnaryOp(UnaryOp, OverflowBehaviour),
+    ///
+    CompareOp(CompareOp, ScalarType),
     Convert(ConversionStrength, Type),
     Derive(PointerType, Box<Self>),
     /// Obtains an lvalue that designates the specified local variable
@@ -2299,6 +2317,7 @@ impl core::fmt::Display for Expr {
                 f.write_str("const ")?;
                 val.fmt(f)
             }
+            Self::CompareOp(op, sty) => f.write_fmt(format_args!("{} {}", op, sty)),
             Self::BinaryOp(op, v) => f.write_fmt(format_args!("{} {}", op, v)),
             Self::UnaryOp(op, v) => f.write_fmt(format_args!("{} {}", op, v)),
             Self::Convert(strength, ty) => f.write_fmt(format_args!("convert {} {}", strength, ty)),

From 56bc7078ff3d08ddcf0ee964740deccaeeb617a0 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 13 Jun 2024 19:37:37 -0400
Subject: [PATCH 51/74] chore: update autobuild submodule

---
 autobuild | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autobuild b/autobuild
index 03185c52..101bb639 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit 03185c52a7562065eed8e41bdd911c7f6940b169
+Subproject commit 101bb6393a27fdfe02854b5a8a0832faf25157cd

From f6192917fc2ac388acf4aee5ada018510e7d950f Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 27 Jun 2024 23:32:50 -0400
Subject: [PATCH 52/74] feat(rust-irgen): Start supporting intrinsics

---
 rust/src/irgen/visitor.rs     | 33 +++++++------
 rust/src/irgen/xir_visitor.rs | 67 +++++++++++++-------------
 rust/src/sema/intrin.rs       | 88 ++++++++++++++++++-----------------
 3 files changed, 95 insertions(+), 93 deletions(-)

diff --git a/rust/src/irgen/visitor.rs b/rust/src/irgen/visitor.rs
index 219810e1..ac11bd08 100644
--- a/rust/src/irgen/visitor.rs
+++ b/rust/src/irgen/visitor.rs
@@ -9,7 +9,7 @@ use crate::{
         cx, generics,
         hir::BinaryOp,
         intrin::IntrinsicDef,
-        mir::{self, SsaVarId, UnaryOp},
+        mir::{self, BasicBlockId, SsaVarId, UnaryOp},
         ty, Attr, Constructor, DefId, DefinitionInner, Definitions, FunctionBody, UserTypeKind,
     },
 };
@@ -346,19 +346,24 @@ pub fn visit_call<V: CallVisitor>(mut visitor: V, info: &mir::MirCallInfo, defs:
     if visitor.is_none() {
         return;
     }
-    visitor.visit_retplace(info.retplace.body);
-    visit_fnty(visitor.visit_fnty(), &info.fnty, defs);
+
     if let mir::MirExpr::Intrinsic(intrin, generics) = &info.targ.body {
-        visitor.visit_intrinsic(*intrin, generics)
+        visitor.visit_intrinsic(*intrin, generics);
     } else {
         visit_expr(visitor.visit_target(), &info.targ, defs);
     }
 
+    visitor.visit_retplace(info.retplace.body);
+    visit_fnty(visitor.visit_fnty(), &info.fnty, defs);
+
     for expr in &info.params {
         visit_expr(visitor.visit_param(), expr, defs);
     }
 
     visit_jump(visitor.visit_next(), &info.next);
+    if let Some(uw) = &info.unwind {
+        visit_jump(visitor.visit_unwind(), &uw);
+    }
 }
 
 #[allow(unused_variables, unused_mut)]
@@ -373,7 +378,7 @@ pub fn visit_tailcall<V: CallVisitor>(
     visit_fnty(visitor.visit_fnty(), &info.fnty, defs);
 
     if let mir::MirExpr::Intrinsic(intrin, generics) = &info.targ.body {
-        visitor.visit_intrinsic(*intrin, generics)
+        visitor.visit_intrinsic(*intrin, generics);
     } else {
         visit_expr(visitor.visit_target(), &info.targ, defs);
     }
@@ -382,7 +387,10 @@ pub fn visit_tailcall<V: CallVisitor>(
         visit_expr(visitor.visit_param(), expr, defs);
     }
 
-    visitor.visit_tailcall()
+    visitor.visit_tailcall();
+    if let Some(uw) = &info.unwind {
+        visit_jump(visitor.visit_unwind(), &uw);
+    }
 }
 
 pub fn visit_branch<V: BranchVisitor>(
@@ -819,18 +827,9 @@ def_visitors! {
         fn visit_fnty(&mut self) -> Option<Box<dyn FunctionTyVisitor + '_>>;
         fn visit_param(&mut self) -> Option<Box<dyn ExprVisitor + '_>>;
         fn visit_next(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
-        fn visit_intrinsic(&mut self, intrin: IntrinsicDef, generics: &generics::GenericArgs);
+        fn visit_intrinsic(&mut self, intrin: IntrinsicDef, generics: &generics::GenericArgs) -> Option<Box<dyn BasicBlockVisitor + '_>>;
         fn visit_tailcall(&mut self);
-
-        // TODO: visit unwind
-    }
-
-    pub trait TailcallVisitor {
-        fn visit_target(&mut self) -> Option<Box<dyn ExprVisitor + '_>>;
-        fn visit_fnty(&mut self) -> Option<Box<dyn FunctionTyVisitor + '_>>;
-        fn visit_param(&mut self) -> Option<Box<dyn ExprVisitor + '_>>;
-        fn visit_intrinsic(&mut self, intrin: IntrinsicDef);
-        // TODO: visit unwind
+        fn visit_unwind(&mut self) -> Option<Box<dyn JumpVisitor + '_>>;
     }
 
     pub trait BranchVisitor {
diff --git a/rust/src/irgen/xir_visitor.rs b/rust/src/irgen/xir_visitor.rs
index dbc4a936..fa933eee 100644
--- a/rust/src/irgen/xir_visitor.rs
+++ b/rust/src/irgen/xir_visitor.rs
@@ -34,8 +34,8 @@ use super::visitor::{
     ConstructorVisitor, ExprVisitor, FieldAccessVisitor, FieldInitVisitor, FieldVisitor,
     FunctionBodyVisitor, FunctionDefVisitor, FunctionTyVisitor, IntTyVisitor, JumpVisitor,
     LetStatementVisitor, ModVisitor, PointerTyVisitor, ReferenceTyVisitor, StatementVisitor,
-    TailcallVisitor, TerminatorVisitor, TupleExprVisitor, TupleTyVisitor, TypeDefVisitor,
-    TypeVisitor, UnaryExprVisitor, ValueDefVisitor,
+    TerminatorVisitor, TupleExprVisitor, TupleTyVisitor, TypeDefVisitor, TypeVisitor,
+    UnaryExprVisitor, ValueDefVisitor,
 };
 use super::NameMap;
 
@@ -1572,29 +1572,38 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
     }
 
     fn visit_next(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
-        Some(Box::new(XirJumpVisitor::new(
-            self.defs,
-            self.names,
-            self.properties,
-            self.deftys,
-            self.cur_fnty,
-            &mut self.block.expr,
-            self.targ.insert(ir::JumpTarget {
-                flags: ir::JumpTargetFlags::empty(),
-                target: !0,
-            }),
-            self.locals,
-            self.ssa_tys,
-            self.stack_height,
-            self.var_heights,
-            self.var_stack,
-            self.param_count + 1,
-            false,
-        )))
+        self.block.term = ir::Terminator::Call(
+            ir::CallFlags::empty(),
+            XLangBox::new(core::mem::take(&mut self.fnty)),
+            ir::JumpTarget::default(),
+        );
+        match &mut self.block.term {
+            ir::Terminator::Call(_, _, targ) => Some(Box::new(XirJumpVisitor::new(
+                self.defs,
+                self.names,
+                self.properties,
+                self.deftys,
+                self.cur_fnty,
+                &mut self.block.expr,
+                targ,
+                self.locals,
+                self.ssa_tys,
+                self.stack_height,
+                self.var_heights,
+                self.var_stack,
+                self.param_count + 1,
+                false,
+            ))),
+            _ => unreachable!(),
+        }
     }
 
-    fn visit_intrinsic(&mut self, intrin: IntrinsicDef, generics: &generics::GenericArgs) {
-        todo!("{}{}", intrin.name(), generics)
+    fn visit_intrinsic(
+        &mut self,
+        intrin: IntrinsicDef,
+        generics: &generics::GenericArgs,
+    ) -> Option<Box<dyn BasicBlockVisitor + 'a>> {
+        todo!("{} {}", intrin.name(), generics)
     }
 
     fn visit_tailcall(&mut self) {
@@ -1603,17 +1612,9 @@ impl<'a> CallVisitor for XirCallVisitor<'a> {
             XLangBox::new(core::mem::take(&mut self.fnty)),
         );
     }
-}
 
-impl<'a> Drop for XirCallVisitor<'a> {
-    fn drop(&mut self) {
-        if let Some(targ) = self.targ.take() {
-            self.block.term = ir::Terminator::Call(
-                ir::CallFlags::empty(),
-                XLangBox::new(core::mem::take(&mut self.fnty)),
-                targ,
-            );
-        }
+    fn visit_unwind(&mut self) -> Option<Box<dyn JumpVisitor + '_>> {
+        None
     }
 }
 
diff --git a/rust/src/sema/intrin.rs b/rust/src/sema/intrin.rs
index 25874304..6caa0384 100644
--- a/rust/src/sema/intrin.rs
+++ b/rust/src/sema/intrin.rs
@@ -196,7 +196,7 @@ macro_rules! parse_attribute {
 macro_rules! def_intrinsics {
     {
         default |$this_block:ident, $next_block:ident, $unwind_block:ident|;
-        $($(#[$meta:ident])* $(unsafe $(@$_vol:tt)?)? intrin $name:ident $(<$($gen_param:ident),* $(,)?>)?($($param:ty),* $(,)?) -> $retty:ty $($([$($lang_name:ident = $lang_item:expr),*])? {$($inner_tt:tt)*})? $(; $(@$_vol2:tt)?)?)*
+        $($(#[$meta:ident])* $(unsafe $(@$_vol:tt)?)? intrin $name:ident $(<$($gen_param:ident),* $(,)?>)?($($param_name:ident: $param:ty),* $(,)?) -> $retty:ty $($([$($lang_name:ident = $lang_item:expr),*])? {$($inner_tt:tt)*})? $(; $(@$_vol2:tt)?)?)*
     } => {
         #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
         #[allow(non_camel_case_types)]
@@ -232,11 +232,15 @@ macro_rules! def_intrinsics {
             }
 
             #[allow(dead_code, unused_variables)]
-            pub fn default_body(&self, defs: &$crate::sema::Definitions, $this_block: $crate::sema::mir::BasicBlockId, $next_block: $crate::sema::mir::BasicBlockId, $unwind_block: $crate::sema::mir::BasicBlockId) -> Option<$crate::sema::mir::MirBasicBlock>{
+            pub fn default_body(&self, defs: &$crate::sema::Definitions, $this_block: $crate::sema::mir::BasicBlockId, $next_block: $crate::sema::mir::BasicBlockId, $unwind_block: $crate::sema::mir::BasicBlockId, param_vars: &[$crate::sema::mir::SsaVarId]) -> Option<$crate::sema::mir::MirBasicBlock>{
                 match self{
                     $(Self::$name => {
                         $($($(let $lang_name = defs.get_lang_item($lang_item)?;)*)?)?
-                        parse_default_body!($({$($inner_tt)*})? $(; $(@$_vol2)?)?)
+                        match param_vars{
+                            [$($param_name),*] => parse_default_body!($({$($inner_tt)*})? $(; $(@$_vol2)?)?),
+                            params => panic!("Bad call to intrinsic {}. ", ::core::stringify!($name))
+                        }
+
                     }),*
                 }
             }
@@ -260,37 +264,37 @@ def_intrinsics! {
         }
     }
     #[unobservable]
-    unsafe intrin __builtin_assume(bool) -> ();
+    unsafe intrin __builtin_assume(val: bool) -> ();
     intrin __builtin_abort() -> !;
     #[unobservable]
     intrin impl_id() -> &str;
-    unsafe intrin __builtin_allocate<type>(Var<0>) -> *mut u8;
-    unsafe intrin __builtin_deallocate<type>(Var<0>, *mut u8) -> ();
+    unsafe intrin __builtin_allocate<type>(layout: Var<0>) -> *mut u8;
+    unsafe intrin __builtin_deallocate<type>(layout: Var<0>, ptr: *mut u8) -> ();
     #[unobservable]
     intrin type_id<type>() -> (*const u8, usize);
     #[unobservable]
     intrin type_name<type>() -> &str;
-    intrin destroy_at<type>(*mut Var<0>) -> ();
+    intrin destroy_at<type>(ptr: *mut Var<0>) -> ();
     #[unobservable]
-    intrin discriminant<type, type>(&Var<0>) -> Var<1>;
+    intrin discriminant<type, type>(val: &Var<0>) -> Var<1>;
     #[unobservable]
-    unsafe intrin transmute<type, type>(Var<0>) -> Var<1>;
-    intrin black_box<type>(Var<0>) -> Var<1>;
+    unsafe intrin transmute<type, type>(val: Var<0>) -> Var<1>;
+    intrin black_box<type>(val: Var<0>) -> Var<1>;
 
-    unsafe intrin construct_in_place<type, type, type>(*mut Var<0>, Var<1>, Var<2>) -> ();
+    unsafe intrin construct_in_place<type, type, type>(dest: *mut Var<0>, f: Var<1>, params: Var<2>) -> ();
 
     #[unobservable]
-    unsafe intrin __builtin_read<type>(*const Var<0>) -> Var<0>{
+    unsafe intrin __builtin_read<type>(ptr: *const Var<0>) -> Var<0>{
         @<this>: { [_0: *const %0]
             return read(*_0)
         }
     }
     #[unobservable]
-    unsafe intrin __builtin_read_freeze<type>(*const Var<0>) -> Var<0>;
-    unsafe intrin __builtin_read_volatile<type>(*const Var<0>) -> Var<0>;
+    unsafe intrin __builtin_read_freeze<type>(ptr: *const Var<0>) -> Var<0>;
+    unsafe intrin __builtin_read_volatile<type>(ptr: *const Var<0>) -> Var<0>;
     #[unobservable]
-    unsafe intrin __builtin_write<type>(*mut Var<0>,Var<0>) -> ();
-    unsafe intrin __builtin_write_volatile<type>(*mut Var<0>, Var<0>) -> ();
+    unsafe intrin __builtin_write<type>(ptr: *mut Var<0>,val: Var<0>) -> ();
+    unsafe intrin __builtin_write_volatile<type>(ptr: *mut Var<0>, val: Var<0>) -> ();
 
     #[unobservable]
     intrin __builtin_size_of<type>() -> usize;
@@ -298,61 +302,59 @@ def_intrinsics! {
     intrin __builtin_align_of<type>() -> usize;
 
     #[unobservable]
-    intrin __builtin_size_of_val<type>(*const Var<0>) -> usize;
+    intrin __builtin_size_of_val<type>(val: *const Var<0>) -> usize;
     #[unobservable]
-    intrin __builtin_align_of_val<type>(*const Var<0>) -> usize;
+    intrin __builtin_align_of_val<type>(val: *const Var<0>) -> usize;
 
     #[unobservable]
-    intrin __builtin_likely(bool) -> bool;
+    intrin __builtin_likely(val: bool) -> bool;
     #[unobservable]
-    intrin __builtin_unlikely(bool) -> bool;
+    intrin __builtin_unlikely(val: bool) -> bool;
 
     #[unobservable]
-    intrin __builtin_cmp<type, type>(Var<0>, Var<0>) -> Var<1>;
+    intrin __builtin_cmp<type, type>(a: Var<0>, b: Var<0>) -> Var<1>;
     #[unobservable]
-    intrin __builtin_max<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_max<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_min<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_min<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_clamp<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_clamp<type>(val: Var<0>, min: Var<0>, max: Var<0>) -> Var<0>;
 
     #[unobservable]
-    intrin __builtin_fadd_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fadd_fast<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_fsub_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fsub_fast<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_fmul_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fmul_fast<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_fdiv_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_fdiv_fast<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_frem_fast<type>(Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_frem_fast<type>(a: Var<0>, b: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_ffma_fast<type>(Var<0>, Var<0>, Var<0>) -> Var<0>;
+    intrin __builtin_ffma_fast<type>(a: Var<0>, b: Var<0>, c: Var<0>) -> Var<0>;
     #[unobservable]
-    intrin __builtin_fneg_fast<type>(Var<0>) -> Var<0>;
+    intrin __builtin_fneg_fast<type>(a: Var<0>) -> Var<0>;
 
     #[unobservable]
-    unsafe intrin __atomic_load<type, const>(*mut Var<0>) -> Var<0>;
+    unsafe intrin __atomic_load<type, const>(ptr: *mut Var<0>) -> Var<0>;
     #[unobservable]
-    unsafe intrin __atomic_store<type, const>(*mut Var<0>, Var<0>) -> ();
+    unsafe intrin __atomic_store<type, const>(dest: *mut Var<0>, val: Var<0>) -> ();
     #[unobservable]
-    unsafe intrin __atomic_compare_exchange_strong<type, const, const>(*mut Var<0>, *mut Var<0>, Var<0>) -> bool;
+    unsafe intrin __atomic_compare_exchange_strong<type, const, const>(dest: *mut Var<0>, expected: *mut Var<0>, new: Var<0>) -> bool;
     #[unobservable]
-    unsafe intrin __atomic_compare_exchange_weak<type, const, const>(*mut Var<0>, *mut Var<0>, Var<0>) -> bool;
+    unsafe intrin __atomic_compare_exchange_weak<type, const, const>(dest: *mut Var<0>, expected: *mut Var<0>, new: Var<0>) -> bool;
     #[unobservable]
-    unsafe intrin __atomic_swap<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+    unsafe intrin __atomic_swap<type, const>(dest: *mut Var<0>, new: Var<0>) -> Var<0>;
     #[unobservable]
-    unsafe intrin __atomic_fetch_add<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+    unsafe intrin __atomic_fetch_add<type, const>(dest: *mut Var<0>, val: Var<0>) -> Var<0>;
     #[unobservable]
-    unsafe intrin __atomic_fetch_sub<type, const>(*mut Var<0>, Var<0>) -> Var<0>;
+    unsafe intrin __atomic_fetch_sub<type, const>(dest: *mut Var<0>, val: Var<0>) -> Var<0>;
 
-    #[unobservable]
-    unsafe intrin __atomic_begin_transaction<type>(*mut Var<0>) -> bool;
 
     #[unobservable]
-    unsafe intrin __atomic_read_in_transaction<type, const>(*mut Var<0>) -> Var<0>;
+    unsafe intrin __atomic_read_in_transaction<type, const>(ptr: *mut Var<0>) -> Var<0>;
     #[unobservable]
-    unsafe intrin __atomic_write_in_transaction<type, const>(*mut Var<0>, Var<0>) -> ();
+    unsafe intrin __atomic_write_in_transaction<type, const>(ptr: *mut Var<0>, val: Var<0>) -> ();
     #[unobservable]
-    unsafe intrin __atomic_commit_transaction<type>(*mut Var<0>) -> i32;
+    unsafe intrin __atomic_commit_transaction<type>(ptr: *mut Var<0>) -> i32;
 }

From 26e0fc4d6f5af3f4aba68a997c0c02ffa25f0c22 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 27 Jun 2024 23:34:12 -0400
Subject: [PATCH 53/74] chore: update autobuild

---
 Cargo.lock | 188 +++++++++++++++++++++++++++++++++++++++++++++++------
 autobuild  |   2 +-
 2 files changed, 169 insertions(+), 21 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f2ececf1..1ed4c5e8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,15 +19,15 @@ version = "0.1.0"
 dependencies = [
  "bytemuck",
  "cfg-match",
+ "dirs",
  "hashbrown",
- "install-dirs 0.3.2",
  "lccc-siphash",
  "libc",
  "serde",
  "serde_derive",
  "target-tuples",
  "toml 0.8.10",
- "windows-sys",
+ "windows-sys 0.52.0",
  "with_builtin_macros",
 ]
 
@@ -79,6 +79,12 @@ dependencies = [
  "syn 2.0.27",
 ]
 
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
 [[package]]
 name = "cfg-match"
 version = "0.2.1"
@@ -147,6 +153,27 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "either"
 version = "1.9.0"
@@ -196,6 +223,17 @@ dependencies = [
  "xlang_struct",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.14.3"
@@ -221,15 +259,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "install-dirs"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6d3e0b81731f08fde18b7bcee99e8cbf607ce0206cc74ea88b9cbbdc3a78172"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "interning-static-syms"
 version = "0.1.0"
@@ -244,7 +273,7 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 name = "lccc"
 version = "0.1.0"
 dependencies = [
- "install-dirs 0.2.1",
+ "install-dirs",
  "serde",
  "serde_derive",
  "target-tuples",
@@ -276,6 +305,16 @@ version = "0.2.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
 
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.1"
@@ -288,6 +327,12 @@ version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
 [[package]]
 name = "paste"
 version = "1.0.14"
@@ -318,6 +363,17 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "redox_users"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+dependencies = [
+ "getrandom",
+ "libredox",
+ "thiserror",
+]
+
 [[package]]
 name = "rlib"
 version = "0.1.0"
@@ -403,6 +459,26 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4479870ee948e4c5c3fc4774b46aa73eedf97d84503a9b90922c1bb19a73a8d"
 
+[[package]]
+name = "thiserror"
+version = "1.0.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e3de26b0965292219b4287ff031fcba86837900fe9cd2b34ea8ad893c0953d2"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "268026685b2be38d7103e9e507c938a1fcb3d7e6eb15e87870b617bf37b6d581"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.27",
+]
+
 [[package]]
 name = "toml"
 version = "0.5.11"
@@ -465,6 +541,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
 [[package]]
 name = "which"
 version = "4.4.0"
@@ -476,13 +558,37 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.4",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
 ]
 
 [[package]]
@@ -491,51 +597,93 @@ version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.4",
+ "windows_aarch64_msvc 0.52.4",
+ "windows_i686_gnu 0.52.4",
+ "windows_i686_msvc 0.52.4",
+ "windows_x86_64_gnu 0.52.4",
+ "windows_x86_64_gnullvm 0.52.4",
+ "windows_x86_64_msvc 0.52.4",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.4"
diff --git a/autobuild b/autobuild
index 101bb639..d6e2cca8 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit 101bb6393a27fdfe02854b5a8a0832faf25157cd
+Subproject commit d6e2cca8ffc881ead60f7ed2dd5c8243a7fc0073

From 9505e8ab5e97514afa92359c4d43c7551599ccac Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 27 Jun 2024 23:34:50 -0400
Subject: [PATCH 54/74] feat(xlang-backend): Refactor xlang_backend to support
 mce

---
 xlang/xlang_backend/src/lib.rs      |  36 ++++----
 xlang/xlang_backend/src/mach.rs     |  29 +++---
 xlang/xlang_backend/src/mach/mce.rs | 131 ++++++++++++++++++++++++++++
 xlang/xlang_backend/src/ssa.rs      |  68 +++++++--------
 xlang/xlang_struct/src/lib.rs       |   3 +-
 5 files changed, 201 insertions(+), 66 deletions(-)
 create mode 100644 xlang/xlang_backend/src/mach/mce.rs

diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index 435cb3a7..070ca0cd 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -8,7 +8,7 @@ use std::{io::Write, rc::Rc};
 
 use arch_ops::traits::InsnWrite;
 use mach::Machine;
-use ssa::FunctionBuilder;
+use ssa::{FunctionBuilder, SsaInstruction};
 use str::StringMap;
 use ty::TypeInformation;
 use xlang::{
@@ -103,7 +103,7 @@ impl<M> SsaCodegenPlugin<M> {
     }
 }
 
-impl<M: Machine> XLangPlugin for SsaCodegenPlugin<M> {
+impl<M: Machine<SsaInstruction>> XLangPlugin for SsaCodegenPlugin<M> {
     fn accept_ir(
         &mut self,
         ir: &mut ir::File,
@@ -205,7 +205,7 @@ impl<M: Machine> XLangPlugin for SsaCodegenPlugin<M> {
     }
 }
 
-impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
+impl<M: Machine<SsaInstruction>> XLangCodegen for SsaCodegenPlugin<M> {
     fn target_matches(&self, x: xlang::abi::string::StringView) -> bool {
         self.mach.matches_target(x)
     }
@@ -216,8 +216,9 @@ impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
         mode: xlang::plugin::OutputMode,
     ) -> xlang::abi::io::Result<()> {
         let targ = self.targ.expect("set_target must have been called first");
+        let mut writer = WriteAdapter::new(x);
+
         if mode == xlang::plugin::OutputMode::Obj {
-            let mut writer = WriteAdapter::new(x);
             let fmt =
                 binfmt::format_by_name(&targ.link.obj_binfmt).expect("obj_binfmt is not supported");
 
@@ -277,7 +278,7 @@ impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
                     Linkage::Weak => SymbolKind::Weak,
                 };
 
-                if let Some(mut body) = def.body {
+                if let Some(body) = def.body {
                     let section = match def.section {
                         SectionSpec::Global => 0,
                     };
@@ -292,17 +293,22 @@ impl<M: Machine> XLangCodegen for SsaCodegenPlugin<M> {
                     );
                     syms.push(sym);
 
-                    try_!(body
-                        .write(&mut sections[section as usize], |name, offset| {
-                            let inner_sym = Symbol::new(
-                                name,
+                    let mut built = body.build();
+                    try_!(built.legalize(&*self.mach).map_err(Into::into));
+                    built.optimize(&*self.mach);
+
+                    try_!(built
+                        .write_machine_code(
+                            &*self.mach,
+                            &mut sections[section as usize],
+                            |val, sym| syms.push(Symbol::new(
+                                sym,
                                 section,
-                                offset,
-                                SymbolType::Null,
-                                SymbolKind::Local,
-                            );
-                            syms.push(inner_sym);
-                        })
+                                val,
+                                SymbolType::Function,
+                                SymbolKind::Local
+                            ))
+                        )
                         .map_err(Into::into));
 
                     *syms[sym_idx].size_mut() =
diff --git a/xlang/xlang_backend/src/mach.rs b/xlang/xlang_backend/src/mach.rs
index 0ea2593b..4e82339c 100644
--- a/xlang/xlang_backend/src/mach.rs
+++ b/xlang/xlang_backend/src/mach.rs
@@ -1,22 +1,21 @@
+use mce::MceWriter;
 use xlang::{
     abi::collection::HashMap, abi::string::StringView, ir, targets::properties::TargetProperties,
     vec::Vec,
 };
 
-use crate::{
-    mangle::mangle_itanium,
-    ssa::{OpaqueLocation, SsaInstruction},
-    ty::TypeInformation,
-};
+use crate::{mangle::mangle_itanium, ssa::OpaqueLocation, ty::TypeInformation};
 
-use arch_ops::traits::InsnWrite;
+/// A Code Generator that supports Machine-code level Optimizations and Legalizing Transformation
+pub mod mce;
 
-/// A trait for representing the properties of a machine, and for generating code for the machine from [`SsaInstruction`]s
-pub trait Machine {
+/// A trait for representing the properties of a machine, and for generating code for the machine from `R` (a type of instruction)
+pub trait Machine<R>: MceWriter {
     /// The type used per-function to track where each opaque location is placed.
     type Assignments;
     /// The type used per-basic block to track where values need to be spilled or moved to a new assignment
     type BlockClobbers;
+
     /// Determines whether the given named `targ` matches the current [`Machine`]
     fn matches_target(&self, targ: StringView) -> bool;
     /// Initializes the machine from the properties specified in `targ`.
@@ -40,31 +39,29 @@ pub trait Machine {
     fn assign_locations(
         &self,
         assignments: &mut Self::Assignments,
-        insns: &[SsaInstruction],
+        insns: &[R],
         incoming: &[OpaqueLocation],
         which: u32,
         incoming_set: &HashMap<u32, Vec<OpaqueLocation>>,
         tys: &TypeInformation,
     ) -> Self::BlockClobbers;
     /// Writes the prologue instructions for a function to the given [`InsnWrite`]
-    fn codegen_prologue<W: InsnWrite>(
+    fn codegen_prologue(
         &self,
         assignments: &Self::Assignments,
-        out: &mut W,
-    ) -> std::io::Result<()>;
+    ) -> Vec<mce::MceInstruction<Self::Instruction>>;
     /// Writes the machine instructions corresponding to the [`SsaInstruction`]s that make up a basic block.
     ///
     /// The function may generate a label string from it's basic block id by using the `label_sym` callback.
-    fn codegen_block<W: InsnWrite, F: Fn(u32) -> String>(
+    fn codegen_block<F: Fn(u32) -> String>(
         &self,
         assignments: &Self::Assignments,
-        insns: &[SsaInstruction],
+        insns: &[R],
         block_clobbers: Self::BlockClobbers,
-        out: &mut W,
         label_sym: F,
         which: u32,
         tys: &TypeInformation,
-    ) -> std::io::Result<()>;
+    ) -> Vec<mce::MceInstruction<Self::Instruction>>;
 
     /// Mangles the components of a complex XIR [`Path`][xlang::ir::Path]
     /// (Does not solely consistent of an optional [`Root`][xlang::ir::PathComponent::Root] followed by a single bare [`Text`][xlang::ir::PathComponent::Text])
diff --git a/xlang/xlang_backend/src/mach/mce.rs b/xlang/xlang_backend/src/mach/mce.rs
new file mode 100644
index 00000000..6e466ba5
--- /dev/null
+++ b/xlang/xlang_backend/src/mach/mce.rs
@@ -0,0 +1,131 @@
+use arch_ops::traits::InsnWrite;
+use xlang::abi::vec::Vec;
+
+/// A Machine code instruction or psuedo-instruction
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum MceInstruction<I> {
+    /// The base instruction type
+    BaseInsn(I),
+    /// Indicates that no analysis should be performed on subsequent instructions until reaching an [`EnableAnalyze`][MceInstruction::EnableAnalyze]
+    DisableAnalyze,
+    /// Overrides the disposition of a previous [`DisableAnalyze`][MceInstruction::DisableAnalyze]
+    EnableAnalyze,
+    /// A MCE-context private label.
+    /// Primarily used by assembly, but some `ssa` instructions that lower to hardware branches may use this as well
+    ///
+    /// The codegen impl is responsible for appropriately naming the label symbol, but the general syntax should be `<bb-label>._X<p-label-no>`
+    PrivateLabel(String),
+    /// Raw bytes being generated as part of the function
+    /// Assembly directives that emit raw bytes, including `.insn`, will use this variant
+    RawBytes(Vec<u8>),
+    /// Placeholder for Legalizer/Opt that an instruction that was present was eliminated by the transform
+    Empty,
+    /// Placeholder for Legalizer/Opt that a single instruction was split into multiple
+    Split(Vec<MceInstruction<I>>),
+}
+
+/// A trait for types that can write a sequence of instructions to either a relocatable byte stream or textual assembly
+pub trait MceWriter {
+    /// The instruction type for the Mce Codegen
+    type Instruction;
+    /// Writes a sequence of [`MceInstruction`]s to an [`InsnWrite`]
+    fn write_machine_code<W: InsnWrite, F: FnMut(u128, String)>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: W,
+        sym_accepter: F,
+    ) -> std::io::Result<()>;
+    /// Writes the assembly syntax form of a sequence of [`MceInstruction`]s to a [`fmt::Write`][core::fmt::Write]
+    fn write_assembly<W: core::fmt::Write>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: W,
+    ) -> core::fmt::Result;
+
+    /// Transforms a sequence of `insns` so that it is legal on the architecture, or emits an error if it cannot be legalized
+    fn legalize_mce_context(
+        &self,
+        #[allow(unused_variables)] insns: &mut [MceInstruction<Self::Instruction>],
+    ) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    /// Performs optional machine-code level optimizations on generated instruction sequences
+    fn optimize_mce_context(
+        &self,
+        #[allow(unused_variables)] insns: &mut [MceInstruction<Self::Instruction>],
+    ) {
+    }
+}
+
+/// A Fully Built function (MCE)
+pub struct BuiltMceFunction<I> {
+    prologue: Vec<MceInstruction<I>>,
+    basic_blocks: Vec<(String, Vec<MceInstruction<I>>)>,
+}
+
+impl<I> BuiltMceFunction<I> {
+    /// Constructs a new [`BuiltMceFunction`] with the prologue body.
+    pub fn new(prologue: Vec<MceInstruction<I>>) -> Self {
+        Self {
+            prologue,
+            basic_blocks: Vec::new(),
+        }
+    }
+    /// Pushes a new basic block with the given label and body
+    pub fn push_basic_block(&mut self, label: String, insns: Vec<MceInstruction<I>>) {
+        self.basic_blocks.push((label, insns))
+    }
+
+    /// Runs legalization passes on each independent MCE context (prologue and each basic block)
+    pub fn legalize<M: MceWriter<Instruction = I>>(&mut self, mach: &M) -> std::io::Result<()> {
+        mach.legalize_mce_context(&mut self.prologue)?;
+        for (_, insns) in &mut self.basic_blocks {
+            mach.legalize_mce_context(insns)?;
+        }
+        Ok(())
+    }
+
+    /// Runs optimization passes on each independent MCE context (prologue and each basic block)
+    pub fn optimize<M: MceWriter<Instruction = I>>(&mut self, mach: &M) {
+        mach.optimize_mce_context(&mut self.prologue);
+        for (_, insns) in &mut self.basic_blocks {
+            mach.optimize_mce_context(insns);
+        }
+    }
+
+    /// Prints the assembly for the entire function
+    pub fn print_assembly<M: MceWriter<Instruction = I>, W: core::fmt::Write>(
+        &self,
+        mach: &M,
+        mut writer: W,
+    ) -> core::fmt::Result {
+        mach.write_assembly(&self.prologue, &mut writer)?;
+        for (label, insns) in &self.basic_blocks {
+            writer.write_str("\t")?;
+            writer.write_str(label)?;
+            writer.write_str(":\n")?;
+            mach.write_assembly(insns, &mut writer)?;
+        }
+        Ok(())
+    }
+
+    /// Writes the macheine code for the entire function to the given [`InsnWrite`]
+    pub fn write_machine_code<
+        M: MceWriter<Instruction = I>,
+        W: InsnWrite,
+        F: FnMut(u128, String),
+    >(
+        &self,
+        mach: &M,
+        mut writer: W,
+        mut sym_accepter: F,
+    ) -> std::io::Result<()> {
+        mach.write_machine_code(&self.prologue, &mut writer, &mut sym_accepter)?;
+        for (label, insns) in &self.basic_blocks {
+            sym_accepter(writer.offset() as u128, label.clone());
+            mach.write_machine_code(insns, &mut writer, &mut sym_accepter)?;
+        }
+        Ok(())
+    }
+}
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 39914c8e..75138e7f 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -4,13 +4,13 @@ use core::cell::RefCell;
 use std::rc::Rc;
 
 use crate::expr::*;
+use crate::mach::mce::BuiltMceFunction;
 use crate::mach::Machine;
 use crate::ty::TypeInformation;
 
 use crate::str::StringMap;
 
 use arch_ops::traits::Address;
-use arch_ops::traits::InsnWrite;
 use xlang::abi::pair::Pair;
 use xlang::{ir::JumpTarget, targets::properties::TargetProperties};
 
@@ -311,52 +311,52 @@ impl<M> FunctionBuilder<M> {
     }
 }
 
-impl<M: Machine> FunctionBuilder<M> {
-    /// Writes the function to the given [`InsnWrite`], with the given function to accept a new symbol
-    pub fn write<W: InsnWrite, F: FnMut(String, u128)>(
-        &mut self,
-        out: &mut W,
-        mut sym_accepter: F,
-    ) -> std::io::Result<()> {
-        let mut assigns = self.mach.new_assignments();
-        let mut block_clobbers = vec![];
-
-        if let Some(bb) = &self.basic_blocks.first() {
-            self.mach.assign_call_conv(
-                &mut assigns,
-                &self.incoming_locations[&bb.id],
-                &self.fnty,
-                &self.tys,
-                bb.id,
-            )
-        }
+impl<M: Machine<SsaInstruction>> FunctionBuilder<M> {
+    /// Builds the [`SsaInstruction`] function into a [`BuiltMceFunction`]
+    pub fn build(&self) -> BuiltMceFunction<M::Instruction> {
+        let mut assignments = self.mach.new_assignments();
+
+        let mut block_clobbers = Vec::new();
+        let mut call_first = false;
 
         for bb in &self.basic_blocks {
+            let incoming = &self.incoming_locations[&bb.id];
+            if !call_first {
+                call_first = true;
+                self.mach.assign_call_conv(
+                    &mut assignments,
+                    incoming,
+                    &self.fnty,
+                    &self.tys,
+                    bb.id,
+                );
+            }
             block_clobbers.push(self.mach.assign_locations(
-                &mut assigns,
+                &mut assignments,
                 &bb.insns,
-                self.incoming_locations.get(&bb.id).unwrap(),
+                incoming,
                 bb.id,
                 &self.incoming_locations,
                 &self.tys,
             ));
         }
 
-        self.mach.codegen_prologue(&assigns, out)?;
-        for (bb, block_clobbers) in self.basic_blocks.iter().zip(block_clobbers) {
-            let symbol = format!("{}._B{}", self.sym_name, bb.id);
-            sym_accepter(symbol, out.offset() as u128);
-            self.mach.codegen_block(
-                &assigns,
+        let mut mce = BuiltMceFunction::new(self.mach.codegen_prologue(&assignments));
+
+        for (bb, clobbers) in self.basic_blocks.iter().zip(block_clobbers) {
+            let st = format!("{}._T{}", self.sym_name, bb.id);
+            let insns = self.mach.codegen_block(
+                &assignments,
                 &bb.insns,
-                block_clobbers,
-                out,
-                |id| format!("{}._B{}", self.sym_name, id),
+                clobbers,
+                |id| format!("{}._T{}", self.sym_name, id),
                 bb.id,
                 &self.tys,
-            )?;
+            );
+            mce.push_basic_block(st, insns);
         }
-        Ok(())
+
+        mce
     }
 }
 
@@ -389,7 +389,7 @@ pub struct BasicBlockBuilder<M> {
     string_interner: Rc<RefCell<StringMap>>,
 }
 
-impl<M: Machine> BasicBlockBuilder<M> {
+impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
     /// Moves the given [`VStackValue`] into the specified [`OpaqueLocation`], generating appropriate loads and move instructions to place both transparent and opaque values in the new location
     pub fn move_into(&mut self, val: VStackValue<OpaqueLocation>, loc: OpaqueLocation) {
         match val {
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index da48ee2b..03e899d6 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -2371,6 +2371,7 @@ bitflags::bitflags! {
     /// jump-target-flag := "fallthrough" / "cold" / "continue"
     /// ```
     #[repr(transparent)]
+    #[derive(Default)]
     pub struct JumpTargetFlags : u32{
         /// The "fallthrough" flag.
         /// Indicates that the jump does not perform a branch but instead continues on to the next basic block
@@ -2403,7 +2404,7 @@ impl core::fmt::Display for JumpTargetFlags {
 /// jump-target := [*(<jump-target-flags>)] @<int-literal>
 /// ```
 #[repr(C)]
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Default, Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub struct JumpTarget {
     /// The flags for the jump
     pub flags: JumpTargetFlags,

From 31f4983e388af95d8bb26ff005f7b1f3352c17d5 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 28 Jun 2024 15:44:47 -0400
Subject: [PATCH 55/74] feat(xlang-backend): Refactor codegens to use new mce

---
 codegen-clever/src/lib.rs           |  44 +++++--
 codegen-w65/src/lib.rs              |  42 +++++--
 codegen-x86/src/lib.rs              | 177 ++++++++++++++++++----------
 xlang/xlang_backend/src/mach/mce.rs |   6 +-
 4 files changed, 185 insertions(+), 84 deletions(-)

diff --git a/codegen-clever/src/lib.rs b/codegen-clever/src/lib.rs
index 07596d62..d849ad0e 100644
--- a/codegen-clever/src/lib.rs
+++ b/codegen-clever/src/lib.rs
@@ -1,9 +1,18 @@
+use arch_ops::clever::CleverInstruction;
 use target_tuples::{Architecture, Target};
 use xlang::{
     abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
     targets::properties::TargetProperties,
 };
-use xlang_backend::{mach::Machine, ssa::OpaqueLocation, ty::TypeInformation, SsaCodegenPlugin};
+use xlang_backend::{
+    mach::{
+        mce::{MceInstruction, MceWriter},
+        Machine,
+    },
+    ssa::{OpaqueLocation, SsaInstruction},
+    ty::TypeInformation,
+    SsaCodegenPlugin,
+};
 
 pub struct CleverAssignments {}
 
@@ -11,7 +20,28 @@ pub struct CleverClobbers {}
 
 pub struct CleverMachine {}
 
-impl Machine for CleverMachine {
+impl MceWriter for CleverMachine {
+    type Instruction = CleverInstruction;
+
+    fn write_assembly<W: core::fmt::Write>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: &mut W,
+    ) -> core::fmt::Result {
+        todo!()
+    }
+
+    fn write_machine_code<W: arch_ops::traits::InsnWrite, F: FnMut(u128, std::string::String)>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: &mut W,
+        sym_accepter: &mut F,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+}
+
+impl Machine<SsaInstruction> for CleverMachine {
     fn matches_target(&self, targ: StringView) -> bool {
         Target::parse(&targ).arch() == Architecture::Clever
     }
@@ -38,24 +68,22 @@ impl Machine for CleverMachine {
         todo!()
     }
 
-    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
+    fn codegen_prologue(
         &self,
         assignments: &Self::Assignments,
-        out: &mut W,
-    ) -> std::io::Result<()> {
+    ) -> Vec<MceInstruction<CleverInstruction>> {
         todo!()
     }
 
-    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
+    fn codegen_block<F: Fn(u32) -> std::prelude::v1::String>(
         &self,
         assignments: &Self::Assignments,
         insns: &[xlang_backend::ssa::SsaInstruction],
         block_clobbers: Self::BlockClobbers,
-        out: &mut W,
         label_sym: F,
         which: u32,
         tys: &TypeInformation,
-    ) -> std::io::Result<()> {
+    ) -> Vec<MceInstruction<CleverInstruction>> {
         todo!()
     }
 
diff --git a/codegen-w65/src/lib.rs b/codegen-w65/src/lib.rs
index 62562a4b..335c0dd4 100644
--- a/codegen-w65/src/lib.rs
+++ b/codegen-w65/src/lib.rs
@@ -1,9 +1,18 @@
+use arch_ops::w65::W65Instruction;
 use target_tuples::{Architecture, Target};
 use xlang::{
     abi::string::StringView, plugin::XLangCodegen, prelude::v1::*,
     targets::properties::TargetProperties,
 };
-use xlang_backend::{mach::Machine, ssa::OpaqueLocation, ty::TypeInformation, SsaCodegenPlugin};
+use xlang_backend::{
+    mach::{
+        mce::{MceInstruction, MceWriter},
+        Machine,
+    },
+    ssa::{OpaqueLocation, SsaInstruction},
+    ty::TypeInformation,
+    SsaCodegenPlugin,
+};
 
 pub struct W65Assignments {}
 
@@ -11,7 +20,26 @@ pub struct W65Clobbers {}
 
 pub struct W65Machine {}
 
-impl Machine for W65Machine {
+impl MceWriter for W65Machine {
+    type Instruction = W65Instruction;
+    fn write_machine_code<W: arch_ops::traits::InsnWrite, F: FnMut(u128, std::string::String)>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: &mut W,
+        sym_accepter: &mut F,
+    ) -> std::io::Result<()> {
+        todo!()
+    }
+    fn write_assembly<W: core::fmt::Write>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: &mut W,
+    ) -> core::fmt::Result {
+        todo!()
+    }
+}
+
+impl Machine<SsaInstruction> for W65Machine {
     fn matches_target(&self, targ: StringView) -> bool {
         Target::parse(&targ).arch() == Architecture::Wc65c816
     }
@@ -38,24 +66,22 @@ impl Machine for W65Machine {
         todo!()
     }
 
-    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
+    fn codegen_prologue(
         &self,
         assignments: &Self::Assignments,
-        out: &mut W,
-    ) -> std::io::Result<()> {
+    ) -> Vec<MceInstruction<W65Instruction>> {
         todo!()
     }
 
-    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
+    fn codegen_block<F: Fn(u32) -> std::prelude::v1::String>(
         &self,
         assignments: &Self::Assignments,
         insns: &[xlang_backend::ssa::SsaInstruction],
         block_clobbers: Self::BlockClobbers,
-        out: &mut W,
         label_sym: F,
         which: u32,
         tys: &TypeInformation,
-    ) -> std::io::Result<()> {
+    ) -> Vec<MceInstruction<W65Instruction>> {
         todo!()
     }
 
diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 5a0d644b..3975b1fd 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -6,19 +6,24 @@ use arch_ops::{
     },
 };
 use callconv::X86CallConvInfo;
+use std::io::Write;
+use std::vec as std_vec;
 use target_tuples::{Architecture, Target};
 use xlang::{
     abi::{pair::Pair, string::StringView},
     ir,
     plugin::XLangCodegen,
-    prelude::v1::{DynBox, HashMap},
+    prelude::v1::{vec, DynBox, HashMap, Vec},
     targets::properties::TargetProperties,
 };
 use xlang_backend::{
     callconv::{compute_call_conv, CallConvLocation},
     expr::Trap,
-    mach::Machine,
-    ssa::OpaquePtr,
+    mach::{
+        mce::{MceInstruction, MceWriter},
+        Machine,
+    },
+    ssa::{OpaquePtr, SsaInstruction},
     ty::TypeInformation,
     SsaCodegenPlugin,
 };
@@ -176,20 +181,20 @@ fn move_opcode(
 }
 
 impl X86Machine {
-    pub fn write_move<W: InsnWrite>(
+    pub fn write_move(
         &self,
-        writer: &mut X86Encoder<W>,
+        insns: &mut Vec<MceInstruction<X86Instruction>>,
         dest: &X86ValLocation,
         src: &X86ValLocation,
         assigns: &X86Assignments,
-    ) -> std::io::Result<()> {
+    ) {
         if dest == src {
-            return Ok(());
+            return;
         }
         match (dest, src) {
             (X86ValLocation::Null, X86ValLocation::Null)
             | (X86ValLocation::Null, X86ValLocation::StackDisp(_))
-            | (X86ValLocation::StackDisp(_), X86ValLocation::Null) => Ok(()),
+            | (X86ValLocation::StackDisp(_), X86ValLocation::Null) => {}
             (X86ValLocation::Register(dest), X86ValLocation::Register(src)) => {
                 if dest.class() != src.class() {
                     panic!("Cannot move between register classes")
@@ -201,10 +206,10 @@ impl X86Machine {
                     _ => {
                         let opcode = move_opcode(dest.class(), None, false);
 
-                        writer.write_insn(X86Instruction::new(
+                        insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                             opcode,
-                            vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
-                        ))
+                            std_vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
+                        )))
                     }
                 }
             }
@@ -212,9 +217,9 @@ impl X86Machine {
                 let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
-                writer.write_insn(X86Instruction::new(
+                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                     opcode,
-                    vec![
+                    std_vec![
                         X86Operand::Memory(
                             reg.class(),
                             None,
@@ -225,15 +230,15 @@ impl X86Machine {
                         ),
                         X86Operand::Register(*reg),
                     ],
-                ))
+                )));
             }
             (X86ValLocation::Register(reg), X86ValLocation::StackDisp(off)) => {
                 let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
-                writer.write_insn(X86Instruction::new(
+                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                     opcode,
-                    vec![
+                    std_vec![
                         X86Operand::Register(*reg),
                         X86Operand::Memory(
                             reg.class(),
@@ -244,7 +249,7 @@ impl X86Machine {
                             },
                         ),
                     ],
-                ))
+                )));
             }
             (X86ValLocation::Null, X86ValLocation::Register(_))
             | (X86ValLocation::Register(_), X86ValLocation::Null) => {
@@ -257,7 +262,49 @@ impl X86Machine {
     }
 }
 
-impl Machine for X86Machine {
+impl MceWriter for X86Machine {
+    type Instruction = X86Instruction;
+
+    fn write_machine_code<W: InsnWrite, F: FnMut(u128, String)>(
+        &self,
+        insn: &[xlang_backend::mach::mce::MceInstruction<Self::Instruction>],
+        writer: &mut W,
+        sym_accepter: &mut F,
+    ) -> std::io::Result<()> {
+        let mut encoder = X86Encoder::new(writer, self.mode.unwrap());
+        for insn in insn {
+            match insn {
+                MceInstruction::BaseInsn(insn) => {
+                    encoder.write_insn(insn.clone())?;
+                }
+                xlang_backend::mach::mce::MceInstruction::PrivateLabel(label) => {
+                    sym_accepter(encoder.offset() as u128, label.clone());
+                }
+                xlang_backend::mach::mce::MceInstruction::RawBytes(bytes) => {
+                    encoder.write_all(bytes)?
+                }
+                xlang_backend::mach::mce::MceInstruction::Split(insns) => {
+                    self.write_machine_code(insns, &mut **encoder.inner_mut(), sym_accepter)?
+                }
+                xlang_backend::mach::mce::MceInstruction::Empty
+                | xlang_backend::mach::mce::MceInstruction::DisableAnalyze
+                | xlang_backend::mach::mce::MceInstruction::EnableAnalyze => {}
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_assembly<W: core::fmt::Write>(
+        &self,
+        insn: &[MceInstruction<Self::Instruction>],
+        writer: &mut W,
+    ) -> core::fmt::Result {
+        todo!("x86 assembly output")
+    }
+}
+
+impl Machine<SsaInstruction> for X86Machine {
     fn matches_target(&self, targ: StringView) -> bool {
         let arch = Target::parse(&targ).arch();
         arch.is_x86() || arch == Architecture::X86_64
@@ -543,34 +590,28 @@ impl Machine for X86Machine {
         clobbers
     }
 
-    fn codegen_block<W: arch_ops::traits::InsnWrite, F: Fn(u32) -> std::prelude::v1::String>(
+    fn codegen_block<F: Fn(u32) -> std::prelude::v1::String>(
         &self,
         assignments: &Self::Assignments,
-        insns: &[xlang_backend::ssa::SsaInstruction],
+        ssa_insns: &[xlang_backend::ssa::SsaInstruction],
         block_clobbers: Self::BlockClobbers,
-        out: &mut W,
         label_sym: F,
         which: u32,
         tys: &TypeInformation,
-    ) -> std::io::Result<()> {
-        let mut encoder = X86Encoder::new(out, assignments.mode);
+    ) -> Vec<MceInstruction<X86Instruction>> {
+        let mut insns = Vec::new();
         let mut cur_locations = HashMap::<_, _>::new();
         for Pair(addr, loc) in &assignments.assigns {
             if loc.owning_bb == which {
                 cur_locations.insert(*addr, loc.foreign_location.clone());
             }
         }
-        for (num, insn) in insns.iter().enumerate() {
+        for (num, insn) in ssa_insns.iter().enumerate() {
             for Pair(addr, loc) in &assignments.assigns {
                 if loc.owning_bb == which {
                     for (at, new_loc) in &loc.change_owner {
                         if *at == num {
-                            self.write_move(
-                                &mut encoder,
-                                new_loc,
-                                &cur_locations[addr],
-                                assignments,
-                            )?;
+                            self.write_move(&mut insns, new_loc, &cur_locations[addr], assignments);
                             break;
                         }
                     }
@@ -579,59 +620,63 @@ impl Machine for X86Machine {
 
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, _) => match &targ.ptr {
-                    OpaquePtr::Symbol(sym) => encoder.write_insn(X86Instruction::new(
-                        X86CodegenOpcode::Call,
-                        vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
-                    ))?,
+                    OpaquePtr::Symbol(sym) => {
+                        insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                            X86CodegenOpcode::Call,
+                            std_vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
+                        )))
+                    }
                     OpaquePtr::Pointer(ptr) => todo!("indirect call"),
                 },
                 xlang_backend::ssa::SsaInstruction::Jump(targ, _) => {
-                    encoder.write_insn(X86Instruction::new(
+                    insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                         X86CodegenOpcode::Jmp,
-                        vec![X86Operand::RelOffset(Address::Symbol {
+                        std_vec![X86Operand::RelOffset(Address::Symbol {
                             name: label_sym(*targ),
                             disp: 0,
                         })],
-                    ))?;
+                    )));
                 }
                 xlang_backend::ssa::SsaInstruction::Fallthrough(_, _) => {}
                 xlang_backend::ssa::SsaInstruction::Exit(val) => {
                     if assignments.stack_width > 0 {
-                        encoder.write_insn(X86Instruction::new(
+                        insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                             X86CodegenOpcode::Add,
-                            vec![
+                            std_vec![
                                 X86Operand::Register(assignments.sp),
                                 X86Operand::Immediate(assignments.stack_width as i64),
                             ],
-                        ))?;
+                        )));
                     }
-                    encoder.write_insn(X86Instruction::Ret)?;
+                    insns.push(MceInstruction::BaseInsn(X86Instruction::Ret));
                 }
                 xlang_backend::ssa::SsaInstruction::Tailcall(targ, _) => match &targ.ptr {
-                    OpaquePtr::Symbol(sym) => encoder.write_insn(X86Instruction::new(
-                        X86CodegenOpcode::Jmp,
-                        vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
-                    ))?,
+                    OpaquePtr::Symbol(sym) => {
+                        insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                            X86CodegenOpcode::Jmp,
+                            std_vec![X86Operand::RelOffset(Address::PltSym { name: sym.clone() })],
+                        )))
+                    }
                     OpaquePtr::Pointer(ptr) => todo!("indirect call"),
                 },
                 xlang_backend::ssa::SsaInstruction::Trap(Trap::Breakpoint) => {
-                    encoder.write_insn(X86Instruction::Int3)?
+                    insns.push(MceInstruction::BaseInsn(X86Instruction::Int3))
                 }
                 xlang_backend::ssa::SsaInstruction::Trap(_) => {
-                    encoder.write_insn(X86Instruction::Ud2)?
+                    insns.push(MceInstruction::BaseInsn(X86Instruction::Ud2))
                 }
                 xlang_backend::ssa::SsaInstruction::LoadImmediate(loc, val) => {
                     if let Some(location) = cur_locations.get(&loc.num) {
                         match location {
                             X86ValLocation::Register(reg) => {
                                 let mov = move_opcode(reg.class(), None, true);
-                                encoder.write_insn(X86Instruction::new(
+                                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                                     mov,
-                                    vec![
+                                    std_vec![
                                         X86Operand::Register(*reg),
                                         X86Operand::Immediate((*val) as i64),
                                     ],
-                                ))?;
+                                )));
                             }
                             X86ValLocation::Null => {}
                             X86ValLocation::StackDisp(_) => todo!("memory"),
@@ -645,9 +690,9 @@ impl Machine for X86Machine {
                                 let lea = X86CodegenOpcode::Lea;
                                 let cl = reg.class();
 
-                                encoder.write_insn(X86Instruction::new(
+                                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                                     lea,
-                                    vec![
+                                    std_vec![
                                         X86Operand::Register(*reg),
                                         X86Operand::Memory(
                                             cl,
@@ -655,7 +700,7 @@ impl Machine for X86Machine {
                                             X86MemoryOperand::RelAddr(addr.clone()),
                                         ),
                                     ],
-                                ))?;
+                                )));
                             }
                             X86ValLocation::Null => {}
                             X86ValLocation::StackDisp(_) => todo!("memory"),
@@ -677,10 +722,13 @@ impl Machine for X86Machine {
 
                                 let xor = xor_opcode(reg.class(), is_int);
 
-                                encoder.write_insn(X86Instruction::new(
+                                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                                     xor,
-                                    vec![X86Operand::Register(*reg), X86Operand::Register(*reg)],
-                                ))?;
+                                    std_vec![
+                                        X86Operand::Register(*reg),
+                                        X86Operand::Register(*reg)
+                                    ],
+                                )));
                             }
                             X86ValLocation::Null => {}
                             X86ValLocation::StackDisp(_) => todo!("memory"),
@@ -690,26 +738,25 @@ impl Machine for X86Machine {
             }
         }
 
-        Ok(())
+        insns
     }
 
-    fn codegen_prologue<W: arch_ops::traits::InsnWrite>(
+    fn codegen_prologue(
         &self,
         assignments: &Self::Assignments,
-        out: &mut W,
-    ) -> std::io::Result<()> {
+    ) -> Vec<MceInstruction<X86Instruction>> {
+        let mut insns = Vec::new();
         if assignments.stack_width != 0 {
-            let mut encoder = X86Encoder::new(out, assignments.mode);
-            encoder.write_insn(X86Instruction::new(
+            insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                 X86CodegenOpcode::Sub,
-                vec![
+                std_vec![
                     X86Operand::Register(assignments.sp),
                     X86Operand::Immediate(assignments.stack_width as i64),
                 ],
-            ))?;
+            )));
         }
 
-        Ok(())
+        insns
     }
 
     fn assign_call_conv(
diff --git a/xlang/xlang_backend/src/mach/mce.rs b/xlang/xlang_backend/src/mach/mce.rs
index 6e466ba5..56493382 100644
--- a/xlang/xlang_backend/src/mach/mce.rs
+++ b/xlang/xlang_backend/src/mach/mce.rs
@@ -32,14 +32,14 @@ pub trait MceWriter {
     fn write_machine_code<W: InsnWrite, F: FnMut(u128, String)>(
         &self,
         insn: &[MceInstruction<Self::Instruction>],
-        writer: W,
-        sym_accepter: F,
+        writer: &mut W,
+        sym_accepter: &mut F,
     ) -> std::io::Result<()>;
     /// Writes the assembly syntax form of a sequence of [`MceInstruction`]s to a [`fmt::Write`][core::fmt::Write]
     fn write_assembly<W: core::fmt::Write>(
         &self,
         insn: &[MceInstruction<Self::Instruction>],
-        writer: W,
+        writer: &mut W,
     ) -> core::fmt::Result;
 
     /// Transforms a sequence of `insns` so that it is legal on the architecture, or emits an error if it cannot be legalized

From 86e346a860ff786db9453ab0054d940760470282 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 28 Jun 2024 22:35:29 -0400
Subject: [PATCH 56/74] feat(rust-sema): Support Lang Items in intrinsic
 signatures

---
 lcrust/libraries/lccc-siphash |  2 +-
 rust/src/lang.rs              |  1 +
 rust/src/sema.rs              | 17 ++++++++++-
 rust/src/sema/intrin.rs       | 54 ++++++++++++++++++++---------------
 rust/src/sema/ty.rs           |  4 +++
 rust/src/sema/tyck.rs         | 47 ++++++++++++++++--------------
 6 files changed, 78 insertions(+), 47 deletions(-)

diff --git a/lcrust/libraries/lccc-siphash b/lcrust/libraries/lccc-siphash
index 7ceecb6f..c518f9b5 160000
--- a/lcrust/libraries/lccc-siphash
+++ b/lcrust/libraries/lccc-siphash
@@ -1 +1 @@
-Subproject commit 7ceecb6fb658568cc189cc5d0d5afb88f9471924
+Subproject commit c518f9b557a6d03ec6f53eb1a52257dafee4a615
diff --git a/rust/src/lang.rs b/rust/src/lang.rs
index 452058d6..c1e40b0e 100644
--- a/rust/src/lang.rs
+++ b/rust/src/lang.rs
@@ -95,4 +95,5 @@ define_lang_items! {
     LayoutTy: layout @ Type,
     AllocSym: alloc_sym @ Function,
     DeallocSym: dealloc_sym @ Function,
+    VaList : va_list @ Type,
 }
diff --git a/rust/src/sema.rs b/rust/src/sema.rs
index ba3ec832..06c540ca 100644
--- a/rust/src/sema.rs
+++ b/rust/src/sema.rs
@@ -1385,6 +1385,7 @@ impl Definitions {
             ty::Type::Tuple(inner) => inner.iter().all(|ty| self.is_copy(ty)),
             ty::Type::UserType(_, _) => false, // for now
             ty::Type::IncompleteAlias(_) => panic!("incomplete alias held too late"),
+            ty::Type::UnresolvedLangItem(_, _) => panic!("Unresolved lang item"),
             ty::Type::Array(ty, _) => self.is_copy(ty),
             ty::Type::InferableInt(_) | ty::Type::Inferable(_) => {
                 panic!("Cannot determine copyability of an uninfered type")
@@ -1399,6 +1400,18 @@ impl Definitions {
         self.lang_items.get(&lang).copied()
     }
 
+    pub fn require_lang_item(&self, lang: LangItem) -> Result<DefId> {
+        self.get_lang_item(lang).ok_or_else(|| Error {
+            span: Span::synthetic(),
+            text: format!("Lang item {} required but not defined", lang.name()),
+            category: ErrorCategory::CannotFindName,
+            containing_item: self.curcrate,
+            at_item: self.curcrate,
+            relevant_item: DefId::ROOT,
+            hints: vec![],
+        })
+    }
+
     pub fn type_defid(&self, ty: &ty::Type) -> DefId {
         // todo: look up primitive impl lang item
         match ty {
@@ -1788,6 +1801,7 @@ impl Definitions {
                     }
                 }
                 Type::IncompleteAlias(_) => todo!("incomplete alias held too late"),
+                Type::UnresolvedLangItem(_, _) => panic!("Unresolved lang item not resolved"),
                 Type::Pointer(_, pte) => {
                     let layout = self.layout_of(pte, at_item, containing_item);
 
@@ -2013,7 +2027,8 @@ impl Definitions {
                 | Type::Reference(_, _, _)
                 | Type::Pointer(_, _)
                 | Type::Array(_, _)
-                | Type::TraitSelf(_) => Vec::new(),
+                | Type::TraitSelf(_)
+                | Type::UnresolvedLangItem(_, _) => Vec::new(),
                 Type::Tuple(elems) => {
                     let mut fields = Vec::new();
 
diff --git a/rust/src/sema/intrin.rs b/rust/src/sema/intrin.rs
index 6caa0384..563a2de5 100644
--- a/rust/src/sema/intrin.rs
+++ b/rust/src/sema/intrin.rs
@@ -89,61 +89,64 @@ macro_rules! parse_cvarargs {
 }
 
 macro_rules! parse_type_inner {
-    (($inner:ty)) => {
+    (|$defs:ident| ($inner:ty)) => {
         parse_type!($inner)
     };
-    (Var$(::)?<$id:literal>) => {
+    (|$defs:ident| Var$(::)?<$id:literal>) => {
         (super::ty::Type::Param($id))
     };
-    ($ident:ident) => {
+    (|$defs:ident| Lang$(::)?<$id:ident>) => {
+        (super::ty::Type::UnresolvedLangItem($crate::lang::LangItem::$id, super::generics::GenericArgs::default()))
+    };
+    (|$defs:ident| $ident:ident) => {
         super::ty::convert_builtin_type(::core::stringify!($ident)).unwrap() // TODO: also support lang item types and generics
     };
-    (&$inner:ty) => {
-        {Type::Reference(None, spanned!(Mutability::Const), spanned!(box parse_type!($inner)))}
+    (|$defs:ident| &$inner:ty) => {
+        {Type::Reference(None, spanned!(Mutability::Const), spanned!(box parse_type!(|$defs| $inner)))}
     };
-    (&mut $inner:ty) => {
-        {Type::Reference(None, spanned!(Mutability::Mut), spanned!(box parse_type!($inner)))}
+    (|$defs:ident| &mut $inner:ty) => {
+        {Type::Reference(None, spanned!(Mutability::Mut), spanned!(box parse_type!(|$defs| $inner)))}
     };
-    (*const $inner:ty) => {
-        {Type::Pointer(spanned!(Mutability::Const), spanned!(box parse_type!($inner)))}
+    (|$defs:ident| *const $inner:ty) => {
+        {Type::Pointer(spanned!(Mutability::Const), spanned!(box parse_type!(|$defs| $inner)))}
     };
-    (*mut $inner:ty) => {
-        {Type::Pointer(spanned!(Mutability::Mut), spanned!(box parse_type!($inner)))}
+    (|$defs:ident| *mut $inner:ty) => {
+        {Type::Pointer(spanned!(Mutability::Mut), spanned!(box parse_type!(|$defs| $inner)))}
     };
-    (($($inner:ty),* $(,)?)) => {
-        {{Type::Tuple(vec![$(spanned!(parse_type!($inner))),*])}}
+    (|$defs:ident| ($($inner:ty),* $(,)?)) => {
+        {{Type::Tuple(vec![$(spanned!(parse_type!(|$defs| $inner))),*])}}
     };
-    (!) => {
+    (|$_defs:ident| !) => {
         Type::Never
     };
-    ($(unsafe $(@$_vol:tt)?)? $(extern $lit:literal)? fn($($param:ty),* $(, $(... $(@$_vol2:tt)?)?)?) -> $ret:ty) => {
+    (|$defs:ident| $(unsafe $(@$_vol:tt)?)? $(extern $lit:literal)? fn($($param:ty),* $(, $(... $(@$_vol2:tt)?)?)?) -> $ret:ty) => {
         Type::FnType (FnType{
             safety: spanned!(parse_safety!($(unsafe $($_vol)?)?)),
             constness: spanned!(Mutability::Const),
             asyncness: spanned!(ty::AsyncType::Normal),
             tag: spanned!(parse_tag!($(extern $lit)?)),
-            retty: spanned!(box parse_type!($ret)),
-            paramtys: vec![$(spanned!($param)),*],
+            retty: spanned!(box parse_type!(|$defs| $ret)),
+            paramtys: vec![$(spanned!(parse_type!(|$defs| $param))),*],
             iscvarargs: spanned!(parse_cvarargs!($($(... $($_vol2)?)?)?))
         })
     };
 }
 
 macro_rules! parse_type {
-    ($inner:ty) => {
-        {::defile::defile!({parse_type_inner!(@$inner)})}
+    (|$defs:ident| $inner:ty) => {
+        {::defile::defile!({parse_type_inner!(|$defs| @$inner)})}
     };
 }
 
 macro_rules! parse_intrinsic_signature {
-    ($(unsafe $(@$_vol:tt)?)? fn($($param:ty),* $(,)?) -> $retty:ty) => {
+    (|$defs:ident| $(unsafe $(@$_vol:tt)?)? fn($($param:ty),* $(,)?) -> $retty:ty) => {
         ty::FnType {
             safety: spanned!(parse_safety!($(unsafe $($_vol)?)?)),
             constness: spanned!(Mutability::Const),
             asyncness: spanned!(ty::AsyncType::Normal),
             tag: spanned!(AbiTag::RustIntrinsic),
-            retty: spanned!(box parse_type!($retty)),
-            paramtys: vec![$(spanned!(parse_type!($param))),*],
+            retty: spanned!(box parse_type!(|$defs| $retty)),
+            paramtys: vec![$(spanned!(parse_type!(|$defs| $param))),*],
             iscvarargs: spanned!(false),
         }
     };
@@ -220,7 +223,7 @@ macro_rules! def_intrinsics {
 
             pub fn signature(&self) -> ty::FnType {
                 match self{
-                    $(Self::$name => parse_intrinsic_signature!($(unsafe $($_vol)?)? fn($($param),*) -> $retty)),*
+                    $(Self::$name => parse_intrinsic_signature!(|defs| $(unsafe $($_vol)?)? fn($($param),*) -> $retty)),*
                 }
             }
 
@@ -357,4 +360,9 @@ def_intrinsics! {
     unsafe intrin __atomic_write_in_transaction<type, const>(ptr: *mut Var<0>, val: Var<0>) -> ();
     #[unobservable]
     unsafe intrin __atomic_commit_transaction<type>(ptr: *mut Var<0>) -> i32;
+
+
+    unsafe intrin __builtin_va_arg<type>(va_list: *mut Lang<VaList>) -> Var<0>;
+    unsafe intrin __builtin_va_copy(va_list: *mut Lang<VaList>, out:*mut Lang<VaList>)->();
+    unsafe intrin __builtin_va_end(va_list: *mut Lang<VaList>) -> ();
 }
diff --git a/rust/src/sema/ty.rs b/rust/src/sema/ty.rs
index bdeca9e2..1b975f90 100644
--- a/rust/src/sema/ty.rs
+++ b/rust/src/sema/ty.rs
@@ -97,6 +97,7 @@ pub enum Type {
     FnPtr(Box<FnType>),
     FnItem(Box<FnType>, DefId, GenericArgs),
     UserType(DefId, GenericArgs),
+    UnresolvedLangItem(LangItem, GenericArgs),
     IncompleteAlias(DefId),
     Pointer(Spanned<Mutability>, Box<Spanned<Type>>),
     Array(Box<Spanned<Type>>, Spanned<ConstExpr>),
@@ -764,6 +765,9 @@ impl core::fmt::Display for Type {
             Self::Param(var) => f.write_fmt(format_args!("%{}", var)),
             Self::TraitSelf(tr) => f.write_fmt(format_args!("Self(impl #{})", tr)),
             Self::DropFlags(ty) => f.write_fmt(format_args!("DropFlags({})", ty)),
+            Self::UnresolvedLangItem(lang, args) => {
+                f.write_fmt(format_args!("{} {}", lang.name(), args))
+            }
         }
     }
 }
diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
index 8817d808..79913176 100644
--- a/rust/src/sema/tyck.rs
+++ b/rust/src/sema/tyck.rs
@@ -622,44 +622,44 @@ impl<'a> ThirConverter<'a> {
         Ok(ret)
     }
 
-    pub fn convert_syntatic_type(&mut self, ty: Spanned<Type>) -> Spanned<Type> {
-        ty.map_span(|ty| match ty {
-            Type::Inferable(None) => {
-                Type::Inferable(Some(InferId(self.next_infer.fetch_increment())))
-            }
+    pub fn convert_syntatic_type(&mut self, ty: Spanned<Type>) -> super::Result<Spanned<Type>> {
+        ty.try_map_span(|ty| match ty {
+            Type::Inferable(None) => Ok(Type::Inferable(Some(InferId(
+                self.next_infer.fetch_increment(),
+            )))),
 
             Type::IncompleteAlias(_) => todo!("incomplete alias"),
 
-            Type::Tuple(tys) => Type::Tuple(
+            Type::Tuple(tys) => Ok(Type::Tuple(
                 tys.into_iter()
                     .map(|ty| self.convert_syntatic_type(ty))
-                    .collect(),
-            ),
+                    .collect::<super::Result<_>>()?,
+            )),
             Type::FnPtr(mut fnty) => {
                 fnty.paramtys = fnty
                     .paramtys
                     .into_iter()
                     .map(|ty| self.convert_syntatic_type(ty))
-                    .collect();
-                *fnty.retty = self.convert_syntatic_type(*fnty.retty);
+                    .collect::<super::Result<_>>()?;
+                *fnty.retty = self.convert_syntatic_type(*fnty.retty)?;
 
-                Type::FnPtr(fnty)
+                Ok(Type::FnPtr(fnty))
             }
 
             Type::Pointer(mt, mut ty) => {
-                *ty = self.convert_syntatic_type(*ty);
+                *ty = self.convert_syntatic_type(*ty)?;
 
-                Type::Pointer(mt, ty)
+                Ok(Type::Pointer(mt, ty))
             }
             Type::Array(mut ty, cx) => {
-                *ty = self.convert_syntatic_type(*ty);
+                *ty = self.convert_syntatic_type(*ty)?;
 
-                Type::Array(ty, cx)
+                Ok(Type::Array(ty, cx))
             }
             Type::Reference(life, mt, mut ty) => {
-                *ty = self.convert_syntatic_type(*ty);
+                *ty = self.convert_syntatic_type(*ty)?;
 
-                Type::Reference(life, mt, ty)
+                Ok(Type::Reference(life, mt, ty))
             }
             val @ (Type::Inferable(Some(_))
             | Type::InferableInt(_)
@@ -673,7 +673,10 @@ impl<'a> ThirConverter<'a> {
             | Type::Str
             | Type::FnItem(_, _, _)
             | Type::UserType(_, _)
-            | Type::Never) => val,
+            | Type::Never) => Ok(val),
+            Type::UnresolvedLangItem(lang, args) => {
+                Ok(Type::UserType(self.defs.require_lang_item(lang)?, args))
+            }
         })
     }
 
@@ -794,7 +797,7 @@ impl<'a> ThirConverter<'a> {
                 inner: ThirExprInner::Unreachable,
             }),
             hir::HirExpr::Cast(expr, ty) => {
-                let ty = self.convert_syntatic_type(ty.clone());
+                let ty = self.convert_syntatic_type(ty.clone())?;
                 Ok(ThirExpr {
                     ty: ty.body.clone(),
                     cat: ValueCategory::Rvalue,
@@ -1168,11 +1171,11 @@ impl<'a> ThirConverter<'a> {
                     .unwrap_or_else(|| {
                         let infer = InferId(self.next_infer.fetch_increment());
 
-                        Spanned {
+                        Ok(Spanned {
                             span: var.span,
                             body: Type::Inferable(Some(infer)),
-                        }
-                    });
+                        })
+                    })?;
 
                 let mutability = *mutability;
 

From 7652d96eacf4c923f52cd0a3fa093227c1d7f6e7 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 28 Jun 2024 23:58:10 -0400
Subject: [PATCH 57/74] fix(codegen-x86): Actually spill clobbered and
 later-used registers to the stack

---
 codegen-x86/src/lib.rs           | 68 +++++++++++++++++++++++---------
 test/rust/call_and_return_val.rs | 12 ++++++
 2 files changed, 62 insertions(+), 18 deletions(-)
 create mode 100644 test/rust/call_and_return_val.rs

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 3975b1fd..30a6f2f1 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -72,9 +72,11 @@ impl X86Clobbers {
         ty_size: u64,
         ty_align: u64,
     ) {
+        println!("mark_used({val}): stack width is {stack_width}, type layout is (size={ty_size}, align={ty_align})");
         if let Some(Pair(_, pos)) = self.clobbered_at.remove(&val) {
+            println!("Clobbered at: {pos}");
             let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
-            *stack_width = (*stack_width + align_minus1) & align_minus1;
+            *stack_width = (*stack_width + align_minus1) & !align_minus1;
             let offset = -*stack_width;
             *stack_width += i32::try_from(ty_size).unwrap();
             assign
@@ -83,6 +85,7 @@ impl X86Clobbers {
         }
     }
     pub fn mark_clobbered(&mut self, reg: X86Register, which: usize, for_val: Option<u32>) {
+        println!("mark_clobbered({reg:?})");
         if let Some(Pair(_, val)) = self.reg_owners.remove(&reg) {
             if for_val == Some(val) {
                 self.reg_owners.insert(reg, val);
@@ -191,6 +194,7 @@ impl X86Machine {
         if dest == src {
             return;
         }
+        println!("write_move({dest:?}, {src:?})");
         match (dest, src) {
             (X86ValLocation::Null, X86ValLocation::Null)
             | (X86ValLocation::Null, X86ValLocation::StackDisp(_))
@@ -260,6 +264,13 @@ impl X86Machine {
             }
         }
     }
+
+    fn real_stack_width(assignments: &X86Assignments) -> i32 {
+        (assignments.stack_width
+            + ((8 & (assignments.stack_align - 1)) as i32)
+            + (assignments.stack_align as i32 - 1))
+            & !(assignments.stack_align - 1) as i32
+    }
 }
 
 impl MceWriter for X86Machine {
@@ -343,7 +354,7 @@ impl Machine<SsaInstruction> for X86Machine {
             available_int_registers: int_registers,
             return_reg: None,
             stack_width: 0,
-            stack_align: 16,
+            stack_align: 1,
             assigns: HashMap::new(),
         }
     }
@@ -373,12 +384,12 @@ impl Machine<SsaInstruction> for X86Machine {
                 }
             }
         }
+        println!("Reg Owners: {:?}", clobbers.reg_owners);
+        println!("Which bb: {which}");
         for (num, insn) in insns.iter().enumerate() {
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
-                    eprintln!("Current width {:?}", assignments.stack_width);
-                    assignments.stack_width = ((assignments.stack_width + 7) & !15) + 8;
-                    eprintln!("Aligned width width {:?}", assignments.stack_width);
+                    assignments.stack_align = assignments.stack_align.max(16);
 
                     let callconv = X86CallConvInfo {
                         mode: assignments.mode,
@@ -414,6 +425,11 @@ impl Machine<SsaInstruction> for X86Machine {
                                     })
                                     .change_owner
                                     .push((num, X86ValLocation::Register(*reg)));
+
+                                eprintln!(
+                                    "Param Location: {loc:?} (assigns {:?})",
+                                    assignments.assigns[&loc.num]
+                                );
                             }
                             loc => todo!("{:?}", loc),
                         }
@@ -453,8 +469,6 @@ impl Machine<SsaInstruction> for X86Machine {
                 | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
-                    eprintln!("{:?}", foreign_locs);
-
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
                         match (
                             assignments
@@ -473,6 +487,7 @@ impl Machine<SsaInstruction> for X86Machine {
                                     ty_size,
                                     ty_align,
                                 );
+
                                 old.change_owner.push((num, foreign));
                             }
                             (Some(foreign), None) => {
@@ -486,11 +501,6 @@ impl Machine<SsaInstruction> for X86Machine {
                                 );
                             }
                             (None, Some(old)) => {
-                                let incoming = old
-                                    .change_owner
-                                    .last()
-                                    .map_or(&old.foreign_location, |(_, x)| x)
-                                    .clone();
                                 let ty_size = tys.type_size(&old_loc.ty).unwrap();
                                 let ty_align = tys.type_align(&old_loc.ty).unwrap();
                                 clobbers.mark_used(
@@ -500,6 +510,17 @@ impl Machine<SsaInstruction> for X86Machine {
                                     ty_size,
                                     ty_align,
                                 );
+                                let incoming = old
+                                    .change_owner
+                                    .last()
+                                    .map_or(&old.foreign_location, |(_, x)| x)
+                                    .clone();
+
+                                println!("{old_loc}: {:?}", old.change_owner);
+
+                                println!("{old_loc}=>{new_loc}: {incoming:?}");
+
+                                println!("{old_loc}: {old:?}");
 
                                 assignments.assigns.insert(
                                     new_loc.num,
@@ -594,7 +615,7 @@ impl Machine<SsaInstruction> for X86Machine {
         &self,
         assignments: &Self::Assignments,
         ssa_insns: &[xlang_backend::ssa::SsaInstruction],
-        block_clobbers: Self::BlockClobbers,
+        _: Self::BlockClobbers,
         label_sym: F,
         which: u32,
         tys: &TypeInformation,
@@ -611,8 +632,12 @@ impl Machine<SsaInstruction> for X86Machine {
                 if loc.owning_bb == which {
                     for (at, new_loc) in &loc.change_owner {
                         if *at == num {
+                            println!(
+                                "Moving {addr} to {new_loc:?} from {:?}",
+                                &cur_locations[addr]
+                            );
                             self.write_move(&mut insns, new_loc, &cur_locations[addr], assignments);
-                            break;
+                            *cur_locations.get_mut(addr).unwrap() = new_loc.clone();
                         }
                     }
                 }
@@ -639,12 +664,13 @@ impl Machine<SsaInstruction> for X86Machine {
                 }
                 xlang_backend::ssa::SsaInstruction::Fallthrough(_, _) => {}
                 xlang_backend::ssa::SsaInstruction::Exit(val) => {
-                    if assignments.stack_width > 0 {
+                    let real_stack_width = Self::real_stack_width(assignments);
+                    if real_stack_width > 0 {
                         insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                             X86CodegenOpcode::Add,
                             std_vec![
                                 X86Operand::Register(assignments.sp),
-                                X86Operand::Immediate(assignments.stack_width as i64),
+                                X86Operand::Immediate(real_stack_width as i64 - 8),
                             ],
                         )));
                     }
@@ -745,13 +771,19 @@ impl Machine<SsaInstruction> for X86Machine {
         &self,
         assignments: &Self::Assignments,
     ) -> Vec<MceInstruction<X86Instruction>> {
+        println!(
+            "Stack width: {} (align={})",
+            assignments.stack_width, assignments.stack_align
+        );
+        let real_stack_width = Self::real_stack_width(assignments);
+        println!("Real stack Width: {real_stack_width}");
         let mut insns = Vec::new();
-        if assignments.stack_width != 0 {
+        if real_stack_width != 0 {
             insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                 X86CodegenOpcode::Sub,
                 std_vec![
                     X86Operand::Register(assignments.sp),
-                    X86Operand::Immediate(assignments.stack_width as i64),
+                    X86Operand::Immediate((real_stack_width as i64).saturating_sub(8)),
                 ],
             )));
         }
diff --git a/test/rust/call_and_return_val.rs b/test/rust/call_and_return_val.rs
new file mode 100644
index 00000000..d21876e7
--- /dev/null
+++ b/test/rust/call_and_return_val.rs
@@ -0,0 +1,12 @@
+extern "C" {
+    fn puts(x: i32);
+}
+
+pub fn foo(x: i32) -> i32 {
+    unsafe {
+        puts(x);
+    }
+    x
+}
+
+fn main() {}

From 2db74a9ba3b3786dae3d3d863b85118752fc4d92 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 00:27:48 -0400
Subject: [PATCH 58/74] fix(codegen-x86): Don't reload wrong values

---
 codegen-x86/src/lib.rs | 65 ++++++++++++++++++++++++++++++++++++------
 test/rust/aaaa.rs      |  2 ++
 2 files changed, 58 insertions(+), 9 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 30a6f2f1..2dedc569 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -42,6 +42,8 @@ pub struct LocationAssignment {
     foreign_location: X86ValLocation,
     owning_bb: u32,
     change_owner: Vec<(usize, X86ValLocation)>,
+    size: u64,
+    stack_slot: Option<i32>,
 }
 
 pub struct X86Machine {
@@ -74,11 +76,14 @@ impl X86Clobbers {
     ) {
         println!("mark_used({val}): stack width is {stack_width}, type layout is (size={ty_size}, align={ty_align})");
         if let Some(Pair(_, pos)) = self.clobbered_at.remove(&val) {
-            println!("Clobbered at: {pos}");
-            let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
-            *stack_width = (*stack_width + align_minus1) & !align_minus1;
-            let offset = -*stack_width;
-            *stack_width += i32::try_from(ty_size).unwrap();
+            let offset = *assign.stack_slot.get_or_insert_with(|| {
+                let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
+                *stack_width = (*stack_width + align_minus1) & !align_minus1;
+                let offset = -*stack_width;
+                *stack_width += i32::try_from(ty_size).unwrap();
+                offset
+            });
+
             assign
                 .change_owner
                 .push((pos, X86ValLocation::StackDisp(offset)));
@@ -190,6 +195,7 @@ impl X86Machine {
         dest: &X86ValLocation,
         src: &X86ValLocation,
         assigns: &X86Assignments,
+        override_mode: Option<X86RegisterClass>,
     ) {
         if dest == src {
             return;
@@ -218,6 +224,9 @@ impl X86Machine {
                 }
             }
             (X86ValLocation::StackDisp(off), X86ValLocation::Register(reg)) => {
+                let reg = override_mode
+                    .and_then(|r| X86Register::from_class(r, reg.regnum()))
+                    .unwrap_or(*reg);
                 let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
@@ -232,18 +241,21 @@ impl X86Machine {
                                 disp: Some(arch_ops::x86::codegen::X86Displacement::Offset(*off)),
                             },
                         ),
-                        X86Operand::Register(*reg),
+                        X86Operand::Register(reg),
                     ],
                 )));
             }
             (X86ValLocation::Register(reg), X86ValLocation::StackDisp(off)) => {
+                let reg = override_mode
+                    .and_then(|r| X86Register::from_class(r, reg.regnum()))
+                    .unwrap_or(*reg);
                 let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
                 insns.push(MceInstruction::BaseInsn(X86Instruction::new(
                     opcode,
                     std_vec![
-                        X86Operand::Register(*reg),
+                        X86Operand::Register(reg),
                         X86Operand::Memory(
                             reg.class(),
                             None,
@@ -400,6 +412,7 @@ impl Machine<SsaInstruction> for X86Machine {
                     // TODO: Clobber non-saved registers
 
                     for (loc, call_loc) in locations.params.iter().zip(callconv.params()) {
+                        let size = tys.type_size(&loc.ty).unwrap();
                         match call_loc {
                             CallConvLocation::Null => {}
                             CallConvLocation::Register(reg) => {
@@ -422,10 +435,14 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: X86ValLocation::Register(*reg),
                                         owning_bb: which,
                                         change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
                                     })
                                     .change_owner
                                     .push((num, X86ValLocation::Register(*reg)));
 
+                                clobbers.reg_owners.insert(*reg, loc.num);
+
                                 eprintln!(
                                     "Param Location: {loc:?} (assigns {:?})",
                                     assignments.assigns[&loc.num]
@@ -440,6 +457,7 @@ impl Machine<SsaInstruction> for X86Machine {
                     }
 
                     if let Some(ret) = &locations.ret {
+                        let size = tys.type_size(&ret.ty).unwrap();
                         match callconv.ret_location() {
                             CallConvLocation::Null => {
                                 assignments.assigns.insert(
@@ -448,6 +466,8 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: X86ValLocation::Null,
                                         owning_bb: which,
                                         change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
                                     },
                                 );
                             }
@@ -458,6 +478,8 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: X86ValLocation::Register(*reg),
                                         owning_bb: which,
                                         change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
                                     },
                                 );
                             }
@@ -470,6 +492,7 @@ impl Machine<SsaInstruction> for X86Machine {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
+                        let size = tys.type_size(&old_loc.ty).unwrap();
                         match (
                             assignments
                                 .assigns
@@ -497,6 +520,8 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: foreign,
                                         owning_bb: which,
                                         change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
                                     },
                                 );
                             }
@@ -521,13 +546,15 @@ impl Machine<SsaInstruction> for X86Machine {
                                 println!("{old_loc}=>{new_loc}: {incoming:?}");
 
                                 println!("{old_loc}: {old:?}");
-
+                                let old_slot = old.stack_slot;
                                 assignments.assigns.insert(
                                     new_loc.num,
                                     LocationAssignment {
                                         foreign_location: incoming,
                                         owning_bb: *targ,
                                         change_owner: vec![],
+                                        size,
+                                        stack_slot: old_slot,
                                     },
                                 );
                             }
@@ -538,6 +565,7 @@ impl Machine<SsaInstruction> for X86Machine {
                 xlang_backend::ssa::SsaInstruction::Exit(val) => match &**val {
                     [] => {}
                     [retval] => {
+                        let size = tys.type_size(&retval.ty).unwrap();
                         let reg = assignments.return_reg;
                         if let Some(reg) = reg {
                             let ty_size = tys.type_size(&retval.ty).unwrap();
@@ -559,6 +587,8 @@ impl Machine<SsaInstruction> for X86Machine {
                                     foreign_location: loc.clone(),
                                     owning_bb: which,
                                     change_owner: vec![],
+                                    size,
+                                    stack_slot: None,
                                 })
                                 .change_owner
                                 .push((num, loc));
@@ -594,6 +624,8 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: X86ValLocation::Register(*reg),
                                         owning_bb: which,
                                         change_owner: vec![],
+                                        size: ty_size,
+                                        stack_slot: None,
                                     })
                                     .change_owner
                                     .push((num, X86ValLocation::Register(*reg)));
@@ -632,11 +664,23 @@ impl Machine<SsaInstruction> for X86Machine {
                 if loc.owning_bb == which {
                     for (at, new_loc) in &loc.change_owner {
                         if *at == num {
+                            let size = loc.size;
+                            let over = if (size <= 8) && size.is_power_of_two() {
+                                X86RegisterClass::gpr_size(size as usize, assignments.mode)
+                            } else {
+                                None
+                            };
                             println!(
                                 "Moving {addr} to {new_loc:?} from {:?}",
                                 &cur_locations[addr]
                             );
-                            self.write_move(&mut insns, new_loc, &cur_locations[addr], assignments);
+                            self.write_move(
+                                &mut insns,
+                                new_loc,
+                                &cur_locations[addr],
+                                assignments,
+                                over,
+                            );
                             *cur_locations.get_mut(addr).unwrap() = new_loc.clone();
                         }
                     }
@@ -805,6 +849,7 @@ impl Machine<SsaInstruction> for X86Machine {
         let callconv = compute_call_conv(&callconv, fnty, fnty, tys);
 
         for (param, incoming) in callconv.params().iter().zip(incoming) {
+            let size = tys.type_size(&incoming.ty).unwrap();
             let loc = match param {
                 CallConvLocation::Null => X86ValLocation::Null,
                 CallConvLocation::Register(reg) => X86ValLocation::Register(*reg),
@@ -815,6 +860,8 @@ impl Machine<SsaInstruction> for X86Machine {
                 foreign_location: loc,
                 change_owner: vec![],
                 owning_bb: which,
+                size,
+                stack_slot: None,
             };
 
             assignments.assigns.insert(incoming.num, assignment);
diff --git a/test/rust/aaaa.rs b/test/rust/aaaa.rs
index 64ac7b18..f1dd6605 100644
--- a/test/rust/aaaa.rs
+++ b/test/rust/aaaa.rs
@@ -1,5 +1,6 @@
 extern "C" {
     fn putchar(x: i32) -> i32;
+    fn puts(c: *mut u8) -> i32;
 }
 
 fn uh_oh(x: i32) {
@@ -8,6 +9,7 @@ fn uh_oh(x: i32) {
         putchar(x);
         putchar(x);
         putchar(x);
+        puts(b"\0" as *mut u8);
     }
 }
 

From effd4ffe74e2380a77674c10fc959e178de90bea Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 14:09:03 -0400
Subject: [PATCH 59/74] feat(xlang-blackend): Support branch

---
 codegen-x86/src/lib.rs          |   6 +-
 xlang/xlang_backend/src/expr.rs |  34 +++---
 xlang/xlang_backend/src/ssa.rs  | 202 +++++++++++++++++++++++++++++++-
 xlang/xlang_struct/src/lib.rs   |  15 +++
 4 files changed, 232 insertions(+), 25 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 2dedc569..c3760104 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -488,7 +488,9 @@ impl Machine<SsaInstruction> for X86Machine {
                     }
                 }
                 xlang_backend::ssa::SsaInstruction::Jump(targ, old_locs)
-                | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
+                | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs)
+                | SsaInstruction::Branch(_, _, _, targ, old_locs)
+                | SsaInstruction::BranchZero(_, _, targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
@@ -805,6 +807,8 @@ impl Machine<SsaInstruction> for X86Machine {
                         }
                     }
                 }
+                SsaInstruction::Branch(_, _, _, _, _) => todo!("branch"),
+                SsaInstruction::BranchZero(_, _, _, _) => todo!("branch"),
             }
         }
 
diff --git a/xlang/xlang_backend/src/expr.rs b/xlang/xlang_backend/src/expr.rs
index 2a626f09..48057a5c 100644
--- a/xlang/xlang_backend/src/expr.rs
+++ b/xlang/xlang_backend/src/expr.rs
@@ -1,6 +1,6 @@
 use xlang::{
-    abi::{collection::HashMap, option::None as XLangNone, pair::Pair},
-    ir::{ArrayType, Path, PointerType, ScalarType, ScalarTypeHeader, ScalarTypeKind, Type, Value},
+    abi::{collection::HashMap, pair::Pair},
+    ir::{ArrayType, CompareOp, Path, PointerType, ScalarType, Type, Value},
 };
 
 use core::{fmt::Debug, hash::Hash};
@@ -10,6 +10,9 @@ use std::num::NonZeroU128;
 pub trait ValLocation: Eq + Debug + Clone {
     /// Checks if this location is addressable (is not a register)
     fn addressible(&self) -> bool;
+
+    /// Returns the type of the value location
+    fn val_type(&self) -> &Type;
 }
 
 /// The pointee of a pointer
@@ -72,7 +75,7 @@ pub enum VStackValue<Loc: ValLocation> {
     OpaqueAggregate(Type, Loc),
 
     /// The result of the `cmp` instruction
-    CompareResult(Box<VStackValue<Loc>>, Box<VStackValue<Loc>>),
+    CompareResult(CompareOp, ScalarType, Loc, Loc),
 
     /// Placeholder for a value that's already caused a [`Trap`]
     Trapped,
@@ -108,8 +111,8 @@ impl<Loc: ValLocation> core::fmt::Display for VStackValue<Loc> {
             VStackValue::OpaqueAggregate(ty, loc) => {
                 f.write_fmt(format_args!("{} (opaque({:?}))", ty, loc))
             }
-            VStackValue::CompareResult(l, r) => {
-                f.write_fmt(format_args!("cmp result ({},{})", l, r))
+            VStackValue::CompareResult(op, ty, l, r) => {
+                f.write_fmt(format_args!("{} result ({:?},{:?}): {}", op, l, r, ty))
             }
             VStackValue::Trapped => f.write_str("trapped"),
             VStackValue::ArrayRepeat(value, count) => {
@@ -178,17 +181,7 @@ impl<Loc: ValLocation> VStackValue<Loc> {
             VStackValue::OpaqueScalar(scalar, _) => Type::Scalar(*scalar),
             VStackValue::AggregatePieced(ty, _) => ty.clone(),
             VStackValue::OpaqueAggregate(ty, _) => ty.clone(),
-            VStackValue::CompareResult(_, _) => Type::Scalar(ScalarType {
-                header: ScalarTypeHeader {
-                    bitsize: 32,
-                    ..Default::default()
-                },
-                kind: ScalarTypeKind::Integer {
-                    signed: false,
-                    min: XLangNone,
-                    max: XLangNone,
-                },
-            }),
+            VStackValue::CompareResult(_, sty, _, _) => Type::Scalar(*sty),
             VStackValue::Trapped => Type::Null,
             VStackValue::ArrayRepeat(val, len) => {
                 Type::Array(xlang::abi::boxed::Box::new(ArrayType {
@@ -232,6 +225,10 @@ impl ValLocation for NoOpaque {
     fn addressible(&self) -> bool {
         match *self {}
     }
+
+    fn val_type(&self) -> &Type {
+        match *self {}
+    }
 }
 
 impl VStackValue<NoOpaque> {
@@ -251,10 +248,7 @@ impl VStackValue<NoOpaque> {
                     .collect(),
             ),
             VStackValue::OpaqueAggregate(_, loc) => match loc {},
-            VStackValue::CompareResult(left, right) => VStackValue::CompareResult(
-                Box::new((*left).into_transparent_for()),
-                Box::new((*right).into_transparent_for()),
-            ),
+            VStackValue::CompareResult(_, _, left, _) => match left {},
             VStackValue::Trapped => VStackValue::Trapped,
             VStackValue::ArrayRepeat(val, count) => {
                 VStackValue::ArrayRepeat(Box::new((*val).into_transparent_for()), count)
diff --git a/xlang/xlang_backend/src/ssa.rs b/xlang/xlang_backend/src/ssa.rs
index 75138e7f..7d003a51 100644
--- a/xlang/xlang_backend/src/ssa.rs
+++ b/xlang/xlang_backend/src/ssa.rs
@@ -12,6 +12,9 @@ use crate::str::StringMap;
 
 use arch_ops::traits::Address;
 use xlang::abi::pair::Pair;
+use xlang::ir::BranchCondition;
+use xlang::ir::CompareOp;
+use xlang::ir::JumpTargetFlags;
 use xlang::{ir::JumpTarget, targets::properties::TargetProperties};
 
 use xlang::ir;
@@ -65,6 +68,16 @@ pub enum SsaInstruction {
     LoadSymAddr(OpaqueLocation, Address),
     /// Initializes a (potentially large) memory location with zeroes
     ZeroInit(OpaqueLocation),
+    /// Conditionally branches to the destination basic block if the comparison is satisfied.
+    Branch(
+        BranchCondition,
+        OpaqueLocation,
+        OpaqueLocation,
+        u32,
+        Vec<OpaqueLocation>,
+    ),
+    /// Conditionally branches to the destination basic block if the comparison with the value `0` is satisfied.
+    BranchZero(BranchCondition, OpaqueLocation, u32, Vec<OpaqueLocation>),
 }
 
 impl core::fmt::Display for SsaInstruction {
@@ -133,6 +146,26 @@ impl core::fmt::Display for SsaInstruction {
                 f.write_fmt(format_args!("loadsymaddr {}, {}", dest, addr))
             }
             SsaInstruction::ZeroInit(dest) => f.write_fmt(format_args!("zeroinit {}", dest)),
+            SsaInstruction::Branch(op, l, r, dest, stack) => {
+                f.write_fmt(format_args!("branch {op} ({l}, {r}) @{dest} ["))?;
+                let mut sep = "";
+                for item in stack {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str("]")
+            }
+            SsaInstruction::BranchZero(op, l, dest, stack) => {
+                f.write_fmt(format_args!("branch {op} ({l}, 0) @{dest} ["))?;
+                let mut sep = "";
+                for item in stack {
+                    f.write_str(sep)?;
+                    sep = ", ";
+                    item.fmt(f)?;
+                }
+                f.write_str("]")
+            }
         }
     }
 }
@@ -200,6 +233,10 @@ impl ValLocation for OpaqueLocation {
     fn addressible(&self) -> bool {
         self.has_addr
     }
+
+    fn val_type(&self) -> &ir::Type {
+        &self.ty
+    }
 }
 
 /// A builder that can convert [`ir::FunctionBody`]s into Machine code, lowering through [`SsaInstruction`]s.
@@ -444,7 +481,7 @@ impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
                 }
             }
             VStackValue::OpaqueAggregate(_, _) => todo!(),
-            VStackValue::CompareResult(_, _) => todo!(),
+            VStackValue::CompareResult(_, _, _, _) => todo!(),
             VStackValue::Trapped => todo!(),
             VStackValue::ArrayRepeat(_, _) => todo!(),
         }
@@ -511,6 +548,24 @@ impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
         ret
     }
 
+    /// Pops `N` values as opaque locations from the basic block's eval stack and returns them as a vector, moving them into a new [`OpaqueLocation`] if necessary.
+    ///
+    /// This provides better destructuring when the number of values is known.
+    pub fn pop_opaque_static<const N: usize>(&mut self) -> [OpaqueLocation; N] {
+        use core::mem::MaybeUninit;
+        let mut val = MaybeUninit::<[_; N]>::uninit();
+        let mut ptr = val.as_mut_ptr().cast::<OpaqueLocation>();
+        let mut vstack = core::mem::take(&mut self.vstack);
+
+        for val in vstack.drain_back(N) {
+            unsafe { ptr.write(self.make_opaque(val)) };
+            ptr = unsafe { ptr.add(1) };
+        }
+        self.vstack = vstack;
+        // SAFETY: We just initialized all `N` elements
+        unsafe { val.assume_init() }
+    }
+
     /// Returns the [`OpaqueLocation`] currently storing the specified [`VStackValue`], if any,
     ///  or otherwise allocates a new [`OpaqueLocation`] and moves `val` into it as though by [`BasicBlockBuilder::move_into`]
     pub fn make_opaque(&mut self, val: VStackValue<OpaqueLocation>) -> OpaqueLocation {
@@ -614,7 +669,7 @@ impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
             VStackValue::OpaqueScalar(_, _) => todo!(),
             VStackValue::AggregatePieced(_, _) => todo!(),
             VStackValue::OpaqueAggregate(_, _) => todo!(),
-            VStackValue::CompareResult(_, _) => todo!(),
+            VStackValue::CompareResult(_, _, _, _) => todo!(),
             VStackValue::Trapped => todo!(),
             VStackValue::ArrayRepeat(_, _) => todo!(),
         }
@@ -767,7 +822,11 @@ impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
             ir::Expr::BeginStorage(_) => todo!("begin storage"),
             ir::Expr::EndStorage(_) => todo!("end storage"),
             ir::Expr::Select(_) => todo!("select"),
-            ir::Expr::CompareOp(_, _) => todo!("compare op"),
+            ir::Expr::CompareOp(op, sty) => {
+                let [val1, val2] = self.pop_opaque_static();
+
+                self.push(VStackValue::CompareResult(*op, *sty, val1, val2));
+            }
         }
     }
 
@@ -783,7 +842,142 @@ impl<M: Machine<SsaInstruction>> BasicBlockBuilder<M> {
             ir::Terminator::Jump(targ) => {
                 self.write_jump(targ, core::iter::empty());
             }
-            ir::Terminator::Branch(_, _, _) => todo!("branch"),
+            ir::Terminator::Branch(cond, targ1, targ2) => {
+                let cond_val = self.pop();
+
+                let (real_cond, val1, val2) = match (cond_val, cond) {
+                    (_, cond @ (BranchCondition::Always | BranchCondition::Never)) => {
+                        (*cond, None, None)
+                    }
+                    (VStackValue::CompareResult(CompareOp::Cmp, _, l, r), cond) => {
+                        (*cond, Some(l), Some(r))
+                    }
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpEq, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpNe, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::NotEqual, Some(l), Some(r)),
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpNe, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpEq, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::NotEqual, Some(l), Some(r)),
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpLt, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpGe, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::Less, Some(l), Some(r)),
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpLe, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpGt, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::LessEqual, Some(l), Some(r)),
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpGt, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpLe, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::Greater, Some(l), Some(r)),
+                    (
+                        VStackValue::CompareResult(CompareOp::CmpGe, _, l, r),
+                        BranchCondition::NotEqual,
+                    )
+                    | (
+                        VStackValue::CompareResult(CompareOp::CmpLt, _, l, r),
+                        BranchCondition::Equal,
+                    ) => (BranchCondition::GreaterEqual, Some(l), Some(r)),
+                    (val, cond) => {
+                        let loc = self.make_opaque(val);
+                        (*cond, Some(loc), None)
+                    }
+                };
+
+                let top_values_count =
+                    self.incoming_count[&targ1.target].min(self.incoming_count[&targ2.target]);
+
+                let targ1_skip = top_values_count - self.incoming_count[&targ1.target];
+                let targ2_skip = top_values_count - self.incoming_count[&targ2.target];
+
+                let top_values = self.pop_opaque(top_values_count);
+
+                match real_cond {
+                    BranchCondition::Always => {
+                        self.write_jump(targ1, top_values.into_iter().skip(targ1_skip));
+                    }
+                    BranchCondition::Never => {
+                        self.write_jump(targ2, top_values.into_iter().skip(targ2_skip));
+                    }
+                    cond => {
+                        if targ1.flags.contains(JumpTargetFlags::FALLTHROUGH)
+                            && targ2.flags.contains(JumpTargetFlags::FALLTHROUGH)
+                        {
+                            // Branches must be the same, fallthrough to take your pick of target
+                            self.write_jump(targ1, top_values.into_iter().skip(targ1_skip))
+                        } else if targ1.flags.contains(JumpTargetFlags::FALLTHROUGH)
+                            || targ2.flags.contains(JumpTargetFlags::COLD)
+                        {
+                            let cond = cond.invert();
+                            let targ2_vals = top_values.iter().skip(targ2_skip).cloned().collect();
+
+                            match (val1, val2) {
+                                (Some(l), Some(r)) => self.insns.push(SsaInstruction::Branch(
+                                    cond,
+                                    l,
+                                    r,
+                                    targ2.target,
+                                    targ2_vals,
+                                )),
+                                (Some(l), None) => self.insns.push(SsaInstruction::BranchZero(
+                                    cond,
+                                    l,
+                                    targ2.target,
+                                    targ2_vals,
+                                )),
+                                (None, _) => unreachable!(
+                                    "Left compare val always provided for non-trivial conditions"
+                                ),
+                            }
+                            self.write_jump(&targ1, top_values.into_iter().skip(targ1_skip));
+                        } else {
+                            let targ1_vals = top_values.iter().skip(targ1_skip).cloned().collect();
+
+                            match (val1, val2) {
+                                (Some(l), Some(r)) => self.insns.push(SsaInstruction::Branch(
+                                    cond,
+                                    l,
+                                    r,
+                                    targ1.target,
+                                    targ1_vals,
+                                )),
+                                (Some(l), None) => self.insns.push(SsaInstruction::BranchZero(
+                                    cond,
+                                    l,
+                                    targ1.target,
+                                    targ1_vals,
+                                )),
+                                (None, _) => unreachable!(
+                                    "Left compare val always provided for non-trivial conditions"
+                                ),
+                            }
+                            self.write_jump(&targ2, top_values.into_iter().skip(targ1_skip));
+                        }
+                    }
+                }
+            }
             ir::Terminator::BranchIndirect => todo!("branch indirect"),
             ir::Terminator::Call(_, call_fnty, next) => {
                 let params_count = call_fnty.params.len();
diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index 03e899d6..d9e250a8 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -1730,6 +1730,21 @@ pub enum BranchCondition {
     Never,
 }
 
+impl BranchCondition {
+    pub const fn invert(self) -> BranchCondition {
+        match self {
+            Self::Always => Self::Never,
+            Self::Less => Self::GreaterEqual,
+            Self::LessEqual => Self::Greater,
+            Self::Equal => Self::NotEqual,
+            Self::NotEqual => Self::Equal,
+            Self::Greater => Self::LessEqual,
+            Self::GreaterEqual => Self::Less,
+            Self::Never => Self::Always,
+        }
+    }
+}
+
 impl core::fmt::Display for BranchCondition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

From 326dcc0bdae218619b57be1a53d1b21652a5a218 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 14:09:38 -0400
Subject: [PATCH 60/74] fix(rust-mir): Don't emit jumps out of divergent
 blocks.

---
 rust/src/sema/mir.rs | 58 +++++++++++++++++++++++++-------------------
 test/rust/if_else.rs | 16 ++++++------
 2 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index 5fd9d060..d9e1ece0 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -1320,33 +1320,41 @@ impl<'a> MirConverter<'a> {
 
                 let (mut muljmps, assigns, incoming) =
                     self.make_many_jumps(&[if_assigns, else_assigns], nextbb);
-
-                let (ifinitstats, ifjmp) = core::mem::take(&mut muljmps[0]);
-                if_end_block
-                    .stmts
-                    .extend(ifinitstats.into_iter().map(|stmt| Spanned {
-                        body: stmt,
-                        span: thir_block.span,
-                    }));
-                self.basic_blocks.push(if_end_block.finish(Spanned {
-                    body: MirTerminator::Jump(ifjmp),
-                    span: thir_block.span,
-                }));
-                let (elseinitstats, elsejmp) = core::mem::take(&mut muljmps[1]);
-                self.cur_basic_block
-                    .stmts
-                    .extend(elseinitstats.into_iter().map(|stmt| Spanned {
-                        body: stmt,
-                        span: thir_block.span,
-                    }));
-                self.basic_blocks
-                    .push(self.cur_basic_block.finish_and_reset(Spanned {
-                        body: MirTerminator::Jump(elsejmp),
+                let mut diverges = true;
+                if if_end_block.id != BasicBlockId::UNUSED {
+                    let (ifinitstats, ifjmp) = core::mem::take(&mut muljmps[0]);
+                    if_end_block
+                        .stmts
+                        .extend(ifinitstats.into_iter().map(|stmt| Spanned {
+                            body: stmt,
+                            span: thir_block.span,
+                        }));
+                    self.basic_blocks.push(if_end_block.finish(Spanned {
+                        body: MirTerminator::Jump(ifjmp),
                         span: thir_block.span,
                     }));
-                self.cur_basic_block.id = nextbb;
-                self.cur_basic_block.incoming_vars = incoming;
-                self.var_names = assigns;
+                    diverges = false;
+                }
+                if self.cur_basic_block.id != BasicBlockId::UNUSED {
+                    let (elseinitstats, elsejmp) = core::mem::take(&mut muljmps[1]);
+                    self.cur_basic_block
+                        .stmts
+                        .extend(elseinitstats.into_iter().map(|stmt| Spanned {
+                            body: stmt,
+                            span: thir_block.span,
+                        }));
+                    self.basic_blocks
+                        .push(self.cur_basic_block.finish_and_reset(Spanned {
+                            body: MirTerminator::Jump(elsejmp),
+                            span: thir_block.span,
+                        }));
+                    diverges = false;
+                }
+                if !diverges {
+                    self.cur_basic_block.id = nextbb;
+                    self.cur_basic_block.incoming_vars = incoming;
+                    self.var_names = assigns;
+                }
             }
             super::tyck::ThirBlock::Match(m) => {
                 let ty = m.discriminee.ty.clone();
diff --git a/test/rust/if_else.rs b/test/rust/if_else.rs
index 23427226..d097f73a 100644
--- a/test/rust/if_else.rs
+++ b/test/rust/if_else.rs
@@ -10,17 +10,17 @@ pub fn test_number(x: i32) {
     } else {
         puts(b"Number is zero\0" as *const u8);
     }
-    puts(if x & 1 == 0 {
-        b"Number is even\0" as *const u8
-    } else {
-        b"Number is odd\0" as *const u8
-    });
+    // puts(if x & 1 == 0 {
+    //     b"Number is even\0" as *const u8
+    // } else {
+    //     b"Number is odd\0" as *const u8
+    // });
 }
 
 fn main() {
-    test_number(-256);
-    test_number(-1);
-    test_number(-0); // should still be 0
+    // test_number(-256);
+    // test_number(-1);
+    // test_number(-0); // should still be 0
     test_number(0);
     test_number(1);
     test_number(256);

From 7253a6668605fdab1ff6231316fba8811dbd0133 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 14:14:11 -0400
Subject: [PATCH 61/74] feat(rust-mir): Skip generating code for blocks after
 diverging

---
 rust/src/sema/mir.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
index d9e1ece0..ac75c256 100644
--- a/rust/src/sema/mir.rs
+++ b/rust/src/sema/mir.rs
@@ -1210,6 +1210,9 @@ impl<'a> MirConverter<'a> {
     }
 
     pub fn write_block(&mut self, thir_block: Spanned<ThirBlock>) -> super::Result<()> {
+        if self.cur_basic_block.id == BasicBlockId::UNUSED {
+            return Ok(());
+        }
         match thir_block.body {
             super::tyck::ThirBlock::Normal(stmts) | super::tyck::ThirBlock::Unsafe(stmts) => {
                 let newbb = BasicBlockId(self.nextbb.fetch_increment());

From 33b7bbebb5d1015229881c633fe45e1e6a77916d Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 14:14:33 -0400
Subject: [PATCH 62/74] chore(x86-codegen): Remove println statements that are
 not longer required.

---
 codegen-x86/src/lib.rs | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index c3760104..23bc8bdf 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -74,7 +74,6 @@ impl X86Clobbers {
         ty_size: u64,
         ty_align: u64,
     ) {
-        println!("mark_used({val}): stack width is {stack_width}, type layout is (size={ty_size}, align={ty_align})");
         if let Some(Pair(_, pos)) = self.clobbered_at.remove(&val) {
             let offset = *assign.stack_slot.get_or_insert_with(|| {
                 let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
@@ -90,7 +89,6 @@ impl X86Clobbers {
         }
     }
     pub fn mark_clobbered(&mut self, reg: X86Register, which: usize, for_val: Option<u32>) {
-        println!("mark_clobbered({reg:?})");
         if let Some(Pair(_, val)) = self.reg_owners.remove(&reg) {
             if for_val == Some(val) {
                 self.reg_owners.insert(reg, val);
@@ -200,7 +198,6 @@ impl X86Machine {
         if dest == src {
             return;
         }
-        println!("write_move({dest:?}, {src:?})");
         match (dest, src) {
             (X86ValLocation::Null, X86ValLocation::Null)
             | (X86ValLocation::Null, X86ValLocation::StackDisp(_))
@@ -396,8 +393,6 @@ impl Machine<SsaInstruction> for X86Machine {
                 }
             }
         }
-        println!("Reg Owners: {:?}", clobbers.reg_owners);
-        println!("Which bb: {which}");
         for (num, insn) in insns.iter().enumerate() {
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
@@ -442,11 +437,6 @@ impl Machine<SsaInstruction> for X86Machine {
                                     .push((num, X86ValLocation::Register(*reg)));
 
                                 clobbers.reg_owners.insert(*reg, loc.num);
-
-                                eprintln!(
-                                    "Param Location: {loc:?} (assigns {:?})",
-                                    assignments.assigns[&loc.num]
-                                );
                             }
                             loc => todo!("{:?}", loc),
                         }
@@ -543,11 +533,6 @@ impl Machine<SsaInstruction> for X86Machine {
                                     .map_or(&old.foreign_location, |(_, x)| x)
                                     .clone();
 
-                                println!("{old_loc}: {:?}", old.change_owner);
-
-                                println!("{old_loc}=>{new_loc}: {incoming:?}");
-
-                                println!("{old_loc}: {old:?}");
                                 let old_slot = old.stack_slot;
                                 assignments.assigns.insert(
                                     new_loc.num,
@@ -672,10 +657,6 @@ impl Machine<SsaInstruction> for X86Machine {
                             } else {
                                 None
                             };
-                            println!(
-                                "Moving {addr} to {new_loc:?} from {:?}",
-                                &cur_locations[addr]
-                            );
                             self.write_move(
                                 &mut insns,
                                 new_loc,
@@ -819,12 +800,7 @@ impl Machine<SsaInstruction> for X86Machine {
         &self,
         assignments: &Self::Assignments,
     ) -> Vec<MceInstruction<X86Instruction>> {
-        println!(
-            "Stack width: {} (align={})",
-            assignments.stack_width, assignments.stack_align
-        );
         let real_stack_width = Self::real_stack_width(assignments);
-        println!("Real stack Width: {real_stack_width}");
         let mut insns = Vec::new();
         if real_stack_width != 0 {
             insns.push(MceInstruction::BaseInsn(X86Instruction::new(

From 3b20f5e4fae3463a587d34216a325ba81222641f Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sat, 29 Jun 2024 15:59:29 -0400
Subject: [PATCH 63/74] feat(x86-backend): Split assignment for branch from
 jump/fallthrough

---
 codegen-x86/src/lib.rs | 300 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 296 insertions(+), 4 deletions(-)

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index 23bc8bdf..f0bdf07e 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -2,6 +2,7 @@ use arch_ops::{
     traits::{Address, InsnWrite},
     x86::{
         codegen::{X86CodegenOpcode, X86Encoder, X86Instruction, X86MemoryOperand, X86Operand},
+        insn::X86Opcode,
         X86Mode, X86Register, X86RegisterClass,
     },
 };
@@ -27,6 +28,7 @@ use xlang_backend::{
     ty::TypeInformation,
     SsaCodegenPlugin,
 };
+use xlang_struct::BranchCondition;
 
 mod callconv;
 
@@ -132,6 +134,17 @@ fn xor_opcode(class: X86RegisterClass, hint_vec_is_int: bool) -> X86CodegenOpcod
     }
 }
 
+fn cmp_opcode(class: X86RegisterClass) -> X86CodegenOpcode {
+    match class {
+        X86RegisterClass::Xmm
+        | X86RegisterClass::Ymm
+        | X86RegisterClass::Zmm
+        | X86RegisterClass::St
+        | X86RegisterClass::Tmm => todo!("fp, vectors, and tiles"),
+        _ => X86CodegenOpcode::Cmp,
+    }
+}
+
 fn move_opcode(
     class: X86RegisterClass,
     align: Option<u64>,
@@ -187,6 +200,91 @@ fn move_opcode(
 }
 
 impl X86Machine {
+    pub fn write_cmp(
+        &self,
+        insns: &mut Vec<MceInstruction<X86Instruction>>,
+        src1: &X86ValLocation,
+        src2: &X86ValLocation,
+        cmp_op: BranchCondition,
+        assigns: &X86Assignments,
+        override_mode: Option<X86RegisterClass>,
+    ) {
+        match (src1, src2) {
+            (X86ValLocation::Null, X86ValLocation::Null)
+            | (X86ValLocation::Null, X86ValLocation::StackDisp(_))
+            | (X86ValLocation::StackDisp(_), X86ValLocation::Null) => {}
+            (X86ValLocation::Register(dest), X86ValLocation::Register(src)) => {
+                if dest.class() != src.class() {
+                    panic!("Cannot move between register classes")
+                }
+
+                match dest.class() {
+                    X86RegisterClass::St => todo!("fpreg"), // We need to do shenanigans to move between arbitrary st slots
+                    X86RegisterClass::Tmm => todo!("tmmreg"),
+                    X86RegisterClass::Xmm | X86RegisterClass::Ymm | X86RegisterClass::Zmm => {
+                        todo!("xmmreg")
+                    } // also need shenanigans for fp
+                    _ => {
+                        let opcode = cmp_opcode(dest.class());
+
+                        insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                            opcode,
+                            std_vec![X86Operand::Register(*dest), X86Operand::Register(*src)],
+                        )))
+                    }
+                }
+            }
+            (X86ValLocation::StackDisp(off), X86ValLocation::Register(reg)) => {
+                let reg = override_mode
+                    .and_then(|r| X86Register::from_class(r, reg.regnum()))
+                    .unwrap_or(*reg);
+                let opcode: X86CodegenOpcode = cmp_opcode(reg.class());
+
+                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                    opcode,
+                    std_vec![
+                        X86Operand::Memory(
+                            reg.class(),
+                            None,
+                            X86MemoryOperand::Indirect {
+                                reg: assigns.sp,
+                                disp: Some(arch_ops::x86::codegen::X86Displacement::Offset(*off)),
+                            },
+                        ),
+                        X86Operand::Register(reg),
+                    ],
+                )));
+            }
+            (X86ValLocation::Register(reg), X86ValLocation::StackDisp(off)) => {
+                let reg = override_mode
+                    .and_then(|r| X86Register::from_class(r, reg.regnum()))
+                    .unwrap_or(*reg);
+                let opcode: X86CodegenOpcode = cmp_opcode(reg.class());
+
+                insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                    opcode,
+                    std_vec![
+                        X86Operand::Register(reg),
+                        X86Operand::Memory(
+                            reg.class(),
+                            None,
+                            X86MemoryOperand::Indirect {
+                                reg: assigns.sp,
+                                disp: Some(arch_ops::x86::codegen::X86Displacement::Offset(*off)),
+                            },
+                        ),
+                    ],
+                )));
+            }
+            (X86ValLocation::Null, X86ValLocation::Register(_))
+            | (X86ValLocation::Register(_), X86ValLocation::Null) => {
+                panic!("Cannot move a register to/from null")
+            }
+            (X86ValLocation::StackDisp(_), X86ValLocation::StackDisp(_)) => {
+                todo!("memory to memory")
+            }
+        }
+    }
     pub fn write_move(
         &self,
         insns: &mut Vec<MceInstruction<X86Instruction>>,
@@ -477,10 +575,148 @@ impl Machine<SsaInstruction> for X86Machine {
                         }
                     }
                 }
+
+                SsaInstruction::Branch(_, l, r, targ, old_locs) => {
+                    let foreign_locs = &incoming_set[targ];
+
+                    for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
+                        let size = tys.type_size(&old_loc.ty).unwrap();
+                        match (
+                            assignments
+                                .assigns
+                                .get_mut(&new_loc.num)
+                                .map(|x| x.foreign_location.clone()),
+                            assignments.assigns.get_mut(&old_loc.num),
+                        ) {
+                            (Some(foreign), Some(old)) => {
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
+
+                                old.change_owner.push((num, foreign));
+                            }
+                            (Some(foreign), None) => {
+                                assignments.assigns.insert(
+                                    old_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: foreign,
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
+                                    },
+                                );
+                            }
+                            (None, Some(old)) => {
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
+                                let incoming = old
+                                    .change_owner
+                                    .last()
+                                    .map_or(&old.foreign_location, |(_, x)| x)
+                                    .clone();
+
+                                let old_slot = old.stack_slot;
+                                assignments.assigns.insert(
+                                    new_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: incoming,
+                                        owning_bb: *targ,
+                                        change_owner: vec![],
+                                        size,
+                                        stack_slot: old_slot,
+                                    },
+                                );
+                            }
+                            (None, None) => {}
+                        }
+                    }
+                }
+                SsaInstruction::BranchZero(_, l, targ, old_locs) => {
+                    let foreign_locs = &incoming_set[targ];
+
+                    for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
+                        let size = tys.type_size(&old_loc.ty).unwrap();
+                        match (
+                            assignments
+                                .assigns
+                                .get_mut(&new_loc.num)
+                                .map(|x| x.foreign_location.clone()),
+                            assignments.assigns.get_mut(&old_loc.num),
+                        ) {
+                            (Some(foreign), Some(old)) => {
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
+
+                                old.change_owner.push((num, foreign));
+                            }
+                            (Some(foreign), None) => {
+                                assignments.assigns.insert(
+                                    old_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: foreign,
+                                        owning_bb: which,
+                                        change_owner: vec![],
+                                        size,
+                                        stack_slot: None,
+                                    },
+                                );
+                            }
+                            (None, Some(old)) => {
+                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
+                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
+                                clobbers.mark_used(
+                                    old_loc.num,
+                                    old,
+                                    &mut assignments.stack_width,
+                                    ty_size,
+                                    ty_align,
+                                );
+                                let incoming = old
+                                    .change_owner
+                                    .last()
+                                    .map_or(&old.foreign_location, |(_, x)| x)
+                                    .clone();
+
+                                let old_slot = old.stack_slot;
+                                assignments.assigns.insert(
+                                    new_loc.num,
+                                    LocationAssignment {
+                                        foreign_location: incoming,
+                                        owning_bb: *targ,
+                                        change_owner: vec![],
+                                        size,
+                                        stack_slot: old_slot,
+                                    },
+                                );
+                            }
+                            (None, None) => {}
+                        }
+                    }
+                }
+
                 xlang_backend::ssa::SsaInstruction::Jump(targ, old_locs)
-                | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs)
-                | SsaInstruction::Branch(_, _, _, targ, old_locs)
-                | SsaInstruction::BranchZero(_, _, targ, old_locs) => {
+                | xlang_backend::ssa::SsaInstruction::Fallthrough(targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
@@ -788,7 +1024,63 @@ impl Machine<SsaInstruction> for X86Machine {
                         }
                     }
                 }
-                SsaInstruction::Branch(_, _, _, _, _) => todo!("branch"),
+                SsaInstruction::Branch(op, l, r, targ, vals) => {
+                    let jmp_insn = match (op, &*l.ty) {
+                        (BranchCondition::Equal, _) => X86CodegenOpcode::Jz,
+                        (BranchCondition::NotEqual, _) => X86CodegenOpcode::Jnz,
+                        (
+                            BranchCondition::Less,
+                            ir::Type::Scalar(ir::ScalarType {
+                                kind: ir::ScalarTypeKind::Integer { signed: false, .. },
+                                ..
+                            }),
+                        ) => X86CodegenOpcode::Jb,
+                        (BranchCondition::Less, _) => X86CodegenOpcode::Jl,
+                        (
+                            BranchCondition::Greater,
+                            ir::Type::Scalar(ir::ScalarType {
+                                kind: ir::ScalarTypeKind::Integer { signed: false, .. },
+                                ..
+                            }),
+                        ) => X86CodegenOpcode::Jnbe,
+                        (BranchCondition::Greater, _) => X86CodegenOpcode::Jnle,
+                        (
+                            BranchCondition::LessEqual,
+                            ir::Type::Scalar(ir::ScalarType {
+                                kind: ir::ScalarTypeKind::Integer { signed: false, .. },
+                                ..
+                            }),
+                        ) => X86CodegenOpcode::Jbe,
+                        (BranchCondition::LessEqual, _) => X86CodegenOpcode::Jle,
+                        (
+                            BranchCondition::GreaterEqual,
+                            ir::Type::Scalar(ir::ScalarType {
+                                kind: ir::ScalarTypeKind::Integer { signed: false, .. },
+                                ..
+                            }),
+                        ) => X86CodegenOpcode::Jnb,
+                        (BranchCondition::GreaterEqual, _) => X86CodegenOpcode::Jnl,
+                        _ => unreachable!("Trivial branches aren't passed as branch"),
+                    };
+
+                    let lloc = &cur_locations[&l.num];
+                    let rloc = &cur_locations[&r.num];
+                    let size = tys.type_size(&l.ty).unwrap();
+                    let over = if (size <= 8) && size.is_power_of_two() {
+                        X86RegisterClass::gpr_size(size as usize, assignments.mode)
+                    } else {
+                        None
+                    };
+
+                    self.write_cmp(&mut insns, lloc, rloc, *op, assignments, over);
+                    insns.push(MceInstruction::BaseInsn(X86Instruction::new(
+                        jmp_insn,
+                        std_vec![X86Operand::RelOffset(Address::Symbol {
+                            name: label_sym(*targ),
+                            disp: 0,
+                        })],
+                    )));
+                }
                 SsaInstruction::BranchZero(_, _, _, _) => todo!("branch"),
             }
         }

From 63cc674b5e986ef71832f3cbb7cbb737ceb88b1c Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:07:38 -0400
Subject: [PATCH 64/74] fix: Silence dead_code warnings for public apis

---
 xlang/xlang_abi/src/collection.rs  | 1 +
 xlang/xlang_host/src/primitives.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/xlang/xlang_abi/src/collection.rs b/xlang/xlang_abi/src/collection.rs
index ecd5a5bf..f4a95440 100644
--- a/xlang/xlang_abi/src/collection.rs
+++ b/xlang/xlang_abi/src/collection.rs
@@ -816,6 +816,7 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> {
 impl<'a, K, V> FusedIterator for IterMut<'a, K, V> {}
 
 /// An [`Iterator`] over the mutable values in a [`HashMap`]
+#[allow(dead_code)] // Public api, false positive
 pub struct ValuesMut<'a, K, V>(IterMut<'a, K, V>);
 
 impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
diff --git a/xlang/xlang_host/src/primitives.rs b/xlang/xlang_host/src/primitives.rs
index 12f098bc..2ca12ada 100644
--- a/xlang/xlang_host/src/primitives.rs
+++ b/xlang/xlang_host/src/primitives.rs
@@ -2,4 +2,5 @@
 
 /// A type that has the maximum fundamental alignment
 #[repr(C, align(16))]
+#[allow(dead_code)]
 pub struct max_align_t(u128);

From 616f8130fe984a139f8bb6cef3d3c43dee8a120f Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:08:00 -0400
Subject: [PATCH 65/74] feat(xlang-abi): Add `Vec::extend_from_with`

---
 xlang/xlang_abi/src/vec.rs | 91 +++++++++++++++++++++++++++++---------
 1 file changed, 70 insertions(+), 21 deletions(-)

diff --git a/xlang/xlang_abi/src/vec.rs b/xlang/xlang_abi/src/vec.rs
index c7b168bb..2709ddba 100644
--- a/xlang/xlang_abi/src/vec.rs
+++ b/xlang/xlang_abi/src/vec.rs
@@ -5,7 +5,7 @@ use std::{
     iter::{FromIterator, FusedIterator},
     marker::PhantomData,
     mem::{size_of, ManuallyDrop},
-    ops::{Deref, DerefMut},
+    ops::{Bound, Deref, DerefMut, RangeBounds},
     ptr::NonNull,
 };
 
@@ -296,7 +296,10 @@ impl<T, A: Allocator> Vec<T, A> {
     /// This will permanently leak the allocation and its elements.
     ///
     /// This function is a convience over `SpanMut::new(self.leak())`
-    pub fn leak_span<'a>(self) -> SpanMut<'a, T> {
+    pub fn leak_span<'a>(self) -> SpanMut<'a, T>
+    where
+        A: 'a,
+    {
         let this = ManuallyDrop::new(self);
         let ptr = this.ptr.as_ptr();
         let len = this.len;
@@ -323,14 +326,68 @@ impl<T, A: Allocator> Vec<T, A> {
         }
     }
 
+    /// Extends the [`Vec`] by [`Clone`]ing the elements from `range`
+    ///
+    /// ## Panics
+    /// Panics if the range ends out of bounds of the [`Vec`], or the end of the range is placed before the beginning.
+    pub fn extend_from_within<R: RangeBounds<usize>>(&mut self, range: R)
+    where
+        T: Clone,
+    {
+        let begin = match range.start_bound() {
+            Bound::Included(x) => *x,
+            Bound::Excluded(x) => *x + 1,
+            Bound::Unbounded => 0,
+        };
+
+        let end = match range.end_bound() {
+            Bound::Included(x) => *x + 1,
+            Bound::Excluded(x) => *x,
+            Bound::Unbounded => self.len,
+        };
+
+        if end < begin {
+            panic!("Range beginnning {begin} must be less than or equal to range end {end}");
+        }
+
+        if self.len < end {
+            panic!("Range {begin}..{end} is out of bounds");
+        }
+
+        let len = end - begin;
+
+        self.reserve(len);
+        let ptr = self.ptr.as_ptr();
+        let read_ptr = unsafe { ptr.add(begin) };
+        let write_ptr = unsafe { ptr.add(self.len) };
+
+        if is_copy::<T>() {
+            unsafe { core::ptr::copy_nonoverlapping(read_ptr, write_ptr, len) }
+        } else {
+            for i in 0..len {
+                unsafe {
+                    write_ptr.add(i).write((&*read_ptr.add(i)).clone());
+                }
+            }
+        }
+    }
+
     /// Clones the elements of `x` and pushes them into the Vec, reallocating at most once.
     pub fn extend_from_slice(&mut self, x: &[T])
     where
         T: Clone,
     {
         self.reserve(x.len());
-        for v in x {
-            self.push(v.clone());
+
+        if is_copy::<T>() {
+            let write_ptr = unsafe { self.ptr.as_ptr().add(self.len) };
+            let read_ptr = x.as_ptr();
+            let len = x.len();
+            unsafe { core::ptr::copy_nonoverlapping(read_ptr, write_ptr, len) }
+        } else {
+            for v in x {
+                self.push(v.clone());
+            }
         }
     }
 
@@ -646,10 +703,11 @@ impl<T, A: Allocator> DerefMut for Vec<T, A> {
     }
 }
 
-#[inline]
+#[inline(always)]
 fn is_copy<T>() -> bool {
     struct TestIsCopy<T>(bool, PhantomData<T>);
     impl<T> Clone for TestIsCopy<T> {
+        #[inline(always)]
         fn clone(&self) -> Self {
             Self(false, self.1)
         }
@@ -665,24 +723,15 @@ impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
     fn clone(&self) -> Self {
         let nalloc = self.alloc.clone();
         let mut nvec = Self::with_capacity_in(self.len, nalloc);
-        let ptr = nvec.ptr.as_ptr();
-
-        if is_copy::<T>() {
-            unsafe { core::ptr::copy_nonoverlapping(self.ptr.as_ptr(), ptr, self.len) }
-        } else {
-            for i in 0..self.len {
-                unsafe {
-                    core::ptr::write(ptr.add(i), self[i].clone());
-                }
-            }
-        }
-
-        unsafe {
-            nvec.set_len(self.len);
-        }
-
+        nvec.extend_from_slice(self);
         nvec
     }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.clear();
+        self.reserve(source.len);
+        self.extend_from_slice(source);
+    }
 }
 
 impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A> {

From 2f1d29e0b8e77701979aae96f805b1cc21418ba5 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:08:30 -0400
Subject: [PATCH 66/74] feat(xlang-backend): Implement generic regalloc

---
 codegen-x86/src/lib.rs              | 367 ++++++++++++++++------------
 xlang/xlang_backend/src/lib.rs      |   3 +
 xlang/xlang_backend/src/regalloc.rs | 162 ++++++++++++
 3 files changed, 381 insertions(+), 151 deletions(-)
 create mode 100644 xlang/xlang_backend/src/regalloc.rs

diff --git a/codegen-x86/src/lib.rs b/codegen-x86/src/lib.rs
index f0bdf07e..516e7f8f 100644
--- a/codegen-x86/src/lib.rs
+++ b/codegen-x86/src/lib.rs
@@ -3,12 +3,13 @@ use arch_ops::{
     x86::{
         codegen::{X86CodegenOpcode, X86Encoder, X86Instruction, X86MemoryOperand, X86Operand},
         insn::X86Opcode,
-        X86Mode, X86Register, X86RegisterClass,
+        X86Gpr, X86Mode, X86Register, X86RegisterClass,
     },
 };
 use callconv::X86CallConvInfo;
-use std::io::Write;
-use std::vec as std_vec;
+use core::cell::Cell;
+use std::{hash::Hash, vec as std_vec};
+use std::{io::Write, rc::Rc};
 use target_tuples::{Architecture, Target};
 use xlang::{
     abi::{pair::Pair, string::StringView},
@@ -24,6 +25,7 @@ use xlang_backend::{
         mce::{MceInstruction, MceWriter},
         Machine,
     },
+    regalloc::{Assignment, RegAllocClobbers, RegGroup},
     ssa::{OpaquePtr, SsaInstruction},
     ty::TypeInformation,
     SsaCodegenPlugin,
@@ -39,13 +41,49 @@ pub enum X86ValLocation {
     StackDisp(i32),
 }
 
+#[derive(Clone, Copy, Debug)]
+struct StackLayout {
+    size: i32,
+    align: i32,
+}
 #[derive(Clone, Debug)]
 pub struct LocationAssignment {
     foreign_location: X86ValLocation,
     owning_bb: u32,
     change_owner: Vec<(usize, X86ValLocation)>,
-    size: u64,
+    size: i32,
+    align: i32,
     stack_slot: Option<i32>,
+    stack_size_shared: Rc<Cell<StackLayout>>,
+}
+
+impl Assignment for LocationAssignment {
+    type Register = X86Register;
+
+    fn current_owned_register(&self) -> Option<Self::Register> {
+        todo!()
+    }
+
+    fn move_to_register(&mut self, reg: Self::Register, at: usize) {
+        self.change_owner.push((at, X86ValLocation::Register(reg)));
+    }
+
+    fn move_to_memory(&mut self, at: usize) {
+        let slot = *self.stack_slot.get_or_insert_with(|| {
+            let StackLayout { size, align } = self.stack_size_shared.get();
+            let new_align = align.max(self.align);
+            let slot = (size + (self.align - 1)) & !(self.align - 1);
+            let new_size = slot + self.size;
+            self.stack_size_shared.set(StackLayout {
+                size: new_size,
+                align: new_align,
+            });
+            -slot
+        });
+
+        self.change_owner
+            .push((at, X86ValLocation::StackDisp(slot)));
+    }
 }
 
 pub struct X86Machine {
@@ -55,52 +93,44 @@ pub struct X86Machine {
 pub struct X86Assignments {
     mode: X86Mode,
     sp: X86Register,
-    available_int_registers: Vec<X86Register>,
     return_reg: Option<X86Register>,
-    stack_width: i32,
-    stack_align: u64,
+    stack_layout: Rc<Cell<StackLayout>>,
     assigns: HashMap<u32, LocationAssignment>,
+    available_groups: Vec<X86RegisterGroup>,
 }
 
-pub struct X86Clobbers {
-    reg_owners: HashMap<X86Register, u32>,
-    clobbered_at: HashMap<u32, usize>,
+#[derive(Copy, Clone, Debug)]
+pub struct X86RegisterGroup {
+    class: X86RegisterClass,
+    max_regno: u8,
 }
 
-impl X86Clobbers {
-    pub fn mark_used(
-        &mut self,
-        val: u32,
-        assign: &mut LocationAssignment,
-        stack_width: &mut i32,
-        ty_size: u64,
-        ty_align: u64,
-    ) {
-        if let Some(Pair(_, pos)) = self.clobbered_at.remove(&val) {
-            let offset = *assign.stack_slot.get_or_insert_with(|| {
-                let align_minus1 = i32::try_from(ty_align).unwrap() - 1;
-                *stack_width = (*stack_width + align_minus1) & !align_minus1;
-                let offset = -*stack_width;
-                *stack_width += i32::try_from(ty_size).unwrap();
-                offset
-            });
+impl Hash for X86RegisterGroup {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.class.hash(state)
+    }
+}
 
-            assign
-                .change_owner
-                .push((pos, X86ValLocation::StackDisp(offset)));
-        }
+impl PartialEq for X86RegisterGroup {
+    fn eq(&self, other: &Self) -> bool {
+        self.class == other.class
     }
-    pub fn mark_clobbered(&mut self, reg: X86Register, which: usize, for_val: Option<u32>) {
-        if let Some(Pair(_, val)) = self.reg_owners.remove(&reg) {
-            if for_val == Some(val) {
-                self.reg_owners.insert(reg, val);
-            } else {
-                self.clobbered_at.insert(val, which);
-            }
-        }
+}
+
+impl Eq for X86RegisterGroup {}
+
+impl RegGroup for X86RegisterGroup {
+    type Register = X86Register;
+
+    fn registers(&self) -> impl IntoIterator<Item = Self::Register> + '_ {
+        (0..self.max_regno)
+            .filter_map(|r| X86Register::from_class(self.class, r))
+            .filter(|r| !matches!(r.gpr(), Some(X86Gpr::Sp)))
     }
 }
 
+type X86Clobbers = RegAllocClobbers<X86RegisterGroup>;
+
 fn xor_opcode(class: X86RegisterClass, hint_vec_is_int: bool) -> X86CodegenOpcode {
     match class {
         X86RegisterClass::Xmm => {
@@ -147,7 +177,7 @@ fn cmp_opcode(class: X86RegisterClass) -> X86CodegenOpcode {
 
 fn move_opcode(
     class: X86RegisterClass,
-    align: Option<u64>,
+    align: Option<i32>,
     hint_vec_is_int: bool,
 ) -> X86CodegenOpcode {
     match class {
@@ -322,7 +352,8 @@ impl X86Machine {
                 let reg = override_mode
                     .and_then(|r| X86Register::from_class(r, reg.regnum()))
                     .unwrap_or(*reg);
-                let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
+                let stack_layout = assigns.stack_layout.get();
+                let align = (1 << (off | -0x80000000).trailing_zeros()).max(stack_layout.align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
                 insns.push(MceInstruction::BaseInsn(X86Instruction::new(
@@ -344,7 +375,8 @@ impl X86Machine {
                 let reg = override_mode
                     .and_then(|r| X86Register::from_class(r, reg.regnum()))
                     .unwrap_or(*reg);
-                let align = (1 << (off | -0x80000000).trailing_zeros()).max(assigns.stack_align);
+                let stack_layout = assigns.stack_layout.get();
+                let align = (1 << (off | -0x80000000).trailing_zeros()).max(stack_layout.align);
                 let opcode: X86CodegenOpcode = move_opcode(reg.class(), Some(align), false);
 
                 insns.push(MceInstruction::BaseInsn(X86Instruction::new(
@@ -373,10 +405,12 @@ impl X86Machine {
     }
 
     fn real_stack_width(assignments: &X86Assignments) -> i32 {
-        (assignments.stack_width
-            + ((8 & (assignments.stack_align - 1)) as i32)
-            + (assignments.stack_align as i32 - 1))
-            & !(assignments.stack_align - 1) as i32
+        let stack_layout = assignments.stack_layout.get();
+
+        (stack_layout.size
+            + ((8 & (stack_layout.align - 1)) as i32)
+            + (stack_layout.align as i32 - 1))
+            & !(stack_layout.align - 1) as i32
     }
 }
 
@@ -450,18 +484,26 @@ impl Machine<SsaInstruction> for X86Machine {
             X86Mode::Long => 16,
             _ => 8,
         };
-        let int_registers = (0..max_gpr_num)
-            .filter(|s| *s != 4)
-            .flat_map(|x| X86Register::from_class(gpr_size, x))
-            .collect();
+
+        let max_vector_num = max_gpr_num; // TODO Support APX and AVX512/AVX10
+
+        let groups = vec![
+            X86RegisterGroup {
+                class: mode.largest_gpr(),
+                max_regno: max_gpr_num,
+            },
+            X86RegisterGroup {
+                class: X86RegisterClass::Xmm,
+                max_regno: max_gpr_num,
+            },
+        ];
 
         X86Assignments {
             mode,
             sp,
-            available_int_registers: int_registers,
+            available_groups: groups,
             return_reg: None,
-            stack_width: 0,
-            stack_align: 1,
+            stack_layout: Rc::new(Cell::new(StackLayout { size: 0, align: 1 })),
             assigns: HashMap::new(),
         }
     }
@@ -475,18 +517,13 @@ impl Machine<SsaInstruction> for X86Machine {
         incoming_set: &HashMap<u32, xlang::abi::vec::Vec<xlang_backend::ssa::OpaqueLocation>>,
         tys: &TypeInformation,
     ) -> Self::BlockClobbers {
-        let mut clobbers = X86Clobbers {
-            reg_owners: HashMap::new(),
-            clobbered_at: HashMap::new(),
-        };
+        let mut clobbers = X86Clobbers::from_groups(assignments.available_groups.iter().copied());
 
         for loc in incoming {
             let id = loc.num;
             if let Some(loc) = assignments.assigns.get(&id) {
                 match &loc.foreign_location {
-                    X86ValLocation::Register(reg) => {
-                        clobbers.reg_owners.insert(*reg, id);
-                    }
+                    X86ValLocation::Register(reg) => clobbers.mark_owning(id, *reg, 0),
                     X86ValLocation::Null | X86ValLocation::StackDisp(_) => {}
                 }
             }
@@ -494,7 +531,11 @@ impl Machine<SsaInstruction> for X86Machine {
         for (num, insn) in insns.iter().enumerate() {
             match insn {
                 xlang_backend::ssa::SsaInstruction::Call(targ, locations) => {
-                    assignments.stack_align = assignments.stack_align.max(16);
+                    let StackLayout { size, align } = assignments.stack_layout.get();
+                    assignments.stack_layout.set(StackLayout {
+                        size,
+                        align: align.max(16),
+                    });
 
                     let callconv = X86CallConvInfo {
                         mode: assignments.mode,
@@ -505,47 +546,47 @@ impl Machine<SsaInstruction> for X86Machine {
                     // TODO: Clobber non-saved registers
 
                     for (loc, call_loc) in locations.params.iter().zip(callconv.params()) {
-                        let size = tys.type_size(&loc.ty).unwrap();
+                        let size = tys.type_size(&loc.ty).unwrap() as i32;
+                        let align = tys.type_align(&loc.ty).unwrap() as i32;
                         match call_loc {
                             CallConvLocation::Null => {}
                             CallConvLocation::Register(reg) => {
                                 let ty_size = tys.type_size(&loc.ty).unwrap();
                                 let ty_align = tys.type_align(&loc.ty).unwrap();
                                 if let Some(assign) = assignments.assigns.get_mut(&loc.num) {
-                                    clobbers.mark_used(
-                                        loc.num,
-                                        assign,
-                                        &mut assignments.stack_width,
-                                        ty_size,
-                                        ty_align,
-                                    );
+                                    clobbers.mark_used(loc.num, assign);
                                 }
 
-                                clobbers.mark_clobbered(*reg, num, Some(loc.num));
+                                clobbers.mark_clobbered(*reg, Some(loc.num), num);
+                                let stack_layout = assignments.stack_layout.clone();
                                 assignments
                                     .assigns
-                                    .get_or_insert_with_mut(loc.num, |_| LocationAssignment {
+                                    .get_or_insert_with_mut(loc.num, move |_| LocationAssignment {
                                         foreign_location: X86ValLocation::Register(*reg),
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: stack_layout,
                                     })
                                     .change_owner
                                     .push((num, X86ValLocation::Register(*reg)));
 
-                                clobbers.reg_owners.insert(*reg, loc.num);
+                                clobbers.mark_owning(loc.num, *reg, num);
                             }
                             loc => todo!("{:?}", loc),
                         }
                     }
 
                     for reg in callconv.tag().volatile_regs() {
-                        clobbers.mark_clobbered(*reg, num, None);
+                        clobbers.mark_clobbered(*reg, None, num);
                     }
 
                     if let Some(ret) = &locations.ret {
-                        let size = tys.type_size(&ret.ty).unwrap();
+                        let size = tys.type_size(&ret.ty).unwrap() as i32;
+                        let align = tys.type_align(&ret.ty).unwrap() as i32;
+
                         match callconv.ret_location() {
                             CallConvLocation::Null => {
                                 assignments.assigns.insert(
@@ -555,7 +596,9 @@ impl Machine<SsaInstruction> for X86Machine {
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
@@ -567,9 +610,12 @@ impl Machine<SsaInstruction> for X86Machine {
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
+                                clobbers.mark_owning(ret.num, *reg, num);
                             }
                             loc => todo!("{:?}", loc),
                         }
@@ -579,8 +625,61 @@ impl Machine<SsaInstruction> for X86Machine {
                 SsaInstruction::Branch(_, l, r, targ, old_locs) => {
                     let foreign_locs = &incoming_set[targ];
 
+                    let l_size = tys.type_size(&l.ty).unwrap() as i32;
+                    let l_align = tys.type_align(&l.ty).unwrap() as i32;
+                    let r_size = tys.type_size(&r.ty).unwrap() as i32;
+                    let r_align = tys.type_align(&r.ty).unwrap() as i32;
+
+                    let largest_gpr = assignments.mode.largest_gpr();
+                    let stack_layout = assignments.stack_layout.clone();
+
+                    let l_assign = assignments.assigns.get_or_insert_with_mut(l.num, |_| {
+                        let reg = clobbers.alloc_reg(
+                            &X86RegisterGroup {
+                                class: largest_gpr,
+                                max_regno: 0,
+                            },
+                            num,
+                        );
+                        clobbers.mark_owning(l.num, reg, num);
+                        LocationAssignment {
+                            foreign_location: X86ValLocation::Register(reg),
+                            owning_bb: which,
+                            change_owner: Vec::new(),
+                            size: l_size,
+                            align: l_align,
+                            stack_slot: None,
+                            stack_size_shared: stack_layout.clone(),
+                        }
+                    });
+
+                    clobbers.mark_used(l.num, l_assign);
+
+                    let r_assign = assignments.assigns.get_or_insert_with_mut(l.num, |_| {
+                        let reg = clobbers.alloc_reg(
+                            &X86RegisterGroup {
+                                class: largest_gpr,
+                                max_regno: 0,
+                            },
+                            num,
+                        );
+                        clobbers.mark_owning(l.num, reg, num);
+                        LocationAssignment {
+                            foreign_location: X86ValLocation::Register(reg),
+                            owning_bb: which,
+                            change_owner: Vec::new(),
+                            size: l_size,
+                            align: l_align,
+                            stack_slot: None,
+                            stack_size_shared: stack_layout.clone(),
+                        }
+                    });
+
+                    clobbers.mark_used(r.num, r_assign);
+
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
-                        let size = tys.type_size(&old_loc.ty).unwrap();
+                        let size = tys.type_size(&old_loc.ty).unwrap() as i32;
+                        let align = tys.type_align(&old_loc.ty).unwrap() as i32;
                         match (
                             assignments
                                 .assigns
@@ -589,15 +688,7 @@ impl Machine<SsaInstruction> for X86Machine {
                             assignments.assigns.get_mut(&old_loc.num),
                         ) {
                             (Some(foreign), Some(old)) => {
-                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
-                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
 
                                 old.change_owner.push((num, foreign));
                             }
@@ -609,20 +700,16 @@ impl Machine<SsaInstruction> for X86Machine {
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
                             (None, Some(old)) => {
                                 let ty_size = tys.type_size(&old_loc.ty).unwrap();
                                 let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
                                 let incoming = old
                                     .change_owner
                                     .last()
@@ -634,10 +721,12 @@ impl Machine<SsaInstruction> for X86Machine {
                                     new_loc.num,
                                     LocationAssignment {
                                         foreign_location: incoming,
-                                        owning_bb: *targ,
+                                        owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: old_slot,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
@@ -649,7 +738,8 @@ impl Machine<SsaInstruction> for X86Machine {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
-                        let size = tys.type_size(&old_loc.ty).unwrap();
+                        let size = tys.type_size(&old_loc.ty).unwrap() as i32;
+                        let align = tys.type_align(&old_loc.ty).unwrap() as i32;
                         match (
                             assignments
                                 .assigns
@@ -658,15 +748,7 @@ impl Machine<SsaInstruction> for X86Machine {
                             assignments.assigns.get_mut(&old_loc.num),
                         ) {
                             (Some(foreign), Some(old)) => {
-                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
-                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
 
                                 old.change_owner.push((num, foreign));
                             }
@@ -678,20 +760,16 @@ impl Machine<SsaInstruction> for X86Machine {
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
                             (None, Some(old)) => {
                                 let ty_size = tys.type_size(&old_loc.ty).unwrap();
                                 let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
                                 let incoming = old
                                     .change_owner
                                     .last()
@@ -703,10 +781,12 @@ impl Machine<SsaInstruction> for X86Machine {
                                     new_loc.num,
                                     LocationAssignment {
                                         foreign_location: incoming,
-                                        owning_bb: *targ,
+                                        owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: old_slot,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
@@ -720,7 +800,8 @@ impl Machine<SsaInstruction> for X86Machine {
                     let foreign_locs = &incoming_set[targ];
 
                     for (old_loc, new_loc) in old_locs.iter().zip(foreign_locs) {
-                        let size = tys.type_size(&old_loc.ty).unwrap();
+                        let size = tys.type_size(&old_loc.ty).unwrap() as i32;
+                        let align = tys.type_align(&old_loc.ty).unwrap() as i32;
                         match (
                             assignments
                                 .assigns
@@ -729,15 +810,7 @@ impl Machine<SsaInstruction> for X86Machine {
                             assignments.assigns.get_mut(&old_loc.num),
                         ) {
                             (Some(foreign), Some(old)) => {
-                                let ty_size = tys.type_size(&old_loc.ty).unwrap();
-                                let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
 
                                 old.change_owner.push((num, foreign));
                             }
@@ -749,20 +822,16 @@ impl Machine<SsaInstruction> for X86Machine {
                                         owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
                             (None, Some(old)) => {
                                 let ty_size = tys.type_size(&old_loc.ty).unwrap();
                                 let ty_align = tys.type_align(&old_loc.ty).unwrap();
-                                clobbers.mark_used(
-                                    old_loc.num,
-                                    old,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(old_loc.num, old);
                                 let incoming = old
                                     .change_owner
                                     .last()
@@ -774,10 +843,12 @@ impl Machine<SsaInstruction> for X86Machine {
                                     new_loc.num,
                                     LocationAssignment {
                                         foreign_location: incoming,
-                                        owning_bb: *targ,
+                                        owning_bb: which,
                                         change_owner: vec![],
                                         size,
+                                        align,
                                         stack_slot: old_slot,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     },
                                 );
                             }
@@ -788,19 +859,12 @@ impl Machine<SsaInstruction> for X86Machine {
                 xlang_backend::ssa::SsaInstruction::Exit(val) => match &**val {
                     [] => {}
                     [retval] => {
-                        let size = tys.type_size(&retval.ty).unwrap();
+                        let size = tys.type_size(&retval.ty).unwrap() as i32;
+                        let align = tys.type_align(&retval.ty).unwrap() as i32;
                         let reg = assignments.return_reg;
                         if let Some(reg) = reg {
-                            let ty_size = tys.type_size(&retval.ty).unwrap();
-                            let ty_align = tys.type_align(&retval.ty).unwrap();
                             if let Some(assign) = assignments.assigns.get_mut(&retval.num) {
-                                clobbers.mark_used(
-                                    retval.num,
-                                    assign,
-                                    &mut assignments.stack_width,
-                                    ty_size,
-                                    ty_align,
-                                );
+                                clobbers.mark_used(retval.num, assign);
                             }
                             let loc = X86ValLocation::Register(reg);
 
@@ -811,7 +875,9 @@ impl Machine<SsaInstruction> for X86Machine {
                                     owning_bb: which,
                                     change_owner: vec![],
                                     size,
+                                    align,
                                     stack_slot: None,
+                                    stack_size_shared: assignments.stack_layout.clone(),
                                 })
                                 .change_owner
                                 .push((num, loc));
@@ -830,16 +896,10 @@ impl Machine<SsaInstruction> for X86Machine {
                         match call_loc {
                             CallConvLocation::Null => {}
                             CallConvLocation::Register(reg) => {
-                                let ty_size = tys.type_size(&loc.ty).unwrap();
-                                let ty_align = tys.type_align(&loc.ty).unwrap();
+                                let size = tys.type_size(&loc.ty).unwrap() as i32;
+                                let align = tys.type_align(&loc.ty).unwrap() as i32;
                                 if let Some(assign) = assignments.assigns.get_mut(&loc.num) {
-                                    clobbers.mark_used(
-                                        loc.num,
-                                        assign,
-                                        &mut assignments.stack_width,
-                                        ty_size,
-                                        ty_align,
-                                    );
+                                    clobbers.mark_used(loc.num, assign);
                                 }
                                 assignments
                                     .assigns
@@ -847,8 +907,10 @@ impl Machine<SsaInstruction> for X86Machine {
                                         foreign_location: X86ValLocation::Register(*reg),
                                         owning_bb: which,
                                         change_owner: vec![],
-                                        size: ty_size,
+                                        size,
+                                        align,
                                         stack_slot: None,
+                                        stack_size_shared: assignments.stack_layout.clone(),
                                     })
                                     .change_owner
                                     .push((num, X86ValLocation::Register(*reg)));
@@ -888,7 +950,7 @@ impl Machine<SsaInstruction> for X86Machine {
                     for (at, new_loc) in &loc.change_owner {
                         if *at == num {
                             let size = loc.size;
-                            let over = if (size <= 8) && size.is_power_of_two() {
+                            let over = if (size <= 8) && (size == (size & -size)) {
                                 X86RegisterClass::gpr_size(size as usize, assignments.mode)
                             } else {
                                 None
@@ -1121,7 +1183,8 @@ impl Machine<SsaInstruction> for X86Machine {
         let callconv = compute_call_conv(&callconv, fnty, fnty, tys);
 
         for (param, incoming) in callconv.params().iter().zip(incoming) {
-            let size = tys.type_size(&incoming.ty).unwrap();
+            let size = tys.type_size(&incoming.ty).unwrap() as i32;
+            let align = tys.type_align(&incoming.ty).unwrap() as i32;
             let loc = match param {
                 CallConvLocation::Null => X86ValLocation::Null,
                 CallConvLocation::Register(reg) => X86ValLocation::Register(*reg),
@@ -1130,10 +1193,12 @@ impl Machine<SsaInstruction> for X86Machine {
 
             let assignment = LocationAssignment {
                 foreign_location: loc,
-                change_owner: vec![],
                 owning_bb: which,
+                change_owner: vec![],
                 size,
+                align,
                 stack_slot: None,
+                stack_size_shared: assignments.stack_layout.clone(),
             };
 
             assignments.assigns.insert(incoming.num, assignment);
diff --git a/xlang/xlang_backend/src/lib.rs b/xlang/xlang_backend/src/lib.rs
index 070ca0cd..7059e269 100644
--- a/xlang/xlang_backend/src/lib.rs
+++ b/xlang/xlang_backend/src/lib.rs
@@ -38,6 +38,9 @@ pub mod intrinsic;
 /// Module for handling calling convention, and calling functions
 pub mod callconv;
 
+/// Module for handling regalloc
+pub mod regalloc;
+
 /// Module for name mangling
 pub mod mangle;
 
diff --git a/xlang/xlang_backend/src/regalloc.rs b/xlang/xlang_backend/src/regalloc.rs
new file mode 100644
index 00000000..601017c7
--- /dev/null
+++ b/xlang/xlang_backend/src/regalloc.rs
@@ -0,0 +1,162 @@
+use core::hash::Hash;
+
+use xlang::abi::{collection::HashMap, pair::Pair, vec::Vec};
+
+/// A Trait for groups of registers on a platform
+pub trait RegGroup: Hash + Eq + Clone {
+    /// The type of Register
+    type Register: Hash + Eq + Clone;
+    /// All Registers that belong to the group
+    fn registers(&self) -> impl IntoIterator<Item = Self::Register> + '_;
+}
+
+/// Trait for codegen specific assignment types
+pub trait Assignment {
+    /// The type of Register the assignment can belong to
+    type Register;
+
+    /// The register the assignment currently occupies, if any
+    fn current_owned_register(&self) -> Option<Self::Register>;
+    /// Indicates that the assignment should move to `reg` at the specified mc instruction
+    fn move_to_register(&mut self, reg: Self::Register, at: usize);
+    /// Indicates that the assignment should move to memory at the specified mc instruction.
+    fn move_to_memory(&mut self, at: usize);
+}
+
+/// A Generalized Register allocator which can be used as [`Machine::BlockClobbers`][crate::mach::Machine::BlockClobbers]
+#[derive(Clone, Debug)]
+pub struct RegisterAllocator<R, G> {
+    inverse_reg_map: HashMap<R, G>,
+    reg_groups_lru: HashMap<G, Vec<R>>,
+    reg_owners: HashMap<R, u32>,
+    clobbered_at: HashMap<u32, usize>,
+    saved_regs: HashMap<R, bool>,
+}
+
+impl<R, G> RegisterAllocator<R, G> {
+    /// Constructs a new [`RegisterAllocator`] in an empty state.
+    pub fn new() -> Self {
+        Self {
+            reg_groups_lru: HashMap::new(),
+            reg_owners: HashMap::new(),
+            clobbered_at: HashMap::new(),
+            inverse_reg_map: HashMap::new(),
+            saved_regs: HashMap::new(),
+        }
+    }
+}
+
+impl<R, G> Default for RegisterAllocator<R, G> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<G: RegGroup> RegisterAllocator<G::Register, G> {
+    /// Constructs a new [`RegisterAllocator`] that is initialized to use each of the register `groups` specified.
+    ///
+    /// This is a convience over constructing with [`RegisterAllocator::new`] followed by calling [`RegisterAllocator::add_groups`].
+    pub fn from_groups<I: IntoIterator<Item = G>>(groups: I) -> Self {
+        let mut ret = Self::new();
+        ret.add_groups(groups);
+        ret
+    }
+
+    /// Indicates that the following registers must be saved by the calling covnention.
+    pub fn save_registers<I: IntoIterator<Item = G::Register>>(&mut self, regs: I) {
+        self.saved_regs.extend(regs.into_iter().map(|x| (x, false)))
+    }
+
+    /// Lists the calling-convention saved registers that have been clobbered by the block
+    pub fn clobbered_registers(&self) -> impl IntoIterator<Item = G::Register> + '_ {
+        self.saved_regs
+            .iter()
+            .filter_map(|Pair(v, x)| if *x { Some(v) } else { None })
+            .cloned()
+    }
+
+    /// Adds the specified group `regs` to list of available registers.
+    pub fn add_group(&mut self, regs: G) {
+        let values = regs.registers().into_iter().collect::<Vec<_>>();
+        for v in &values {
+            self.inverse_reg_map.insert(v.clone(), regs.clone());
+        }
+        self.reg_groups_lru.insert(regs, values);
+    }
+    /// Adds each group in `groups` to the list of available registers.
+    /// This is equivalent to repeatedly calling [`RegisterAllocator::add_group`] on each element yielded by `groups`.
+    pub fn add_groups<I: IntoIterator<Item = G>>(&mut self, groups: I) {
+        for group in groups {
+            self.add_group(group);
+        }
+    }
+
+    fn reg_used(&mut self, reg: &G::Register) {
+        let group = &self.inverse_reg_map[reg];
+
+        let cache = self.reg_groups_lru.get_mut(group).unwrap();
+
+        for (i, r) in cache.iter().enumerate() {
+            if reg == r {
+                let val = cache.remove(i);
+                cache.push(val);
+                break;
+            }
+        }
+    }
+
+    /// Allocates a register that belongs to the specified `group`.
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `group` has not been added via [`RegisterAllocator::add_group`].
+    pub fn alloc_reg(&mut self, group: &G, at: usize) -> G::Register {
+        let cache = self.reg_groups_lru.get_mut(group).unwrap();
+
+        let val = cache.remove(0);
+        cache.push(val.clone());
+        self.mark_clobbered(val.clone(), None, at);
+        val
+    }
+
+    /// Marks that `val` starts owning register `reg` at the specified mc instruction.
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `reg` does not belong to any register group previously added by [`RegisterAllocator::add_group`].
+    pub fn mark_owning(&mut self, val: u32, reg: G::Register, at: usize) {
+        self.mark_clobbered(reg.clone(), Some(val), at);
+        self.reg_used(&reg);
+        self.reg_owners.insert(reg, val);
+    }
+
+    /// Marks that `reg` has been clobbered at the specified mc instruction.
+    ///
+    /// `for_val` is either `None` or the [`OpaqueLocation`][crate::ssa::OpaqueLocation] number of the appropriate value.
+    ///
+    /// ## Panics
+    ///
+    /// Panics if `reg` does not belong to any register group previously added by [`RegisterAllocator::add_group`].
+    pub fn mark_clobbered(&mut self, reg: G::Register, for_val: Option<u32>, at: usize) {
+        if let Some(v) = self.saved_regs.get_mut(&reg) {
+            *v = true;
+        }
+        if let Some(Pair(_, val)) = self.reg_owners.remove(&reg) {
+            if for_val == Some(val) {
+                self.reg_owners.insert(reg, val);
+            } else {
+                self.clobbered_at.insert(val, at);
+            }
+        }
+    }
+
+    /// Marks the specified `val` as used, spilling it to memory if necessary.
+    pub fn mark_used<A: Assignment>(&mut self, val: u32, assign: &mut A) {
+        if let Some(Pair(_, at)) = self.clobbered_at.remove(&val) {
+            assign.move_to_memory(at);
+        }
+    }
+}
+
+/// A convience alias for [`RegisterAllocator`] that only specifies the register group.
+pub type RegAllocClobbers<G> = RegisterAllocator<<G as RegGroup>::Register, G>;

From 56f503cf9219e5a8f286398277a55d9303f02c34 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:08:55 -0400
Subject: [PATCH 67/74] docs(xlang-ir): Add clause about
 *weekly-happens-before*

---
 xlang/xlang_struct/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xlang/xlang_struct/src/lib.rs b/xlang/xlang_struct/src/lib.rs
index d9e250a8..8ad6ef15 100644
--- a/xlang/xlang_struct/src/lib.rs
+++ b/xlang/xlang_struct/src/lib.rs
@@ -2662,7 +2662,7 @@ fake_enum::fake_enum! {
     ///    * A *happens before* B,
     ///    * A is a memory operation with a nontemporal access class, B is a `sequence` instruction, and A is *weekly sequenced before* B,
     ///    * There exists an expression C, such that A *weekly happens before* C, and C *weekly happens before* B.
-    /// 6.
+    /// 6. _Note: Weekly happens before allows a `sequence` instruction to synchronize `nontemporal` accesses with _
     ///
     pub enum struct AccessClass{
         Normal = 0,

From 6cf6ceda56eb186b66e5de1e0835c26bb9f8a323 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:09:05 -0400
Subject: [PATCH 68/74] chore: Update submodules

---
 .gitignore  | 3 ++-
 autobuild   | 2 +-
 lc-binutils | 2 +-
 rtlibs      | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/.gitignore b/.gitignore
index bfa4c924..014e85a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,5 @@ autom4te.cache/
 *.out
 testfile
 test-output.txt
-/build*/
\ No newline at end of file
+/build*/
+rustc-ice-*.txt
\ No newline at end of file
diff --git a/autobuild b/autobuild
index d6e2cca8..f5ef836d 160000
--- a/autobuild
+++ b/autobuild
@@ -1 +1 @@
-Subproject commit d6e2cca8ffc881ead60f7ed2dd5c8243a7fc0073
+Subproject commit f5ef836d802e84b959b0015e0a27f20711a54a5c
diff --git a/lc-binutils b/lc-binutils
index 3d34de46..26c171fa 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 3d34de46365defa4fa1931e7d7466ae5889f4ce4
+Subproject commit 26c171faa77497cf7e90570a2baefbf70fda3c47
diff --git a/rtlibs b/rtlibs
index bf819633..a99ff3e6 160000
--- a/rtlibs
+++ b/rtlibs
@@ -1 +1 @@
-Subproject commit bf8196338353f5735a2d46b09c3e2b9fd9fbc55f
+Subproject commit a99ff3e6850833f975b3172457a69242e990c855

From c40b1976cd7b94f075f0254306733ebd48ff1f81 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:23:50 -0400
Subject: [PATCH 69/74] chore: update lc-binutils

---
 lc-binutils | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lc-binutils b/lc-binutils
index 26c171fa..440de1e7 160000
--- a/lc-binutils
+++ b/lc-binutils
@@ -1 +1 @@
-Subproject commit 26c171faa77497cf7e90570a2baefbf70fda3c47
+Subproject commit 440de1e708722d8634d1cf79b01ea6c43ed9a29f

From af3d523ea42ef776540ab17ccb0b5fdc26a2105e Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 16:25:57 -0400
Subject: [PATCH 70/74] chore: cargo fmt

---
 lccc/src/manifest/parse.rs      | 1 +
 rust/src/lex.rs                 | 6 +++++-
 xlang/xlang_frontend/src/lib.rs | 2 +-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/lccc/src/manifest/parse.rs b/lccc/src/manifest/parse.rs
index e69de29b..8b137891 100644
--- a/lccc/src/manifest/parse.rs
+++ b/lccc/src/manifest/parse.rs
@@ -0,0 +1 @@
+
diff --git a/rust/src/lex.rs b/rust/src/lex.rs
index 7fe4e806..5eff5c9b 100644
--- a/rust/src/lex.rs
+++ b/rust/src/lex.rs
@@ -843,7 +843,11 @@ fn do_lexeme(file: &mut Speekable<impl Iterator<Item = char>>) -> Result<Lexeme>
                                         ty: TokenType::Character(_),
                                         body,
                                     }) => {
-                                        break Ok(Token::new(TokenType::Character(CharType::Byte), id + &body).with_span(span));
+                                        break Ok(Token::new(
+                                            TokenType::Character(CharType::Byte),
+                                            id + &body,
+                                        )
+                                        .with_span(span));
                                     }
                                     LexemeBody::Token(_) => {
                                         todo!("validation error for \"byte lifetimes\"");
diff --git a/xlang/xlang_frontend/src/lib.rs b/xlang/xlang_frontend/src/lib.rs
index a9f0dcc1..5ecd3f91 100644
--- a/xlang/xlang_frontend/src/lib.rs
+++ b/xlang/xlang_frontend/src/lib.rs
@@ -5,4 +5,4 @@ pub mod parse;
 pub mod span;
 pub mod symbol;
 
-pub mod lexer;
\ No newline at end of file
+pub mod lexer;

From bbdb46353d09b4b027c980f8da4d37bac745cfcc Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 18:29:37 -0400
Subject: [PATCH 71/74] fix: Adjust alloc test

---
 .github/workflows/{clippy.yml => clippy.yml.disabled} | 0
 xlang/xlang_abi/src/alloc.rs                          | 1 +
 xlang/xlang_abi/src/string.rs                         | 6 +++---
 3 files changed, 4 insertions(+), 3 deletions(-)
 rename .github/workflows/{clippy.yml => clippy.yml.disabled} (100%)

diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml.disabled
similarity index 100%
rename from .github/workflows/clippy.yml
rename to .github/workflows/clippy.yml.disabled
diff --git a/xlang/xlang_abi/src/alloc.rs b/xlang/xlang_abi/src/alloc.rs
index 737d9262..0db2f1c6 100644
--- a/xlang/xlang_abi/src/alloc.rs
+++ b/xlang/xlang_abi/src/alloc.rs
@@ -1107,6 +1107,7 @@ mod test {
     #[test]
     pub fn test_alloc_align() {
         #[repr(align(256))]
+        #[allow(dead_code)]
         struct Foo(u8);
         let p = unsafe { xlang_allocate_aligned(256, 256) } as *mut Foo;
         if p.is_null() {
diff --git a/xlang/xlang_abi/src/string.rs b/xlang/xlang_abi/src/string.rs
index 526410bf..8916c278 100644
--- a/xlang/xlang_abi/src/string.rs
+++ b/xlang/xlang_abi/src/string.rs
@@ -363,7 +363,7 @@ impl Deref for StringView<'_> {
         unsafe {
             core::str::from_utf8_unchecked(core::slice::from_raw_parts(
                 self.begin.as_ptr(),
-                (self.end.as_ptr() as usize) - (self.begin.as_ptr() as usize), // This is really annoying that have to do this
+                self.end.offset_from(self.begin) as usize, // This is really annoying that have to do this
             ))
         }
     }
@@ -407,7 +407,7 @@ impl core::fmt::Debug for StringView<'_> {
 
 impl core::fmt::Display for StringView<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        <str as core::fmt::Display>::fmt(self, f)
+        f.write_str(self)
     }
 }
 
@@ -604,6 +604,6 @@ mod test {
     #[test]
     pub fn test_display() {
         let x = StringView::new("Hello World");
-        assert_eq!(&*x, &*format!("{}", x))
+        assert_eq!(*x, *format!("{}", x))
     }
 }

From 179e2b9a2522973c8be86099768e40a87639600f Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 18:48:42 -0400
Subject: [PATCH 72/74] test(xlang-abi): Don't use xlang::abi::format for
 test_display

---
 xlang/xlang_abi/src/string.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xlang/xlang_abi/src/string.rs b/xlang/xlang_abi/src/string.rs
index 8916c278..4837f7df 100644
--- a/xlang/xlang_abi/src/string.rs
+++ b/xlang/xlang_abi/src/string.rs
@@ -604,6 +604,6 @@ mod test {
     #[test]
     pub fn test_display() {
         let x = StringView::new("Hello World");
-        assert_eq!(*x, *format!("{}", x))
+        assert_eq!(*x, *std::format!("{}", x))
     }
 }

From d121c45b02f2fa6d4477425e7782ec0968262ddf Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Sun, 4 Aug 2024 22:45:48 -0400
Subject: [PATCH 73/74] fix(xlang-abi): Vec::extend_from_slice and
 Vec::extend_from_within did not update length for `Copy` types

---
 xlang/xlang_abi/src/string.rs |  5 +++
 xlang/xlang_abi/src/vec.rs    | 61 +++++++++++++++++++++++++++++++++--
 2 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/xlang/xlang_abi/src/string.rs b/xlang/xlang_abi/src/string.rs
index 4837f7df..06e80fab 100644
--- a/xlang/xlang_abi/src/string.rs
+++ b/xlang/xlang_abi/src/string.rs
@@ -606,4 +606,9 @@ mod test {
         let x = StringView::new("Hello World");
         assert_eq!(*x, *std::format!("{}", x))
     }
+
+    #[test]
+    fn test_format() {
+        assert_eq!(*"5", *format!("{}", 5))
+    }
 }
diff --git a/xlang/xlang_abi/src/vec.rs b/xlang/xlang_abi/src/vec.rs
index 2709ddba..c375897b 100644
--- a/xlang/xlang_abi/src/vec.rs
+++ b/xlang/xlang_abi/src/vec.rs
@@ -370,6 +370,8 @@ impl<T, A: Allocator> Vec<T, A> {
                 }
             }
         }
+
+        self.len += len;
     }
 
     /// Clones the elements of `x` and pushes them into the Vec, reallocating at most once.
@@ -383,7 +385,10 @@ impl<T, A: Allocator> Vec<T, A> {
             let write_ptr = unsafe { self.ptr.as_ptr().add(self.len) };
             let read_ptr = x.as_ptr();
             let len = x.len();
-            unsafe { core::ptr::copy_nonoverlapping(read_ptr, write_ptr, len) }
+            unsafe {
+                core::ptr::copy_nonoverlapping(read_ptr, write_ptr, len);
+            }
+            self.len += len;
         } else {
             for v in x {
                 self.push(v.clone());
@@ -1000,7 +1005,7 @@ macro_rules! vec{
             __check(&val);
             let mut vec = $crate::vec::Vec::with_capacity(__repeat);
             for _ in 0..($repeat){
-                vec.push(val.clone());
+                vec.push(::core::clone::Clone::clone(&val));
             }
             vec
         }
@@ -1161,4 +1166,56 @@ mod test {
         assert_eq!(vec[0], 4);
         assert_eq!(vec[1], 5);
     }
+
+    #[test]
+    fn test_vec_macro_slice() {
+        let vec = vec![0, 1, 2, 3];
+
+        assert_eq!(vec[..], [0, 1, 2, 3]);
+    }
+
+    #[test]
+    fn test_vec_macro_repeat() {
+        let vec = vec![0; 4];
+
+        assert_eq!(vec[..], [0; 4])
+    }
+
+    #[test]
+    fn test_vec_extend_from_slice_non_copy() {
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct NotCopy(u8);
+
+        const NOT_COPY: NotCopy = NotCopy(1);
+
+        let mut base = Vec::new();
+        base.extend_from_slice(&[NOT_COPY; 16]);
+
+        assert_eq!(base[..], [NOT_COPY; 16])
+    }
+
+    #[test]
+    fn test_vec_extend_from_slice_copy() {
+        let mut base = Vec::new();
+        base.extend_from_slice(&[0u8; 16]);
+
+        assert_eq!(base[..], [0; 16])
+    }
+
+    #[test]
+    fn test_vec_extend_from_within_non_copy() {
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct NotCopy(u8);
+        const NOT_COPY: NotCopy = NotCopy(1);
+        let mut base = vec![NotCopy(1); 32];
+        base.extend_from_within(0..8);
+        assert_eq!(base[..], [NOT_COPY; 40]);
+    }
+
+    #[test]
+    fn test_vec_extend_from_within_copy() {
+        let mut base = vec![1u8; 32];
+        base.extend_from_within(0..8);
+        assert_eq!(base[..], [1; 40]);
+    }
 }

From 29bc0214ebd48fa0af4b50c1f24e9d593404eb78 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 7 Aug 2024 17:00:51 -0400
Subject: [PATCH 74/74] Make `StringView::new` a `const fn`

---
 xlang/xlang_abi/src/string.rs | 23 ++---------------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/xlang/xlang_abi/src/string.rs b/xlang/xlang_abi/src/string.rs
index 06e80fab..14eadcd6 100644
--- a/xlang/xlang_abi/src/string.rs
+++ b/xlang/xlang_abi/src/string.rs
@@ -444,7 +444,7 @@ impl<'a> StringView<'a> {
 
     /// Returns a view over the string referred to by `v`
     #[must_use]
-    pub fn new(v: &'a str) -> Self {
+    pub const fn new(v: &'a str) -> Self {
         let bytes = v.as_bytes();
 
         let begin = bytes.as_ptr();
@@ -536,26 +536,7 @@ pub use core::ptr::addr_of as __addr_of;
 #[macro_export]
 macro_rules! const_sv {
     ($str:expr) => {{
-        const __RET: $crate::string::StringView = {
-            #[repr(C)]
-            union AsArray<'a, T> {
-                reff: &'a T,
-                arr: &'a [T; 1],
-            }
-
-            let st: &'static $crate::string::__rust_str = $str;
-            let slice = st.as_bytes();
-            let begin = slice.as_ptr();
-            let end = if let [.., reff] = slice {
-                let [_, end @ ..] = unsafe { AsArray { reff }.arr };
-                end.as_ptr()
-            } else {
-                slice.as_ptr()
-            };
-
-            unsafe { $crate::string::StringView::from_raw_parts(begin, end) }
-        };
-        __RET
+        $crate::string::StringView::new($str)
     }};
 }