You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: compare.rs
    path of file: ./repos/swc/crates/swc_html_parser/benches
    
    the code of the file until where you have to start completion: extern crate swc_malloc;

use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion};
use swc_common::{input::StringInput, FileName, Span, SyntaxContext, DUMMY_SP};
use swc_html_ast::{Document, DocumentFragment, DocumentMode, Element, Namespace};
use swc_html_parser::{lexer::Lexer, parser::Parser};
use swc_html_visit::{Fold, FoldWith, VisitMut, VisitMutWith};

static SOURCE: &str = include_str!("files/github_com_17_05_2022.html");

fn run_document<F>(b: &mut Bencher, mut op: F)
where
    F: FnMut(Document) -> Document,
{
    let _ = ::testing::run_test(false, |cm, _| {
        let fm = cm.new_source_file(FileName::Anon, SOURCE.into());

        let lexer = Lexer::new(StringInput::from(&*fm));
        let mut parser = Parser::new(lexer, Default::default());
        let document: Document = parser.parse_document().unwrap();

        b.iter(|| {
            let document = document.clone();
            let document = op(document);

            black_box(document)
        });

        Ok(())
    });
}

fn run_document_fragment<F>(b: &mut Bencher, mut op: F)
where
    F: FnMut(DocumentFragment) -> DocumentFragment,
{
    let _ = ::testing::run_test(false, |cm, _| {
        let fm = cm.new_source_file(FileName::Anon, SOURCE.into());

        let lexer = Lexer::new(StringInput::from(&*fm));
        let mut parser = Parser::new(lexer, Default::default());
        let document_fragment: DocumentFragment = parser
            .parse_document_fragment(
                Element {
                    span: Default::default(),
                    tag_name: "template".into(),
                    namespace: Namespace::HTML,
                    attributes: vec![],
                    is_self_closing: false,
                    children: vec![],
                    content: None,
                },
                DocumentMode::NoQuirks,
                None,
            )
            .unwrap();

        b.iter(|| {
            let document_fragment = document_fragment.clone();
            let document_fragment = op(document_fragment);

            black_box(document_fragment)
        });

        Ok(())
    });
}

fn bench_cases(c: &mut Criterion) {
    c.bench_function("html/document/visitor/compare/clone", |b| {
        run_document(b, |m: Document| m)
    });

    c.bench_function("html/document/visitor/compare/visit_mut_span", |b| {
        struct RespanVisitMut;

        impl VisitMut for RespanVisitMut {
            fn visit_mut_span(&mut self, span: &mut Span) {
                *span = DUMMY_SP;
            }
        }

        run_document(b, |mut m| {
            m.visit_mut_with(&mut RespanVisitMut);

            m
        });
    });

    c.bench_function("html/document/visitor/compare/visit_mut_span_panic", |b| {
        struct RespanVisitMut;

        impl VisitMut for RespanVisitMut {
            fn visit_mut_span(&mut self, span: &mut Span) {
                if span.ctxt != SyntaxContext::empty() {
                    panic!()
                }

                *span = DUMMY_SP;
            }
        }

        run_document(b, |mut m| {
            m.visit_mut_with(&mut RespanVisitMut);

            m
        });
    });

    c.bench_function("html/document/visitor/compare/fold_span", |b| {
        struct RespanFold;

        impl Fold for RespanFold {
            fn fold_span(&mut self, _: Span) -> Span {
                DUMMY_SP
            }
        }

        run_document(b, |m| m.fold_with(&mut RespanFold));
    });

    c.bench_function("html/document/visitor/compare/fold_span_panic", |b| {
        struct RespanFold;

        impl Fold for RespanFold {
            fn fold_span(&mut self, s: Span) -> Span {
    
fn bench_cases(c: &mut Criterion) {
    c.bench_function("html/document/visitor/compare/clone", |b| {
        run_document(b, |m: Document| m)
    });

    c.bench_function("html/document/visitor/compare/visit_mut_span", |b| {
        struct RespanVisitMut;

        impl VisitMut for RespanVisitMut {
            fn visit_mut_span(&mut self, span: &mut Span) {
                *span = DUMMY_SP;
            }
        }

        run_document(b, |mut m| {
            m.visit_mut_with(&mut RespanVisitMut);

            m
        });
    });

    c.bench_function("html/document/visitor/compare/visit_mut_span_panic", |b| {
        struct RespanVisitMut;

        impl VisitMut for RespanVisitMut {
            fn visit_mut_span(&mut self, span: &mut Span) {
                if span.ctxt != SyntaxContext::empty() {
                    panic!()
                }

                *span = DUMMY_SP;
            }
        }

        run_document(b, |mut m| {
            m.visit_mut_with(&mut RespanVisitMut);

            m
        });
    });

    c.bench_function("html/document/visitor/compare/fold_span", |b| {
        struct RespanFold;

        impl Fold for RespanFold {
            fn fold_span(&mut self, _: Span) -> Span {
                DUMMY_SP
            }
        }

        run_document(b, |m| m.fold_with(&mut RespanFold));
    });

    c.bench_function("html/document/visitor/compare/fold_span_panic", |b| {
        struct RespanFold;

        impl Fold for RespanFold {
            fn fold_span(&mut self, s: Span) -> Span {
                if s.ctxt != SyntaxContext::empty() {
                    panic!()
                }

                DUMMY_SP
            }
        }

        run_document(b, |m| m.fold_with(&mut RespanFold));
    });

    c.bench_function("html/document_fragment/visitor/compare/clone", |b| {
        run_document_fragment(b, |m: DocumentFragment| m)
    });

    c.bench_function(
        "html/document_fragment/visitor/compare/visit_mut_span",
        |b| {
            struct RespanVisitMut;

            impl VisitMut for RespanVisitMut {
                fn visit_mut_span(&mut self, span: &mut Span) {
                    *span = DUMMY_SP;
                }
            }

            run_document_fragment(b, |mut m| {
                m.visit_mut_with(&mut RespanVisitMut);

                m
            });
        },
    );

    c.bench_function(
        "html/document_fragment/visitor/compare/visit_mut_span_panic",
        |b| {
            struct RespanVisitMut;

            impl VisitMut for RespanVisitMut {
                fn visit_mut_span(&mut self, span: &mut Span) {
                    if span.ctxt != SyntaxContext::empty() {
                        panic!()
                    }

                    *span = DUMMY_SP;
                }
            }

            run_document_fragment(b, |mut m| {
                m.visit_mut_with(&mut RespanVisitMut);

                m
            });
        },
    );

    c.bench_function("html/document_fragment/visitor/compare/fold_span", |b| {
        struct RespanFold;

        impl Fold for RespanFold {
            fn fold_span(&mut self, _: Span) -> Span {
                DUMMY_SP
            }
        }

        run_document_fragment(b, |m| m.fold_with(&mut RespanFold));
    });

    c.bench_function(
        "html/document_fragment/visitor/compare/fold_span_panic",
        |b| {
            struct RespanFold;

            impl Fold for RespanFold {
                fn fold_span(&mut self, s: Span) -> Span {
                    if s.ctxt != SyntaxContext::empty() {
                        panic!()
                    }

                    DUMMY_SP
                }
            }

            run_document_fragment(b, |m| m.fold_with(&mut RespanFold));
        },
    );
}