--------------------------------------------------------------------------------
I1 cache:         65536 B, 64 B, 4-way associative
D1 cache:         32768 B, 64 B, 8-way associative
LL cache:         67108864 B, 64 B, 64-way associative
Command:          /usr/home/liquid/.rustup/toolchains/w-profiling/bin/rustc --crate-name wayland_scanner --edition=2018 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --crate-type proc-macro --emit=dep-info,link -C prefer-dynamic -C opt-level=3 -C embed-bitcode=no -C metadata=d32a27f904ed265c -C extra-filename=-d32a27f904ed265c --out-dir /usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps -L dependency=/usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps --extern proc_macro2=/usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps/libproc_macro2-2cc02033350d879d.rlib --extern quote=/usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps/libquote-519527976b29fa54.rlib --extern syn=/usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps/libsyn-744f301fa7e53c80.rlib --extern xml=/usr/home/liquid/tmp/.tmpmfVdQ2/target/release/deps/libxml-b77b46c44f4bab13.rlib --extern proc_macro -Adeprecated -Aunknown-lints -Zincremental-verify-ich
Data file:        results/cgout-w-profiling-wayland-scanner-0.30.0-alpha3-Opt-Full
Events recorded:  Ir
Events shown:     Ir
Event sort order: Ir
Thresholds:       0.1
Include dirs:     
User annotated:   
Auto-annotation:  on

--------------------------------------------------------------------------------
Ir                      
--------------------------------------------------------------------------------
43,462,990,151 (100.0%)  PROGRAM TOTALS

--------------------------------------------------------------------------------
Ir                      file:function
--------------------------------------------------------------------------------
1,086,073,888 ( 2.50%)  ./malloc/malloc.c:_int_malloc
1,067,879,792 ( 2.46%)  ./malloc/malloc.c:_int_free
  931,271,399 ( 2.14%)  ???:llvm::isNonEscapingLocalObject(llvm::Value const*, llvm::SmallDenseMap<llvm::Value const*, bool, 8u, llvm::DenseMapInfo<llvm::Value const*>, llvm::detail::DenseMapPair<llvm::Value const*, bool> >*)
  887,029,032 ( 2.04%)  ???:llvm::InstCombinerImpl::run()
  722,960,567 ( 1.66%)  ???:combineInstructionsOverFunction(llvm::Function&, llvm::InstCombineWorklist&, llvm::AAResults*, llvm::AssumptionCache&, llvm::TargetLibraryInfo&, llvm::TargetTransformInfo&, llvm::DominatorTree&, llvm::OptimizationRemarkEmitter&, llvm::BlockFrequencyInfo*, llvm::ProfileSummaryInfo*, unsigned int, llvm::LoopInfo*)
  685,189,685 ( 1.58%)  ./malloc/malloc.c:malloc
  603,518,455 ( 1.39%)  ???:llvm::SelectionDAG::Combine(llvm::CombineLevel, llvm::AAResults*, llvm::CodeGenOpt::Level)
  522,888,869 ( 1.20%)  ???:llvm::BasicAAResult::alias(llvm::MemoryLocation const&, llvm::MemoryLocation const&, llvm::AAQueryInfo&)
  456,836,991 ( 1.05%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::CalculateFromScratch(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::BatchUpdateInfo*)
  428,959,730 ( 0.99%)  ???:llvm::BitstreamCursor::readRecord(unsigned int, llvm::SmallVectorImpl<unsigned long>&, llvm::StringRef*)
  408,689,147 ( 0.94%)  ???:llvm::isPotentiallyReachable(llvm::BasicBlock const*, llvm::BasicBlock const*, llvm::SmallPtrSetImpl<llvm::BasicBlock*> const*, llvm::DominatorTree const*, llvm::LoopInfo const*)
  378,847,919 ( 0.87%)  ???:llvm::ValueHandleBase::AddToUseList()
  364,849,548 ( 0.84%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::runSemiNCA(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, unsigned int)
  357,994,348 ( 0.82%)  ???:(anonymous namespace)::LazyValueInfoImpl::solve() [clone .llvm.4316243980339171764]
  353,108,554 ( 0.81%)  ???:llvm::TargetLibraryInfoImpl::getLibFunc(llvm::Function const&, llvm::LibFunc&) const
  349,284,240 ( 0.80%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::getExitBlocks(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const
  340,382,734 ( 0.78%)  ./malloc/malloc.c:free
  326,902,885 ( 0.75%)  ???:(anonymous namespace)::LazyValueInfoImpl::getEdgeValue(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::Instruction*) [clone .llvm.4316243980339171764]
  305,860,137 ( 0.70%)  ???:llvm::removeUnreachableBlocks(llvm::Function&, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*)
  291,820,390 ( 0.67%)  ./string/../sysdeps/x86_64/multiarch/memcmp-avx2-movbe.S:__memcmp_avx2_movbe
  285,403,093 ( 0.66%)  ???:llvm::AnalysisManager<llvm::Function>::getResultImpl(llvm::AnalysisKey*, llvm::Function&)
  277,752,627 ( 0.64%)  ???:llvm::FPPassManager::runOnFunction(llvm::Function&)
  272,696,181 ( 0.63%)  ???:llvm::AnalysisManager<llvm::Function>::invalidate(llvm::Function&, llvm::PreservedAnalyses const&)
  268,189,853 ( 0.62%)  ???:llvm::InstCombinerImpl::visitCallInst(llvm::CallInst&)
  263,739,432 ( 0.61%)  ???:llvm::LiveVariables::runOnBlock(llvm::MachineBasicBlock*, unsigned int)
  253,382,127 ( 0.58%)  ???:llvm::BasicAAResult::getModRefInfo(llvm::CallBase const*, llvm::MemoryLocation const&, llvm::AAQueryInfo&)
  250,297,974 ( 0.58%)  ???:llvm::PointerMayBeCaptured(llvm::Value const*, llvm::CaptureTracker*, unsigned int)
  248,184,395 ( 0.57%)  ???:computeKnownBits(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&) [clone .llvm.15619146473165121143]
  247,451,513 ( 0.57%)  ???:llvm::DataLayout::getAlignment(llvm::Type*, bool) const
  229,700,915 ( 0.53%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::verifyLoop() const
  228,690,770 ( 0.53%)  ???:llvm::FindFunctionBackedges(llvm::Function const&, llvm::SmallVectorImpl<std::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> >&)
  226,695,565 ( 0.52%)  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S:__memset_avx2_erms
  213,152,635 ( 0.49%)  ???:runCVP(llvm::Module&) [clone .llvm.11785992503873176614]
  211,801,263 ( 0.49%)  ???:bool llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> >, (anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> >::LookupBucketFor<(anonymous namespace)::SimpleValue>((anonymous namespace)::SimpleValue const&, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> const*&) const
  204,480,045 ( 0.47%)  ???:llvm::MemorySSA::buildMemorySSA(llvm::BatchAAResults&)
  203,210,454 ( 0.47%)  ???:SimplifyICmpInst(unsigned int, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int) [clone .llvm.1619516508949622737]
  202,414,597 ( 0.47%)  ???:llvm::SimplifyInstruction(llvm::Instruction*, llvm::SimplifyQuery const&, llvm::OptimizationRemarkEmitter*)
  196,521,966 ( 0.45%)  ???:llvm::MemoryDependenceResults::getNonLocalPointerDepFromBB(llvm::Instruction*, llvm::PHITransAddr const&, llvm::MemoryLocation const&, bool, llvm::BasicBlock*, llvm::SmallVectorImpl<llvm::NonLocalDepResult>&, llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*> >&, bool, bool)
  193,014,710 ( 0.44%)  ???:computeKnownBitsFromOperator(llvm::Operator const*, llvm::APInt const&, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
  190,726,625 ( 0.44%)  ???:llvm::DataLayout::getTypeSizeInBits(llvm::Type*) const
  187,545,762 ( 0.43%)  ???:llvm::AttributeList::addAttributes(llvm::LLVMContext&, unsigned int, llvm::AttrBuilder const&) const
  183,796,182 ( 0.42%)  ???:llvm::simplifyCFG(llvm::BasicBlock*, llvm::TargetTransformInfo const&, llvm::DomTreeUpdater*, llvm::SimplifyCFGOptions const&, llvm::ArrayRef<llvm::WeakVH>)
  179,995,942 ( 0.41%)  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S:__memcpy_avx_unaligned_erms
  166,412,014 ( 0.38%)  ./malloc/malloc.c:malloc_consolidate
  163,181,956 ( 0.38%)  ???:(anonymous namespace)::MachineCopyPropagation::runOnMachineFunction(llvm::MachineFunction&)
  156,876,183 ( 0.36%)  ???:llvm::InstCombinerImpl::visitICmpInst(llvm::ICmpInst&)
  154,690,316 ( 0.36%)  ???:(anonymous namespace)::DeadMachineInstructionElim::eliminateDeadMI(llvm::MachineFunction&)
  150,144,046 ( 0.35%)  ???:llvm::IDFCalculatorBase<llvm::BasicBlock, false>::calculate(llvm::SmallVectorImpl<llvm::BasicBlock*>&)
  149,638,234 ( 0.34%)  ???:llvm::SelectionDAGISel::SelectCodeCommon(llvm::SDNode*, unsigned char const*, unsigned int)
  147,687,811 ( 0.34%)  ???:llvm::InlineFunction(llvm::CallBase&, llvm::InlineFunctionInfo&, llvm::AAResults*, bool, llvm::Function*)
  143,375,487 ( 0.33%)  ???:llvm::AttributeSetNode::get(llvm::LLVMContext&, llvm::AttrBuilder const&)
  141,814,797 ( 0.33%)  ???:llvm::AttributeList::get(llvm::LLVMContext&, llvm::ArrayRef<llvm::AttributeList>)
  140,949,073 ( 0.32%)  ???:isKnownNonZero(llvm::Value const*, llvm::APInt const&, unsigned int, (anonymous namespace)::Query const&) [clone .llvm.15619146473165121143]
  138,436,029 ( 0.32%)  ???:llvm::LiveIntervals::HMEditor::updateAllRanges(llvm::MachineInstr*)
  134,954,723 ( 0.31%)  ???:llvm::SmallPtrSetImplBase::insert_imp_big(void const*)
  132,145,941 ( 0.30%)  ???:llvm::PopulateLoopsDFS<llvm::BasicBlock, llvm::Loop>::traverse(llvm::BasicBlock*)
  130,617,956 ( 0.30%)  ???:(anonymous namespace)::eliminateDeadStores(llvm::Function&, llvm::AAResults&, llvm::MemorySSA&, llvm::DominatorTree&, llvm::PostDominatorTree&, llvm::TargetLibraryInfo const&, llvm::LoopInfo const&) [clone .llvm.5769264623867638418]
  129,243,468 ( 0.30%)  ???:llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop>::analyze(llvm::DominatorTreeBase<llvm::BasicBlock, false> const&)
  127,778,968 ( 0.29%)  ???:llvm::AAResults::getModRefInfo(llvm::Instruction const*, llvm::Optional<llvm::MemoryLocation> const&, llvm::AAQueryInfo&)
  125,890,337 ( 0.29%)  ???:llvm::LiveVariables::HandleRegMask(llvm::MachineOperand const&)
  124,434,671 ( 0.29%)  ???:llvm::GVN::processBlock(llvm::BasicBlock*)
  123,411,876 ( 0.28%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::FindRoots(llvm::DominatorTreeBase<llvm::BasicBlock, true> const&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::BatchUpdateInfo*)
  123,400,512 ( 0.28%)  ???:llvm::AAResults::Model<llvm::BasicAAResult>::getModRefBehavior(llvm::CallBase const*)
  121,469,191 ( 0.28%)  ???:(anonymous namespace)::EarlyCSE::run() [clone .llvm.7062997131228810369]
  119,850,149 ( 0.28%)  ???:computeKnownBitsFromAssume(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
  116,815,858 ( 0.27%)  ???:llvm::LiveIntervals::extendSegmentsToUses(llvm::LiveRange&, llvm::SmallVector<std::pair<llvm::SlotIndex, llvm::VNInfo*>, 16u>&, llvm::Register, llvm::LaneBitmask)
  116,794,807 ( 0.27%)  ./malloc/malloc.c:unlink_chunk.constprop.0
  114,831,365 ( 0.26%)  ???:llvm::SROA::runOnAlloca(llvm::AllocaInst&)
  114,134,138 ( 0.26%)  ???:llvm::Type::isSizedDerivedType(llvm::SmallPtrSetImpl<llvm::Type*>*) const
  112,132,394 ( 0.26%)  /tmp/gcc-build/x86_64-unknown-linux-gnu/libstdc++-v3/libsupc++/../../../../gcc-5.5.0/libstdc++-v3/libsupc++/new_op.cc:operator new(unsigned long)
  111,607,606 ( 0.26%)  ???:llvm::ScheduleDAGSDNodes::BuildSchedUnits()
  109,148,463 ( 0.25%)  ???:(anonymous namespace)::PruningFunctionCloner::CloneBlock(llvm::BasicBlock const*, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, true, false, void>, false, true>, std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> >&)
  107,730,748 ( 0.25%)  ???:(anonymous namespace)::DAGCombiner::combine(llvm::SDNode*)
  107,114,314 ( 0.25%)  ???:llvm::TargetLoweringBase::getTypeConversion(llvm::LLVMContext&, llvm::EVT) const
  106,324,927 ( 0.24%)  ???:llvm::InstCombinerImpl::visitBitCast(llvm::BitCastInst&)
  104,774,620 ( 0.24%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::CalculateFromScratch(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::BatchUpdateInfo*)
  104,671,664 ( 0.24%)  ???:llvm::JumpThreadingPass::processBlock(llvm::BasicBlock*)
  102,410,320 ( 0.24%)  ???:(anonymous namespace)::AggressiveDeadCodeElimination::performDeadCodeElimination()
  102,229,282 ( 0.24%)  ???:llvm::SimplifyGEPInst(llvm::Type*, llvm::ArrayRef<llvm::Value*>, llvm::SimplifyQuery const&)
   97,487,975 ( 0.22%)  ???:(anonymous namespace)::Verifier::visitInstruction(llvm::Instruction&)
   97,487,645 ( 0.22%)  ???:llvm::MemorySSA::OptimizeUses::optimizeUses()
   97,166,871 ( 0.22%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::runSemiNCA(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, unsigned int)
   93,878,427 ( 0.22%)  ???:computeKnownBits(llvm::Value const*, llvm::APInt const&, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
   92,273,357 ( 0.21%)  ???:(anonymous namespace)::SimplifyCFGOpt::simplifyCondBranch(llvm::BranchInst*, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&)
   91,437,455 ( 0.21%)  ???:llvm::MachineInstr::addOperand(llvm::MachineFunction&, llvm::MachineOperand const&)
   91,023,899 ( 0.21%)  ???:llvm::LivePhysRegs::stepBackward(llvm::MachineInstr const&)
   90,270,506 ( 0.21%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::hasDedicatedExits() const
   90,078,365 ( 0.21%)  ???:(anonymous namespace)::CallAnalyzer::analyze()
   87,603,056 ( 0.20%)  ???:(anonymous namespace)::StackColoring::runOnMachineFunction(llvm::MachineFunction&)
   86,747,907 ( 0.20%)  ???:llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>::initializeRPOT()
   85,990,755 ( 0.20%)  ???:runImpl(llvm::Function&, llvm::LazyValueInfo*, llvm::DominatorTree*, llvm::SimplifyQuery const&) [clone .llvm.16011871802505272439]
   85,716,327 ( 0.20%)  ???:llvm::InterferenceCache::Entry::update(unsigned int)
   84,392,063 ( 0.19%)  ???:llvm::InstCombinerImpl::visitLoadInst(llvm::LoadInst&)
   80,555,715 ( 0.19%)  ???:updateCGAndAnalysisManagerForPass(llvm::LazyCallGraph&, llvm::LazyCallGraph::SCC&, llvm::LazyCallGraph::Node&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::CGSCCUpdateResult&, llvm::AnalysisManager<llvm::Function>&, bool) [clone .llvm.5426518467876156712]
   79,879,876 ( 0.18%)  ???:llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>::tryToComputeMassInFunction()
   79,738,749 ( 0.18%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::getExitingBlock() const
   78,649,219 ( 0.18%)  ???:llvm::InstCombinerImpl::visitInvokeInst(llvm::InvokeInst&)
   78,518,743 ( 0.18%)  ???:std::back_insert_iterator<std::vector<llvm::BasicBlock*, std::allocator<llvm::BasicBlock*> > > std::__copy_move_a<false, llvm::po_iterator<llvm::Function*, llvm::SmallPtrSet<llvm::BasicBlock*, 8u>, false, llvm::GraphTraits<llvm::Function*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock*, std::allocator<llvm::BasicBlock*> > > >(llvm::po_iterator<llvm::Function*, llvm::SmallPtrSet<llvm::BasicBlock*, 8u>, false, llvm::GraphTraits<llvm::Function*> >, llvm::po_iterator<llvm::Function*, llvm::SmallPtrSet<llvm::BasicBlock*, 8u>, false, llvm::GraphTraits<llvm::Function*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock*, std::allocator<llvm::BasicBlock*> > >)
   78,053,453 ( 0.18%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false> >::runSemiNCA(llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>&, unsigned int)
   77,825,831 ( 0.18%)  ???:llvm::X86InstrInfo::analyzeBranch(llvm::MachineBasicBlock&, llvm::MachineBasicBlock*&, llvm::MachineBasicBlock*&, llvm::SmallVectorImpl<llvm::MachineOperand>&, bool) const
   77,596,102 ( 0.18%)  ???:llvm::DemandedBits::isInstructionDead(llvm::Instruction*)
   77,114,927 ( 0.18%)  ???:std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > std::__copy_move_a2<false, llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > >(llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > >)
   76,933,408 ( 0.18%)  ???:llvm::coro::declaresIntrinsics(llvm::Module const&, std::initializer_list<llvm::StringRef>)
   76,289,482 ( 0.18%)  ???:llvm::ConstantFoldTerminator(llvm::BasicBlock*, bool, llvm::TargetLibraryInfo const*, llvm::DomTreeUpdater*)
   75,845,234 ( 0.17%)  ???:llvm::ScalarEvolution::getAddExpr(llvm::SmallVectorImpl<llvm::SCEV const*>&, llvm::SCEV::NoWrapFlags, unsigned int)
   74,991,511 ( 0.17%)  ???:llvm::AAResults::Model<llvm::BasicAAResult>::pointsToConstantMemory(llvm::MemoryLocation const&, llvm::AAQueryInfo&, bool)
   73,293,890 ( 0.17%)  ???:llvm::DAGTypeLegalizer::run()
   73,255,677 ( 0.17%)  ???:llvm::getObjectSize(llvm::Value const*, unsigned long&, llvm::DataLayout const&, llvm::TargetLibraryInfo const*, llvm::ObjectSizeOpts)
   72,947,306 ( 0.17%)  ???:llvm::LiveRangeCalc::findReachingDefs(llvm::LiveRange&, llvm::MachineBasicBlock&, llvm::SlotIndex, unsigned int, llvm::ArrayRef<llvm::SlotIndex>)
   71,590,383 ( 0.16%)  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S:__memset_avx2_unaligned_erms
   71,476,288 ( 0.16%)  ???:llvm::BlockFrequencyInfoImplBase::finalizeMetrics()
   70,331,417 ( 0.16%)  ???:llvm::ReassociatePass::BuildRankMap(llvm::Function&, llvm::ReversePostOrderTraversal<llvm::Function*, llvm::GraphTraits<llvm::Function*> >&)
   70,195,584 ( 0.16%)  ./string/../sysdeps/x86_64/multiarch/strcmp-avx2.S:__strncmp_avx2
   70,113,771 ( 0.16%)  /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs:rustc_expand::mbe::macro_parser::parse_tt
   69,962,529 ( 0.16%)  ???:llvm::SelectionDAG::Legalize()
   68,902,741 ( 0.16%)  ???:llvm::InstrEmitter::EmitMachineNode(llvm::SDNode*, bool, bool, llvm::DenseMap<llvm::SDValue, llvm::Register, llvm::DenseMapInfo<llvm::SDValue>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::Register> >&)
   68,700,030 ( 0.16%)  ???:(anonymous namespace)::SelectionDAGLegalize::LegalizeOp(llvm::SDNode*) [clone .llvm.8386621111310650999]
   68,281,158 ( 0.16%)  ???:llvm::LivePhysRegs::addPristines(llvm::MachineFunction const&)
   67,295,868 ( 0.15%)  ???:llvm::SelectionDAG::MorphNodeTo(llvm::SDNode*, unsigned int, llvm::SDVTList, llvm::ArrayRef<llvm::SDValue>)
   67,288,194 ( 0.15%)  ???:llvm::ConstantRange::makeExactICmpRegion(llvm::CmpInst::Predicate, llvm::APInt const&)
   65,717,434 ( 0.15%)  ???:llvm::BranchProbabilityInfo::SccInfo::SccInfo(llvm::Function const&)
   65,592,487 ( 0.15%)  ???:llvm::Value::stripAndAccumulateConstantOffsets(llvm::DataLayout const&, llvm::APInt&, bool, llvm::function_ref<bool (llvm::Value&, llvm::APInt&)>) const
   65,537,387 ( 0.15%)  ./stdlib/msort.c:msort_with_tmp.part.0
   65,222,763 ( 0.15%)  ???:llvm::BranchProbabilityInfo::setEdgeProbability(llvm::BasicBlock const*, llvm::SmallVectorImpl<llvm::BranchProbability> const&)
   64,884,230 ( 0.15%)  ???:llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&)
   64,695,809 ( 0.15%)  ???:(anonymous namespace)::ClobberWalker<llvm::BatchAAResults>::addSearches(llvm::MemoryPhi*, llvm::SmallVectorImpl<unsigned int>&, unsigned int)
   63,540,695 ( 0.15%)  ???:llvm::ReachingDefAnalysis::enterBasicBlock(llvm::MachineBasicBlock*)
   62,720,818 ( 0.14%)  ???:llvm::BranchProbabilityInfo::calcEstimatedHeuristics(llvm::BasicBlock const*)
   62,185,076 ( 0.14%)  ???:llvm::ScopedNoAliasAAResult::getModRefInfo(llvm::CallBase const*, llvm::MemoryLocation const&, llvm::AAQueryInfo&)
   61,332,240 ( 0.14%)  ???:llvm::FoldingSetBase::FindNodeOrInsertPos(llvm::FoldingSetNodeID const&, void*&, llvm::FoldingSetBase::FoldingSetInfo const&)
   60,406,994 ( 0.14%)  ???:(anonymous namespace)::LazyValueInfoImpl::getValueInBlock(llvm::Value*, llvm::BasicBlock*, llvm::Instruction*) [clone .llvm.4316243980339171764]
   60,244,936 ( 0.14%)  ???:(anonymous namespace)::BitcodeReader::parseModule(unsigned long, bool, llvm::function_ref<llvm::Optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > (llvm::StringRef)>)
   60,132,046 ( 0.14%)  ???:llvm::SelectionDAG::getConstant(llvm::ConstantInt const&, llvm::SDLoc const&, llvm::EVT, bool, bool)
   59,686,395 ( 0.14%)  ???:llvm::BranchProbabilityInfo::calculate(llvm::Function const&, llvm::LoopInfo const&, llvm::TargetLibraryInfo const*, llvm::DominatorTree*, llvm::PostDominatorTree*)
   58,623,992 ( 0.13%)  ???:llvm::DenseMapBase<llvm::DenseMap<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> >, llvm::DenseMapInfo<llvm::PoisoningVH<llvm::BasicBlock> >, llvm::detail::DenseMapPair<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> > > >, llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> >, llvm::DenseMapInfo<llvm::PoisoningVH<llvm::BasicBlock> >, llvm::detail::DenseMapPair<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> > > >::destroyAll() [clone .llvm.4316243980339171764]
   58,258,540 ( 0.13%)  ???:llvm::LiveRange::extendInBlock(llvm::ArrayRef<llvm::SlotIndex>, llvm::SlotIndex, llvm::SlotIndex)
   57,925,918 ( 0.13%)  ???:llvm::Loop::isLCSSAForm(llvm::DominatorTree const&) const
   57,710,789 ( 0.13%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false> >::CalculateFromScratch(llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false> >::BatchUpdateInfo*)
   57,483,986 ( 0.13%)  ???:(anonymous namespace)::RAGreedy::growRegion((anonymous namespace)::RAGreedy::GlobalSplitCandidate&)
   57,054,370 ( 0.13%)  ???:???
   56,768,991 ( 0.13%)  ???:llvm::InstCombinerImpl::SimplifyDemandedUseBits(llvm::Value*, llvm::APInt, llvm::KnownBits&, unsigned int, llvm::Instruction*)
   56,485,826 ( 0.13%)  ???:llvm::Loop::isRecursivelyLCSSAForm(llvm::DominatorTree const&, llvm::LoopInfo const&) const
   56,010,601 ( 0.13%)  ???:llvm::FoldBranchToCommonDest(llvm::BranchInst*, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*, llvm::TargetTransformInfo const*, unsigned int)
   55,464,235 ( 0.13%)  ???:llvm::InstCombinerImpl::visitAllocSite(llvm::Instruction&)
   54,927,214 ( 0.13%)  ???:llvm::BlockFrequencyInfoImplBase::distributeMass(llvm::BlockFrequencyInfoImplBase::BlockNode const&, llvm::BlockFrequencyInfoImplBase::LoopData*, llvm::BlockFrequencyInfoImplBase::Distribution&)
   54,925,868 ( 0.13%)  ???:llvm::MD5::final(llvm::MD5::MD5Result&)
   54,881,494 ( 0.13%)  ???:(anonymous namespace)::CVPLatticeFunc::ComputeInstructionState(llvm::Instruction&, llvm::DenseMap<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal, llvm::DenseMapInfo<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > > >, llvm::detail::DenseMapPair<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal> >&, llvm::SparseSolver<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal, llvm::LatticeKeyInfo<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > > > >&)
   54,564,900 ( 0.13%)  ???:llvm::ReachingDefAnalysis::traverse()
   53,575,562 ( 0.12%)  ???:llvm::SCCPInstVisitor::solve()
   52,661,909 ( 0.12%)  ???:llvm::InstCombinerImpl::visitAllocaInst(llvm::AllocaInst&)
   52,117,772 ( 0.12%)  ./string/../sysdeps/x86_64/multiarch/memchr-avx2.S:__memchr_avx2
   50,813,157 ( 0.12%)  ???:llvm::Intrinsic::getDeclaration(llvm::Module*, unsigned int, llvm::ArrayRef<llvm::Type*>)
   50,541,808 ( 0.12%)  ???:(anonymous namespace)::ScheduleDAGRRList::Schedule() [clone .llvm.6953762222372402862]
   50,537,949 ( 0.12%)  ???:llvm::JumpThreadingPass::runImpl(llvm::Function&, llvm::TargetLibraryInfo*, llvm::LazyValueInfo*, llvm::AAResults*, llvm::DomTreeUpdater*, bool, std::unique_ptr<llvm::BlockFrequencyInfo, std::default_delete<llvm::BlockFrequencyInfo> >, std::unique_ptr<llvm::BranchProbabilityInfo, std::default_delete<llvm::BranchProbabilityInfo> >)
   49,965,624 ( 0.11%)  ???:llvm::PMDataManager::verifyPreservedAnalysis(llvm::Pass*)
   49,406,490 ( 0.11%)  ???:llvm::TargetTransformInfo::Model<llvm::X86TTIImpl>::getUserCost(llvm::User const*, llvm::ArrayRef<llvm::Value const*>, llvm::TargetTransformInfo::TargetCostKind)
   48,927,852 ( 0.11%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::getExitingBlocks(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const
   48,329,990 ( 0.11%)  ???:llvm::Optional<unsigned int> llvm::BranchProbabilityInfo::getMaxEstimatedEdgeWeight<llvm::BasicBlock**>(llvm::BranchProbabilityInfo::LoopBlock const&, llvm::iterator_range<llvm::BasicBlock**>) const
   48,232,743 ( 0.11%)  ???:llvm::SCCPInstVisitor::visitTerminator(llvm::Instruction&)
   47,829,132 ( 0.11%)  /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_parse/src/parser/mod.rs:<rustc_parse::parser::TokenCursor>::next
   47,756,928 ( 0.11%)  ???:llvm::MemoryLocation::get(llvm::LoadInst const*)
   47,735,430 ( 0.11%)  /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs:rustc_expand::mbe::macro_parser::parse_tt
   47,719,123 ( 0.11%)  ???:llvm::MD5::update(llvm::StringRef)
   47,467,422 ( 0.11%)  ???:llvm::AttributeList::addAttribute(llvm::LLVMContext&, unsigned int, llvm::Attribute::AttrKind) const
   47,382,247 ( 0.11%)  /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_parse/src/parser/mod.rs:<rustc_parse::parser::Parser>::bump
   47,314,040 ( 0.11%)  ???:void llvm::getUniqueExitBlocksHelper<llvm::BasicBlock, llvm::LoopBase<llvm::BasicBlock, llvm::Loop>, llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::getUniqueExitBlocks(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const::{lambda(llvm::BasicBlock const*)#1}>(llvm::LoopBase<llvm::BasicBlock, llvm::Loop> const*, llvm::SmallVectorImpl<llvm::BasicBlock*>&, llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::getUniqueExitBlocks(llvm::SmallVectorImpl<llvm::BasicBlock*>&) const::{lambda(llvm::BasicBlock const*)#1})
   47,149,660 ( 0.11%)  ???:llvm::MergeBlockIntoPredecessor(llvm::BasicBlock*, llvm::DomTreeUpdater*, llvm::LoopInfo*, llvm::MemorySSAUpdater*, llvm::MemoryDependenceResults*, bool)
   46,474,003 ( 0.11%)  ???:llvm::InstCombinerImpl::visitStoreInst(llvm::StoreInst&)
   46,354,210 ( 0.11%)  ???:llvm::ReassociatePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&)
   46,203,403 ( 0.11%)  ???:llvm::BranchProbabilityInfo::computeEestimateBlockWeight(llvm::Function const&, llvm::DominatorTree*, llvm::PostDominatorTree*)
   45,884,079 ( 0.11%)  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S:__memcpy_sse2_unaligned_erms
   45,695,289 ( 0.11%)  ???:llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec, llvm::DenseMapInfo<llvm::BasicBlock*>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec> >, llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec, llvm::DenseMapInfo<llvm::BasicBlock*>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec> >::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec>*, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::InfoRec>*)
   45,618,066 ( 0.10%)  ???:llvm::LiveIntervals::checkRegMaskInterference(llvm::LiveInterval&, llvm::BitVector&)
   44,217,162 ( 0.10%)  ???:llvm::ScalarEvolution::getSCEV(llvm::Value*)
   44,214,009 ( 0.10%)  ???:llvm::Type::getPrimitiveSizeInBits() const
   44,023,621 ( 0.10%)  ???:std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > std::__copy_move_a<false, llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > >(llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*> >, llvm::po_iterator<llvm::BasicBlock const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::BasicBlock const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > >)
   44,012,896 ( 0.10%)  ???:llvm::LoopBlocksDFS::perform(llvm::LoopInfo*)
   43,618,688 ( 0.10%)  ???:llvm::MDTuple::getImpl(llvm::LLVMContext&, llvm::ArrayRef<llvm::Metadata*>, llvm::Metadata::StorageType, bool)
   43,553,965 ( 0.10%)  ???:llvm::MachineInstr::isIdenticalTo(llvm::MachineInstr const&, llvm::MachineInstr::MICheckType) const

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs
--------------------------------------------------------------------------------
Ir                  

-- line 90 ----------------------------------------
         .           use std::collections::hash_map::Entry::{Occupied, Vacant};
         .           use std::mem;
         .           use std::ops::{Deref, DerefMut};
         .           
         .           // To avoid costly uniqueness checks, we require that `MatchSeq` always has a nonempty body.
         .           
         .           /// Either a sequence of token trees or a single one. This is used as the representation of the
         .           /// sequence of tokens that make up a matcher.
   684,823 ( 0.00%)  #[derive(Clone)]
         .           enum TokenTreeOrTokenTreeSlice<'tt> {
       423 ( 0.00%)      Tt(TokenTree),
   168,662 ( 0.00%)      TtSeq(&'tt [TokenTree]),
         .           }
         .           
         .           impl<'tt> TokenTreeOrTokenTreeSlice<'tt> {
         .               /// Returns the number of constituent top-level token trees of `self` (top-level in that it
         .               /// will not recursively descend into subtrees).
         .               fn len(&self) -> usize {
 3,420,036 ( 0.01%)          match *self {
   751,760 ( 0.00%)              TtSeq(ref v) => v.len(),
         .                       Tt(ref tt) => tt.len(),
         .                   }
         .               }
         .           
         .               /// The `index`-th token tree of `self`.
         .               fn get_tt(&self, index: usize) -> TokenTree {
   737,564 ( 0.00%)          match *self {
 2,330,848 ( 0.01%)              TtSeq(ref v) => v[index].clone(),
   845,721 ( 0.00%)              Tt(ref tt) => tt.get_tt(index),
         .                   }
         .               }
         .           }
         .           
         .           /// An unzipping of `TokenTree`s... see the `stack` field of `MatcherPos`.
         .           ///
         .           /// This is used by `inner_parse_loop` to keep track of delimited submatchers that we have
         .           /// descended into.
   106,786 ( 0.00%)  #[derive(Clone)]
         .           struct MatcherTtFrame<'tt> {
         .               /// The "parent" matcher that we are descending into.
         .               elts: TokenTreeOrTokenTreeSlice<'tt>,
         .               /// The position of the "dot" in `elts` at the time we descended.
    53,393 ( 0.00%)      idx: usize,
         .           }
         .           
         .           type NamedMatchVec = SmallVec<[NamedMatch; 4]>;
         .           
         .           /// Represents a single "position" (aka "matcher position", aka "item"), as
         .           /// described in the module documentation.
         .           ///
         .           /// Here:
-- line 140 ----------------------------------------
-- line 147 ----------------------------------------
         .           ///   position refers to.
         .           ///
         .           /// It is important to distinguish these two lifetimes because we have a
         .           /// `SmallVec<TokenTreeOrTokenTreeSlice<'tt>>` below, and the destructor of
         .           /// that is considered to possibly access the data from its elements (it lacks
         .           /// a `#[may_dangle]` attribute). As a result, the compiler needs to know that
         .           /// all the elements in that `SmallVec` strictly outlive the root stack slot
         .           /// lifetime. By separating `'tt` from `'root`, we can show that.
 2,921,426 ( 0.01%)  #[derive(Clone)]
         .           struct MatcherPos<'root, 'tt> {
         .               /// The token or sequence of tokens that make up the matcher
         .               top_elts: TokenTreeOrTokenTreeSlice<'tt>,
         .           
         .               /// The position of the "dot" in this matcher
    62,158 ( 0.00%)      idx: usize,
         .           
         .               /// For each named metavar in the matcher, we keep track of token trees matched against the
         .               /// metavar by the black box parser. In particular, there may be more than one match per
         .               /// metavar if we are in a repetition (each repetition matches each of the variables).
         .               /// Moreover, matchers and repetitions can be nested; the `matches` field is shared (hence the
         .               /// `Rc`) among all "nested" matchers. `match_lo`, `match_cur`, and `match_hi` keep track of
         .               /// the current position of the `self` matcher position in the shared `matches` list.
         .               ///
         .               /// Also, note that while we are descending into a sequence, matchers are given their own
         .               /// `matches` vector. Only once we reach the end of a full repetition of the sequence do we add
         .               /// all bound matches from the submatcher into the shared top-level `matches` vector. If `sep`
         .               /// and `up` are `Some`, then `matches` is _not_ the shared top-level list. Instead, if one
         .               /// wants the shared `matches`, one should use `up.matches`.
   248,632 ( 0.00%)      matches: Box<[Lrc<NamedMatchVec>]>,
         .               /// The position in `matches` corresponding to the first metavar in this matcher's sequence of
         .               /// token trees. In other words, the first metavar in the first token of `top_elts` corresponds
         .               /// to `matches[match_lo]`.
    62,158 ( 0.00%)      match_lo: usize,
         .               /// The position in `matches` corresponding to the metavar we are currently trying to match
         .               /// against the source token stream. `match_lo <= match_cur <= match_hi`.
         .               match_cur: usize,
         .               /// Similar to `match_lo` except `match_hi` is the position in `matches` of the _last_ metavar
         .               /// in this matcher.
    62,158 ( 0.00%)      match_hi: usize,
         .           
         .               // The following fields are used if we are matching a repetition. If we aren't, they should be
         .               // `None`.
         .               /// The KleeneOp of this sequence if we are in a repetition.
    62,158 ( 0.00%)      seq_op: Option<mbe::KleeneOp>,
         .           
         .               /// The separator if we are in a repetition.
         .               sep: Option<Token>,
         .           
         .               /// The "parent" matcher position if we are in a repetition. That is, the matcher position just
         .               /// before we enter the sequence.
   124,316 ( 0.00%)      up: Option<MatcherPosHandle<'root, 'tt>>,
         .           
         .               /// Specifically used to "unzip" token trees. By "unzip", we mean to unwrap the delimiters from
         .               /// a delimited token tree (e.g., something wrapped in `(` `)`) or to get the contents of a doc
         .               /// comment...
         .               ///
         .               /// When matching against matchers with nested delimited submatchers (e.g., `pat ( pat ( .. )
         .               /// pat ) pat`), we need to keep track of the matchers we are descending into. This stack does
         .               /// that where the bottom of the stack is the outermost matcher.
         .               /// Also, throughout the comments, this "descent" is often referred to as "unzipping"...
         .               stack: SmallVec<[MatcherTtFrame<'tt>; 1]>,
         .           }
         .           
         .           impl<'root, 'tt> MatcherPos<'root, 'tt> {
         .               /// Adds `m` as a named match for the `idx`-th metavar.
         .               fn push_match(&mut self, idx: usize, m: NamedMatch) {
 1,388,596 ( 0.00%)          let matches = Lrc::make_mut(&mut self.matches[idx]);
         .                   matches.push(m);
         .               }
         .           }
         .           
         .           // Lots of MatcherPos instances are created at runtime. Allocating them on the
         .           // heap is slow. Furthermore, using SmallVec<MatcherPos> to allocate them all
         .           // on the stack is also slow, because MatcherPos is quite a large type and
         .           // instances get moved around a lot between vectors, which requires lots of
-- line 221 ----------------------------------------
-- line 226 ----------------------------------------
         .           // and this type is used to encapsulate both cases.
         .           enum MatcherPosHandle<'root, 'tt> {
         .               Ref(&'root mut MatcherPos<'root, 'tt>),
         .               Box(Box<MatcherPos<'root, 'tt>>),
         .           }
         .           
         .           impl<'root, 'tt> Clone for MatcherPosHandle<'root, 'tt> {
         .               // This always produces a new Box.
   248,632 ( 0.00%)      fn clone(&self) -> Self {
   124,316 ( 0.00%)          MatcherPosHandle::Box(match *self {
    62,184 ( 0.00%)              MatcherPosHandle::Ref(ref r) => Box::new((**r).clone()),
         .                       MatcherPosHandle::Box(ref b) => b.clone(),
         .                   })
   372,948 ( 0.00%)      }
         .           }
         .           
         .           impl<'root, 'tt> Deref for MatcherPosHandle<'root, 'tt> {
         .               type Target = MatcherPos<'root, 'tt>;
         .               fn deref(&self) -> &Self::Target {
         .                   match *self {
         .                       MatcherPosHandle::Ref(ref r) => r,
         .                       MatcherPosHandle::Box(ref b) => b,
-- line 247 ----------------------------------------
-- line 272 ----------------------------------------
         .           
         .           /// A `ParseResult` where the `Success` variant contains a mapping of
         .           /// `MacroRulesNormalizedIdent`s to `NamedMatch`es. This represents the mapping
         .           /// of metavars to the token trees they bind to.
         .           crate type NamedParseResult = ParseResult<FxHashMap<MacroRulesNormalizedIdent, NamedMatch>>;
         .           
         .           /// Count how many metavars are named in the given matcher `ms`.
         .           pub(super) fn count_names(ms: &[TokenTree]) -> usize {
 2,295,552 ( 0.01%)      ms.iter().fold(0, |count, elt| {
 1,147,776 ( 0.00%)          count
 3,443,328 ( 0.01%)              + match *elt {
    79,982 ( 0.00%)                  TokenTree::Sequence(_, ref seq) => seq.num_captures,
    73,007 ( 0.00%)                  TokenTree::Delimited(_, ref delim) => count_names(&delim.tts),
         .                           TokenTree::MetaVar(..) => 0,
         .                           TokenTree::MetaVarDecl(..) => 1,
         .                           TokenTree::Token(..) => 0,
         .                       }
 2,869,440 ( 0.01%)      })
         .           }
         .           
         .           /// `len` `Vec`s (initially shared and empty) that will store matches of metavars.
         .           fn create_matches(len: usize) -> Box<[Lrc<NamedMatchVec>]> {
   384,421 ( 0.00%)      if len == 0 {
         .                   vec![]
         .               } else {
         .                   let empty_matches = Lrc::new(SmallVec::new());
         .                   vec![empty_matches; len]
         .               }
         .               .into_boxed_slice()
         .           }
         .           
         .           /// Generates the top-level matcher position in which the "dot" is before the first token of the
         .           /// matcher `ms`.
         .           fn initial_matcher_pos<'root, 'tt>(ms: &'tt [TokenTree]) -> MatcherPos<'root, 'tt> {
         .               let match_idx_hi = count_names(ms);
         .               let matches = create_matches(match_idx_hi);
 1,864,560 ( 0.00%)      MatcherPos {
         .                   // Start with the top level matcher given to us
         .                   top_elts: TtSeq(ms), // "elts" is an abbr. for "elements"
         .                   // The "dot" is before the first token of the matcher
         .                   idx: 0,
         .           
         .                   // Initialize `matches` to a bunch of empty `Vec`s -- one for each metavar in `top_elts`.
         .                   // `match_lo` for `top_elts` is 0 and `match_hi` is `matches.len()`. `match_cur` is 0 since
         .                   // we haven't actually matched anything yet.
-- line 316 ----------------------------------------
-- line 340 ----------------------------------------
         .           /// particular token tree.
         .           ///
         .           /// The width of each `MatchedSeq` in the `NamedMatch`, and the identity of
         .           /// the `MatchedNonterminal`s, will depend on the token tree it was applied
         .           /// to: each `MatchedSeq` corresponds to a single `TTSeq` in the originating
         .           /// token tree. The depth of the `NamedMatch` structure will therefore depend
         .           /// only on the nesting depth of `ast::TTSeq`s in the originating
         .           /// token tree it was derived from.
     5,212 ( 0.00%)  #[derive(Debug, Clone)]
         .           crate enum NamedMatch {
         .               MatchedSeq(Lrc<NamedMatchVec>),
         .               MatchedNonterminal(Lrc<Nonterminal>),
         .           }
         .           
         .           /// Takes a sequence of token trees `ms` representing a matcher which successfully matched input
         .           /// and an iterator of items that matched input and produces a `NamedParseResult`.
         .           fn nameize<I: Iterator<Item = NamedMatch>>(
-- line 356 ----------------------------------------
-- line 357 ----------------------------------------
         .               sess: &ParseSess,
         .               ms: &[TokenTree],
         .               mut res: I,
         .           ) -> NamedParseResult {
         .               // Recursively descend into each type of matcher (e.g., sequences, delimited, metavars) and make
         .               // sure that each metavar has _exactly one_ binding. If a metavar does not have exactly one
         .               // binding, then there is an error. If it does, then we insert the binding into the
         .               // `NamedParseResult`.
   854,788 ( 0.00%)      fn n_rec<I: Iterator<Item = NamedMatch>>(
         .                   sess: &ParseSess,
         .                   m: &TokenTree,
         .                   res: &mut I,
         .                   ret_val: &mut FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
         .               ) -> Result<(), (rustc_span::Span, String)> {
   505,832 ( 0.00%)          match *m {
         .                       TokenTree::Sequence(_, ref seq) => {
     5,714 ( 0.00%)                  for next_m in &seq.tts {
    34,674 ( 0.00%)                      n_rec(sess, next_m, res.by_ref(), ret_val)?
         .                           }
         .                       }
         .                       TokenTree::Delimited(_, ref delim) => {
     7,691 ( 0.00%)                  for next_m in &delim.tts {
    47,430 ( 0.00%)                      n_rec(sess, next_m, res.by_ref(), ret_val)?;
         .                           }
         .                       }
         .                       TokenTree::MetaVarDecl(span, _, None) => {
         .                           if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
         .                               return Err((span, "missing fragment specifier".to_string()));
         .                           }
         .                       }
   351,876 ( 0.00%)              TokenTree::MetaVarDecl(sp, bind_name, _) => match ret_val
   234,584 ( 0.00%)                  .entry(MacroRulesNormalizedIdent::new(bind_name))
         .                       {
         .                           Vacant(spot) => {
         .                               spot.insert(res.next().unwrap());
         .                           }
         .                           Occupied(..) => return Err((sp, format!("duplicated bind name: {}", bind_name))),
         .                       },
         .                       TokenTree::MetaVar(..) | TokenTree::Token(..) => (),
         .                   }
         .           
    77,708 ( 0.00%)          Ok(())
   621,664 ( 0.00%)      }
         .           
         .               let mut ret_val = FxHashMap::default();
         .               for m in ms {
   568,232 ( 0.00%)          match n_rec(sess, m, res.by_ref(), &mut ret_val) {
         .                       Ok(_) => {}
         .                       Err((sp, msg)) => return Error(sp, msg),
         .                   }
         .               }
         .           
   101,511 ( 0.00%)      Success(ret_val)
         .           }
         .           
         .           /// Performs a token equality check, ignoring syntax context (that is, an unhygienic comparison)
         .           fn token_name_eq(t1: &Token, t2: &Token) -> bool {
   987,682 ( 0.00%)      if let (Some((ident1, is_raw1)), Some((ident2, is_raw2))) = (t1.ident(), t2.ident()) {
       128 ( 0.00%)          ident1.name == ident2.name && is_raw1 == is_raw2
 1,381,310 ( 0.00%)      } else if let (Some(ident1), Some(ident2)) = (t1.lifetime(), t2.lifetime()) {
         .                   ident1.name == ident2.name
         .               } else {
   591,817 ( 0.00%)          t1.kind == t2.kind
         .               }
         .           }
         .           
         .           /// Process the matcher positions of `cur_items` until it is empty. In the process, this will
         .           /// produce more items in `next_items`, `eof_items`, and `bb_items`.
         .           ///
         .           /// For more info about the how this happens, see the module-level doc comments and the inline
         .           /// comments of this function.
-- line 427 ----------------------------------------
-- line 443 ----------------------------------------
         .               sess: &ParseSess,
         .               cur_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
         .               next_items: &mut Vec<MatcherPosHandle<'root, 'tt>>,
         .               eof_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
         .               bb_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
         .               token: &Token,
         .           ) -> ParseResult<()> {
         .               // Pop items from `cur_items` until it is empty.
 2,395,204 ( 0.01%)      while let Some(mut item) = cur_items.pop() {
         .                   // When unzipped trees end, remove them. This corresponds to backtracking out of a
         .                   // delimited submatcher into which we already descended. In backtracking out again, we need
         .                   // to advance the "dot" past the delimiters in the outer matcher.
 7,370,788 ( 0.02%)          while item.idx >= item.top_elts.len() {
    18,022 ( 0.00%)              match item.stack.pop() {
         .                           Some(MatcherTtFrame { elts, idx }) => {
    81,099 ( 0.00%)                      item.top_elts = elts;
    36,044 ( 0.00%)                      item.idx = idx + 1;
         .                           }
         .                           None => break,
         .                       }
         .                   }
         .           
         .                   // Get the current position of the "dot" (`idx`) in `item` and the number of token trees in
         .                   // the matcher (`len`).
         .                   let idx = item.idx;
         .                   let len = item.top_elts.len();
         .           
         .                   // If `idx >= len`, then we are at or past the end of the matcher of `item`.
 1,609,911 ( 0.00%)          if idx >= len {
         .                       // We are repeating iff there is a parent. If the matcher is inside of a repetition,
         .                       // then we could be at the end of a sequence or at the beginning of the next
         .                       // repetition.
    75,105 ( 0.00%)              if item.up.is_some() {
         .                           // At this point, regardless of whether there is a separator, we should add all
         .                           // matches from the complete repetition of the sequence to the shared, top-level
         .                           // `matches` list (actually, `up.matches`, which could itself not be the top-level,
         .                           // but anyway...). Moreover, we add another item to `cur_items` in which the "dot"
         .                           // is at the end of the `up` matcher. This ensures that the "dot" in the `up`
         .                           // matcher is also advanced sufficiently.
         .                           //
         .                           // NOTE: removing the condition `idx == len` allows trailing separators.
   111,534 ( 0.00%)                  if idx == len {
         .                               // Get the `up` matcher
         .                               let mut new_pos = item.up.clone().unwrap();
         .           
         .                               // Add matches from this repetition to the `matches` of `up`
   111,214 ( 0.00%)                      for idx in item.match_lo..item.match_hi {
   277,985 ( 0.00%)                          let sub = item.matches[idx].clone();
   166,791 ( 0.00%)                          new_pos.push_match(idx, MatchedSeq(sub));
         .                               }
         .           
         .                               // Move the "dot" past the repetition in `up`
   111,090 ( 0.00%)                      new_pos.match_cur = item.match_hi;
   333,642 ( 0.00%)                      new_pos.idx += 1;
         .                               cur_items.push(new_pos);
         .                           }
         .           
         .                           // Check if we need a separator.
    55,607 ( 0.00%)                  if idx == len && item.sep.is_some() {
         .                               // We have a separator, and it is the current token. We can advance past the
         .                               // separator token.
       346 ( 0.00%)                      if item.sep.as_ref().map_or(false, |sep| token_name_eq(token, sep)) {
     1,120 ( 0.00%)                          item.idx += 1;
         .                                   next_items.push(item);
         .                               }
         .                           }
         .                           // We don't need a separator. Move the "dot" back to the beginning of the matcher
         .                           // and try to match again UNLESS we are only allowed to have _one_ repetition.
    55,594 ( 0.00%)                  else if item.seq_op != Some(mbe::KleeneOp::ZeroOrOne) {
   111,148 ( 0.00%)                      item.match_cur = item.match_lo;
   222,296 ( 0.00%)                      item.idx = 0;
         .                               cur_items.push(item);
         .                           }
         .                       }
         .                       // If we are not in a repetition, then being at the end of a matcher means that we have
         .                       // reached the potential end of the input.
         .                       else {
         .                           eof_items.push(item);
         .                       }
         .                   }
         .                   // We are in the middle of a matcher.
         .                   else {
         .                       // Look at what token in the matcher we are trying to match the current token (`token`)
         .                       // against. Depending on that, we may generate new items.
 2,380,526 ( 0.01%)              match item.top_elts.get_tt(idx) {
         .                           // Need to descend into a sequence
    31,514 ( 0.00%)                  TokenTree::Sequence(sp, seq) => {
         .                               // Examine the case where there are 0 matches of this sequence. We are
         .                               // implicitly disallowing OneOrMore from having 0 matches here. Thus, that will
         .                               // result in a "no rules expected token" error by virtue of this matcher not
         .                               // working.
    13,210 ( 0.00%)                      if seq.kleene.op == mbe::KleeneOp::ZeroOrMore
         .                                   || seq.kleene.op == mbe::KleeneOp::ZeroOrOne
         .                               {
    13,102 ( 0.00%)                          let mut new_item = item.clone();
    26,204 ( 0.00%)                          new_item.match_cur += seq.num_captures;
    32,755 ( 0.00%)                          new_item.idx += 1;
    39,306 ( 0.00%)                          for idx in item.match_cur..item.match_cur + seq.num_captures {
    19,041 ( 0.00%)                              new_item.push_match(idx, MatchedSeq(Lrc::new(smallvec![])));
         .                                   }
         .                                   cur_items.push(new_item);
         .                               }
         .           
     6,605 ( 0.00%)                      let matches = create_matches(item.matches.len());
    79,260 ( 0.00%)                      cur_items.push(MatcherPosHandle::Box(Box::new(MatcherPos {
     6,605 ( 0.00%)                          stack: smallvec![],
         .                                   sep: seq.separator.clone(),
     6,605 ( 0.00%)                          seq_op: Some(seq.kleene.op),
         .                                   idx: 0,
    33,025 ( 0.00%)                          matches,
    13,210 ( 0.00%)                          match_lo: item.match_cur,
         .                                   match_cur: item.match_cur,
    13,210 ( 0.00%)                          match_hi: item.match_cur + seq.num_captures,
         .                                   up: Some(item),
    46,235 ( 0.00%)                          top_elts: Tt(TokenTree::Sequence(sp, seq)),
         .                               })));
         .                           }
         .           
         .                           // We need to match a metavar (but the identifier is invalid)... this is an error
         .                           TokenTree::MetaVarDecl(span, _, None) => {
         .                               if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
         .                                   return Error(span, "missing fragment specifier".to_string());
         .                               }
-- line 565 ----------------------------------------
-- line 568 ----------------------------------------
         .                           // We need to match a metavar with a valid ident... call out to the black-box
         .                           // parser by adding an item to `bb_items`.
         .                           TokenTree::MetaVarDecl(_, _, Some(kind)) => {
         .                               // Built-in nonterminals never start with these tokens, so we can eliminate
         .                               // them from consideration.
         .                               //
         .                               // We use the span of the metavariable declaration to determine any
         .                               // edition-specific matching behavior for non-terminals.
 1,458,460 ( 0.00%)                      if Parser::nonterminal_may_begin_with(kind, token) {
         .                                   bb_items.push(item);
         .                               }
         .                           }
         .           
         .                           // We need to descend into a delimited submatcher or a doc comment. To do this, we
         .                           // push the current matcher onto a stack and push a new item containing the
         .                           // submatcher onto `cur_items`.
         .                           //
         .                           // At the beginning of the loop, if we reach the end of the delimited submatcher,
         .                           // we pop the stack to backtrack out of the descent.
   140,690 ( 0.00%)                  seq @ (TokenTree::Delimited(..)
         .                           | TokenTree::Token(Token { kind: DocComment(..), .. })) => {
         .                               let lower_elts = mem::replace(&mut item.top_elts, Tt(seq));
    28,138 ( 0.00%)                      let idx = item.idx;
   196,966 ( 0.00%)                      item.stack.push(MatcherTtFrame { elts: lower_elts, idx });
   112,552 ( 0.00%)                      item.idx = 0;
         .                               cur_items.push(item);
         .                           }
         .           
         .                           // We just matched a normal token. We can just advance the parser.
   577,599 ( 0.00%)                  TokenTree::Token(t) if token_name_eq(&t, token) => {
   256,599 ( 0.00%)                      item.idx += 1;
         .                               next_items.push(item);
         .                           }
         .           
         .                           // There was another token that was not `token`... This means we can't add any
         .                           // rules. NOTE that this is not necessarily an error unless _all_ items in
         .                           // `cur_items` end up doing this. There may still be some other matchers that do
         .                           // end up working out.
         .                           TokenTree::Token(..) | TokenTree::MetaVar(..) => {}
         .                       }
 2,675,051 ( 0.01%)          }
   991,116 ( 0.00%)      }
         .           
         .               // Yay a successful parse (so far)!
         .               Success(())
         .           }
         .           
         .           /// Use the given sequence of token trees (`ms`) as a matcher. Match the token
         .           /// stream from the given `parser` against it and return the match.
 1,243,040 ( 0.00%)  pub(super) fn parse_tt(
         .               parser: &mut Cow<'_, Parser<'_>>,
         .               ms: &[TokenTree],
         .               macro_name: Ident,
         .           ) -> NamedParseResult {
         .               // A queue of possible matcher positions. We initialize it with the matcher position in which
         .               // the "dot" is before the first token of the first token tree in `ms`. `inner_parse_loop` then
         .               // processes all of these possible matcher positions and produces possible next positions into
         .               // `next_items`. After some post-processing, the contents of `next_items` replenish `cur_items`
         .               // and we start over again.
         .               //
         .               // This MatcherPos instance is allocated on the stack. All others -- and
         .               // there are frequently *no* others! -- are allocated on the heap.
         .               let mut initial = initial_matcher_pos(ms);
   621,520 ( 0.00%)      let mut cur_items = smallvec![MatcherPosHandle::Ref(&mut initial)];
         .               let mut next_items = Vec::new();
         .           
         .               loop {
         .                   // Matcher positions black-box parsed by parser.rs (`parser`)
         .                   let mut bb_items = SmallVec::new();
         .           
         .                   // Matcher positions that would be valid if the macro invocation was over now
         .                   let mut eof_items = SmallVec::new();
   446,222 ( 0.00%)          assert!(next_items.is_empty());
         .           
         .                   // Process `cur_items` until either we have finished the input or we need to get some
         .                   // parsing from the black-box parser done. The result is that `next_items` will contain a
         .                   // bunch of possible next matcher positions in `next_items`.
         .                   match inner_parse_loop(
         .                       parser.sess,
         .                       &mut cur_items,
         .                       &mut next_items,
-- line 648 ----------------------------------------
-- line 652 ----------------------------------------
         .                   ) {
         .                       Success(_) => {}
         .                       Failure(token, msg) => return Failure(token, msg),
         .                       Error(sp, msg) => return Error(sp, msg),
         .                       ErrorReported => return ErrorReported,
         .                   }
         .           
         .                   // inner parse loop handled all cur_items, so it's empty
   446,222 ( 0.00%)          assert!(cur_items.is_empty());
         .           
         .                   // We need to do some post processing after the `inner_parser_loop`.
         .                   //
         .                   // Error messages here could be improved with links to original rules.
         .           
         .                   // If we reached the EOF, check that there is EXACTLY ONE possible matcher. Otherwise,
         .                   // either the parse is ambiguous (which should never happen) or there is a syntax error.
 2,231,110 ( 0.01%)          if parser.token == token::Eof {
    45,124 ( 0.00%)              if eof_items.len() == 1 {
         .                           let matches =
    81,204 ( 0.00%)                      eof_items[0].matches.iter_mut().map(|dv| Lrc::make_mut(dv).pop().unwrap());
    33,837 ( 0.00%)                  return nameize(parser.sess, ms, matches);
         .                       } else if eof_items.len() > 1 {
         .                           return Error(
         .                               parser.token.span,
         .                               "ambiguity: multiple successful parses".to_string(),
         .                           );
         .                       } else {
        36 ( 0.00%)                  return Failure(
        12 ( 0.00%)                      Token::new(
         .                                   token::Eof,
        16 ( 0.00%)                          if parser.token.span.is_dummy() {
         .                                       parser.token.span
         .                                   } else {
         .                                       parser.token.span.shrink_to_hi()
         .                                   },
         .                               ),
         .                               "missing tokens in macro arguments",
         .                           );
         .                       }
         .                   }
         .                   // Performance hack: eof_items may share matchers via Rc with other things that we want
         .                   // to modify. Dropping eof_items now may drop these refcounts to 1, preventing an
         .                   // unnecessary implicit clone later in Rc::make_mut.
 1,739,756 ( 0.00%)          drop(eof_items);
         .           
         .                   // If there are no possible next positions AND we aren't waiting for the black-box parser,
         .                   // then there is a syntax error.
 1,454,551 ( 0.00%)          if bb_items.is_empty() && next_items.is_empty() {
 1,469,273 ( 0.00%)              return Failure(parser.token.clone(), "no rules expected this token in macro call");
         .                   }
         .                   // Another possibility is that we need to call out to parse some rust nonterminal
         .                   // (black-box) parser. However, if there is not EXACTLY ONE of these, something is wrong.
 1,140,820 ( 0.00%)          else if (!bb_items.is_empty() && !next_items.is_empty()) || bb_items.len() > 1 {
         .                       let nts = bb_items
         .                           .iter()
         .                           .map(|item| match item.top_elts.get_tt(item.idx) {
         .                               TokenTree::MetaVarDecl(_, bind, Some(kind)) => format!("{} ('{}')", kind, bind),
         .                               _ => panic!(),
         .                           })
         .                           .collect::<Vec<String>>()
         .                           .join(" or ");
-- line 712 ----------------------------------------
-- line 721 ----------------------------------------
         .                                   n => format!("built-in NTs {} or {} other options.", nts, n),
         .                               }
         .                           ),
         .                       );
         .                   }
         .                   // Dump all possible `next_items` into `cur_items` for the next iteration.
         .                   else if !next_items.is_empty() {
         .                       // Now process the next token
   110,139 ( 0.00%)              cur_items.extend(next_items.drain(..));
    36,713 ( 0.00%)              parser.to_mut().bump();
         .                   }
         .                   // Finally, we have the case where we need to call the black-box parser to get some
         .                   // nonterminal.
         .                   else {
         .                       assert_eq!(bb_items.len(), 1);
         .           
   570,410 ( 0.00%)              let mut item = bb_items.pop().unwrap();
 1,603,130 ( 0.00%)              if let TokenTree::MetaVarDecl(span, _, Some(kind)) = item.top_elts.get_tt(item.idx) {
   285,205 ( 0.00%)                  let match_cur = item.match_cur;
         .                           // We use the span of the metavariable declaration to determine any
         .                           // edition-specific matching behavior for non-terminals.
 1,834,424 ( 0.00%)                  let nt = match parser.to_mut().parse_nonterminal(kind) {
         .                               Err(mut err) => {
         .                                   err.span_label(
         .                                       span,
         .                                       format!("while parsing argument for this `{}` macro fragment", kind),
         .                                   )
         .                                   .emit();
         .                                   return ErrorReported;
         .                               }
 1,711,230 ( 0.00%)                      Ok(nt) => nt,
         .                           };
 1,140,820 ( 0.00%)                  item.push_match(match_cur, MatchedNonterminal(Lrc::new(nt)));
 1,140,820 ( 0.00%)                  item.idx += 1;
 1,711,230 ( 0.00%)                  item.match_cur += 1;
         .                       } else {
         .                           unreachable!()
         .                       }
         .                       cur_items.push(item);
         .                   }
         .           
   643,836 ( 0.00%)          assert!(!cur_items.is_empty());
         .               }
 1,118,736 ( 0.00%)  }

10,401,742 ( 0.02%)  <counts for unidentified lines in /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs>

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_parse/src/parser/mod.rs
--------------------------------------------------------------------------------
Ir                  

-- line 36 ----------------------------------------
         .           use rustc_session::parse::ParseSess;
         .           use rustc_span::source_map::{MultiSpan, Span, DUMMY_SP};
         .           use rustc_span::symbol::{kw, sym, Ident, Symbol};
         .           use tracing::debug;
         .           
         .           use std::ops::Range;
         .           use std::{cmp, mem, slice};
         .           
    43,399 ( 0.00%)  bitflags::bitflags! {
         .               struct Restrictions: u8 {
         .                   const STMT_EXPR         = 1 << 0;
         .                   const NO_STRUCT_LITERAL = 1 << 1;
         .                   const CONST_EXPR        = 1 << 2;
         .               }
         .           }
         .           
         .           #[derive(Clone, Copy, PartialEq, Debug)]
-- line 52 ----------------------------------------
-- line 104 ----------------------------------------
         .                               $self.bump();
         .                               return $self.maybe_recover_from_bad_qpath_stage_2($self.prev_token.span, ty);
         .                           }
         .                       }
         .                   }
         .               };
         .           }
         .           
 7,572,792 ( 0.02%)  #[derive(Clone)]
         .           pub struct Parser<'a> {
   281,226 ( 0.00%)      pub sess: &'a ParseSess,
         .               /// The current token.
   269,930 ( 0.00%)      pub token: Token,
         .               /// The spacing for the current token
   135,013 ( 0.00%)      pub token_spacing: Spacing,
         .               /// The previous token.
   404,895 ( 0.00%)      pub prev_token: Token,
   135,061 ( 0.00%)      pub capture_cfg: bool,
   270,170 ( 0.00%)      restrictions: Restrictions,
   270,026 ( 0.00%)      expected_tokens: Vec<TokenType>,
         .               // Important: This must only be advanced from `next_tok`
         .               // to ensure that `token_cursor.num_next_calls` is updated properly
         .               token_cursor: TokenCursor,
   270,026 ( 0.00%)      desugar_doc_comments: bool,
         .               /// This field is used to keep track of how many left angle brackets we have seen. This is
         .               /// required in order to detect extra leading left angle brackets (`<` characters) and error
         .               /// appropriately.
         .               ///
         .               /// See the comments in the `parse_path_segment` function for more details.
   270,026 ( 0.00%)      unmatched_angle_bracket_count: u32,
   405,039 ( 0.00%)      max_angle_bracket_count: u32,
         .               /// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery
         .               /// it gets removed from here. Every entry left at the end gets emitted as an independent
         .               /// error.
   135,013 ( 0.00%)      pub(super) unclosed_delims: Vec<UnmatchedBrace>,
         .               last_unexpected_token_span: Option<Span>,
         .               /// Span pointing at the `:` for the last type ascription the parser has seen, and whether it
         .               /// looked like it could have been a mistyped path or literal `Option:Some(42)`).
         .               pub last_type_ascription: Option<(Span, bool /* likely path typo */)>,
         .               /// If present, this `Parser` is not parsing Rust code but rather a macro call.
         .               subparser_name: Option<&'static str>,
         .               capture_state: CaptureState,
         .               /// This allows us to recover when the user forget to add braces around
-- line 146 ----------------------------------------
-- line 173 ----------------------------------------
         .           /// the first macro inner attribute to invoke a proc-macro).
         .           /// When create a `TokenStream`, the inner attributes get inserted
         .           /// into the proper place in the token stream.
         .           pub type ReplaceRange = (Range<u32>, Vec<(FlatToken, Spacing)>);
         .           
         .           /// Controls how we capture tokens. Capturing can be expensive,
         .           /// so we try to avoid performing capturing in cases where
         .           /// we will never need an `AttrAnnotatedTokenStream`
   135,013 ( 0.00%)  #[derive(Copy, Clone)]
         .           pub enum Capturing {
         .               /// We aren't performing any capturing - this is the default mode.
         .               No,
         .               /// We are capturing tokens
         .               Yes,
         .           }
         .           
   551,300 ( 0.00%)  #[derive(Clone)]
         .           struct CaptureState {
   540,052 ( 0.00%)      capturing: Capturing,
   135,013 ( 0.00%)      replace_ranges: Vec<ReplaceRange>,
         .               inner_attr_ranges: FxHashMap<AttrId, ReplaceRange>,
         .           }
         .           
         .           impl<'a> Drop for Parser<'a> {
         .               fn drop(&mut self) {
   473,092 ( 0.00%)          emit_unclosed_delims(&mut self.unclosed_delims, &self.sess);
         .               }
         .           }
         .           
 2,444,533 ( 0.01%)  #[derive(Clone)]
         .           struct TokenCursor {
         .               frame: TokenCursorFrame,
   570,666 ( 0.00%)      stack: Vec<TokenCursorFrame>,
         .               desugar_doc_comments: bool,
         .               // Counts the number of calls to `next` or `next_desugared`,
         .               // depending on whether `desugar_doc_comments` is set.
   185,202 ( 0.00%)      num_next_calls: usize,
         .               // During parsing, we may sometimes need to 'unglue' a
         .               // glued token into two component tokens
         .               // (e.g. '>>' into '>' and '>), so that the parser
         .               // can consume them one at a time. This process
         .               // bypasses the normal capturing mechanism
         .               // (e.g. `num_next_calls` will not be incremented),
         .               // since the 'unglued' tokens due not exist in
         .               // the original `TokenStream`.
-- line 217 ----------------------------------------
-- line 226 ----------------------------------------
         .               // in `Option<Vec<u8>>` requires us to unglue
         .               // the trailing `>>` token. The `break_last_token`
         .               // field is used to track this token - it gets
         .               // appended to the captured stream when
         .               // we evaluate a `LazyTokenStream`
         .               break_last_token: bool,
         .           }
         .           
 1,111,750 ( 0.00%)  #[derive(Clone)]
         .           struct TokenCursorFrame {
   191,245 ( 0.00%)      delim: token::DelimToken,
         .               span: DelimSpan,
         .               open_delim: bool,
   382,490 ( 0.00%)      tree_cursor: tokenstream::Cursor,
         .               close_delim: bool,
         .           }
         .           
         .           impl TokenCursorFrame {
         .               fn new(span: DelimSpan, delim: DelimToken, tts: TokenStream) -> Self {
   113,255 ( 0.00%)          TokenCursorFrame {
         .                       delim,
         .                       span,
         .                       open_delim: false,
   144,436 ( 0.00%)              tree_cursor: tts.into_trees(),
         .                       close_delim: false,
         .                   }
         .               }
         .           }
         .           
         .           impl TokenCursor {
10,743,036 ( 0.02%)      fn next(&mut self) -> (Token, Spacing) {
         .                   loop {
 5,139,505 ( 0.01%)              let (tree, spacing) = if !self.frame.open_delim {
    99,132 ( 0.00%)                  self.frame.open_delim = true;
   495,660 ( 0.00%)                  TokenTree::open_tt(self.frame.span, self.frame.delim).into()
10,415,969 ( 0.02%)              } else if let Some(tree) = self.frame.tree_cursor.next_with_spacing() {
         .                           tree
   380,738 ( 0.00%)              } else if !self.frame.close_delim {
    83,795 ( 0.00%)                  self.frame.close_delim = true;
   418,975 ( 0.00%)                  TokenTree::close_tt(self.frame.span, self.frame.delim).into()
   167,590 ( 0.00%)              } else if let Some(frame) = self.stack.pop() {
 1,089,335 ( 0.00%)                  self.frame = frame;
         .                           continue;
         .                       } else {
   410,022 ( 0.00%)                  (TokenTree::Token(Token::new(token::Eof, DUMMY_SP)), Spacing::Alone)
         .                       };
         .           
 1,988,766 ( 0.00%)              match tree {
         .                           TokenTree::Token(token) => {
 7,162,024 ( 0.02%)                      return (token, spacing);
         .                           }
         .                           TokenTree::Delimited(sp, delim, tts) => {
         .                               let frame = TokenCursorFrame::new(sp, delim, tts);
         .                               self.stack.push(mem::replace(&mut self.frame, frame));
         .                           }
         .                       }
         .                   }
 7,162,024 ( 0.02%)      }
         .           
 4,795,310 ( 0.01%)      fn next_desugared(&mut self) -> (Token, Spacing) {
 1,438,597 ( 0.00%)          let (data, attr_style, sp) = match self.next() {
         6 ( 0.00%)              (Token { kind: token::DocComment(_, attr_style, data), span }, _) => {
         .                           (data, attr_style, span)
         .                       }
 2,397,645 ( 0.01%)              tok => return tok,
         .                   };
         .           
         .                   // Searches for the occurrences of `"#*` and returns the minimum number of `#`s
         .                   // required to wrap the text.
         .                   let mut num_of_hashes = 0;
         .                   let mut count = 0;
       602 ( 0.00%)          for ch in data.as_str().chars() {
         .                       count = match ch {
         .                           '"' => 1,
         .                           '#' if count > 0 => count + 1,
         .                           _ => 0,
         .                       };
         .                       num_of_hashes = cmp::max(num_of_hashes, count);
         .                   }
         .           
         8 ( 0.00%)          let delim_span = DelimSpan::from_single(sp);
        10 ( 0.00%)          let body = TokenTree::Delimited(
         .                       delim_span,
         .                       token::Bracket,
        24 ( 0.00%)              [
        14 ( 0.00%)                  TokenTree::token(token::Ident(sym::doc, false), sp),
         8 ( 0.00%)                  TokenTree::token(token::Eq, sp),
        16 ( 0.00%)                  TokenTree::token(TokenKind::lit(token::StrRaw(num_of_hashes), data, None), sp),
         .                       ]
         .                       .iter()
         .                       .cloned()
         .                       .collect::<TokenStream>(),
         2 ( 0.00%)          );
         .           
         .                   self.stack.push(mem::replace(
         .                       &mut self.frame,
         .                       TokenCursorFrame::new(
         .                           delim_span,
         .                           token::NoDelim,
         2 ( 0.00%)                  if attr_style == AttrStyle::Inner {
         .                               [TokenTree::token(token::Pound, sp), TokenTree::token(token::Not, sp), body]
         .                                   .iter()
         .                                   .cloned()
         .                                   .collect::<TokenStream>()
         .                           } else {
        24 ( 0.00%)                      [TokenTree::token(token::Pound, sp), body]
         .                                   .iter()
         .                                   .cloned()
         .                                   .collect::<TokenStream>()
         .                           },
         .                       ),
         .                   ));
         .           
         6 ( 0.00%)          self.next()
 4,315,779 ( 0.01%)      }
         .           }
         .           
     3,100 ( 0.00%)  #[derive(Debug, Clone, PartialEq)]
         .           enum TokenType {
     2,480 ( 0.00%)      Token(TokenKind),
         .               Keyword(Symbol),
         .               Operator,
         .               Lifetime,
         .               Ident,
         .               Path,
         .               Type,
         .               Const,
         .           }
-- line 353 ----------------------------------------
-- line 378 ----------------------------------------
         .               /// The separator token.
         .               sep: Option<TokenKind>,
         .               /// `true` if a trailing separator is allowed.
         .               trailing_sep_allowed: bool,
         .           }
         .           
         .           impl SeqSep {
         .               fn trailing_allowed(t: TokenKind) -> SeqSep {
       123 ( 0.00%)          SeqSep { sep: Some(t), trailing_sep_allowed: true }
         .               }
         .           
         .               fn none() -> SeqSep {
         .                   SeqSep { sep: None, trailing_sep_allowed: false }
         .               }
         .           }
         .           
         .           pub enum FollowedByType {
         .               Yes,
         .               No,
         .           }
         .           
         .           fn token_descr_opt(token: &Token) -> Option<&'static str> {
       158 ( 0.00%)      Some(match token.kind {
       316 ( 0.00%)          _ if token.is_special_ident() => "reserved identifier",
       316 ( 0.00%)          _ if token.is_used_keyword() => "keyword",
       316 ( 0.00%)          _ if token.is_unused_keyword() => "reserved keyword",
         .                   token::DocComment(..) => "doc comment",
         .                   _ => return None,
         .               })
         .           }
         .           
       553 ( 0.00%)  pub(super) fn token_descr(token: &Token) -> String {
       158 ( 0.00%)      let token_str = pprust::token_to_string(token);
         .               match token_descr_opt(token) {
         .                   Some(prefix) => format!("{} `{}`", prefix, token_str),
       553 ( 0.00%)          _ => format!("`{}`", token_str),
         .               }
       395 ( 0.00%)  }
         .           
         .           impl<'a> Parser<'a> {
   317,114 ( 0.00%)      pub fn new(
         .                   sess: &'a ParseSess,
         .                   tokens: TokenStream,
         .                   desugar_doc_comments: bool,
         .                   subparser_name: Option<&'static str>,
         .               ) -> Self {
    22,651 ( 0.00%)          let mut start_frame = TokenCursorFrame::new(DelimSpan::dummy(), token::NoDelim, tokens);
    45,302 ( 0.00%)          start_frame.open_delim = true;
         .                   start_frame.close_delim = true;
         .           
   702,181 ( 0.00%)          let mut parser = Parser {
         .                       sess,
    22,651 ( 0.00%)              token: Token::dummy(),
         .                       token_spacing: Spacing::Alone,
    22,651 ( 0.00%)              prev_token: Token::dummy(),
         .                       capture_cfg: false,
         .                       restrictions: Restrictions::empty(),
         .                       expected_tokens: Vec::new(),
         .                       token_cursor: TokenCursor {
   135,906 ( 0.00%)                  frame: start_frame,
         .                           stack: Vec::new(),
         .                           num_next_calls: 0,
         .                           desugar_doc_comments,
         .                           break_last_token: false,
         .                       },
         .                       desugar_doc_comments,
         .                       unmatched_angle_bracket_count: 0,
         .                       max_angle_bracket_count: 0,
-- line 445 ----------------------------------------
-- line 451 ----------------------------------------
         .                           capturing: Capturing::No,
         .                           replace_ranges: Vec::new(),
         .                           inner_attr_ranges: Default::default(),
         .                       },
         .                       current_closure: None,
         .                   };
         .           
         .                   // Make parser point to the first token.
    45,302 ( 0.00%)          parser.bump();
         .           
         .                   parser
   203,859 ( 0.00%)      }
         .           
         .               fn next_tok(&mut self, fallback_span: Span) -> (Token, Spacing) {
         .                   loop {
 5,169,210 ( 0.01%)              let (mut next, spacing) = if self.desugar_doc_comments {
 1,918,124 ( 0.00%)                  self.token_cursor.next_desugared()
         .                       } else {
 1,146,012 ( 0.00%)                  self.token_cursor.next()
         .                       };
 3,446,140 ( 0.01%)              self.token_cursor.num_next_calls += 1;
         .                       // We've retrieved an token from the underlying
         .                       // cursor, so we no longer need to worry about
         .                       // an unglued token. See `break_and_eat` for more details
   861,535 ( 0.00%)              self.token_cursor.break_last_token = false;
 3,446,140 ( 0.01%)              if next.span.is_dummy() {
         .                           // Tweak the location for better diagnostics, but keep syntactic context intact.
    90,656 ( 0.00%)                  next.span = fallback_span.with_ctxt(next.span.ctxt());
         .                       }
 2,851,231 ( 0.01%)              if matches!(
 1,723,070 ( 0.00%)                  next.kind,
         .                           token::OpenDelim(token::NoDelim) | token::CloseDelim(token::NoDelim)
         .                       ) {
         .                           continue;
         .                       }
 3,446,124 ( 0.01%)              return (next, spacing);
         .                   }
         .               }
         .           
         .               pub fn unexpected<T>(&mut self) -> PResult<'a, T> {
         .                   match self.expect_one_of(&[], &[]) {
         .                       Err(e) => Err(e),
         .                       // We can get `Ok(true)` from `recover_closing_delimiter`
         .                       // which is called in `expected_one_of_not_found`.
         .                       Ok(_) => FatalError.raise(),
         .                   }
         .               }
         .           
         .               /// Expects and consumes the token `t`. Signals an error if the next token is not `t`.
    74,736 ( 0.00%)      pub fn expect(&mut self, t: &TokenKind) -> PResult<'a, bool /* recovered */> {
     8,304 ( 0.00%)          if self.expected_tokens.is_empty() {
       714 ( 0.00%)              if self.token == *t {
       595 ( 0.00%)                  self.bump();
         .                           Ok(false)
         .                       } else {
         .                           self.unexpected_try_recover(t)
         .                       }
         .                   } else {
    98,220 ( 0.00%)              self.expect_one_of(slice::from_ref(t), &[])
         .                   }
   124,560 ( 0.00%)      }
         .           
         .               /// Expect next token to be edible or inedible token.  If edible,
         .               /// then consume it; if inedible, then return without consuming
         .               /// anything.  Signal a fatal error if next token is unexpected.
   145,404 ( 0.00%)      pub fn expect_one_of(
         .                   &mut self,
         .                   edible: &[TokenKind],
         .                   inedible: &[TokenKind],
         .               ) -> PResult<'a, bool /* recovered */> {
    24,234 ( 0.00%)          if edible.contains(&self.token.kind) {
    25,341 ( 0.00%)              self.bump();
         .                       Ok(false)
         .                   } else if inedible.contains(&self.token.kind) {
         .                       // leave it in the input
         .                       Ok(false)
         .                   } else if self.last_unexpected_token_span == Some(self.token.span) {
         .                       FatalError.raise();
         .                   } else {
         .                       self.expected_one_of_not_found(edible, inedible)
         .                   }
   181,755 ( 0.00%)      }
         .           
         .               // Public for rustfmt usage.
         .               pub fn parse_ident(&mut self) -> PResult<'a, Ident> {
   123,791 ( 0.00%)          self.parse_ident_common(true)
         .               }
         .           
         .               fn ident_or_err(&mut self) -> PResult<'a, (Ident, /* is_raw */ bool)> {
    92,322 ( 0.00%)          self.token.ident().ok_or_else(|| match self.prev_token.kind {
         .                       TokenKind::DocComment(..) => {
         .                           self.span_err(self.prev_token.span, Error::UselessDocComment)
         .                       }
         .                       _ => self.expected_ident_found(),
         .                   })
         .               }
         .           
   215,117 ( 0.00%)      fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, Ident> {
    30,731 ( 0.00%)          let (ident, is_raw) = self.ident_or_err()?;
   184,386 ( 0.00%)          if !is_raw && ident.is_reserved() {
         .                       let mut err = self.expected_ident_found();
         .                       if recover {
         .                           err.emit();
         .                       } else {
         .                           return Err(err);
         .                       }
         .                   }
   122,924 ( 0.00%)          self.bump();
         .                   Ok(ident)
   307,310 ( 0.00%)      }
         .           
         .               /// Checks if the next token is `tok`, and returns `true` if so.
         .               ///
         .               /// This method will automatically add `tok` to `expected_tokens` if `tok` is not
         .               /// encountered.
 2,565,437 ( 0.01%)      fn check(&mut self, tok: &TokenKind) -> bool {
 1,111,448 ( 0.00%)          let is_present = self.token == *tok;
   754,928 ( 0.00%)          if !is_present {
 1,285,762 ( 0.00%)              self.expected_tokens.push(TokenType::Token(tok.clone()));
         .                   }
         .                   is_present
 2,565,437 ( 0.01%)      }
         .           
         .               /// Consumes a token 'tok' if it exists. Returns whether the given token was present.
       356 ( 0.00%)      pub fn eat(&mut self, tok: &TokenKind) -> bool {
   520,863 ( 0.00%)          let is_present = self.check(tok);
   346,221 ( 0.00%)          if is_present {
   117,434 ( 0.00%)              self.bump()
         .                   }
         .                   is_present
       445 ( 0.00%)      }
         .           
         .               /// If the next token is the given keyword, returns `true` without eating it.
         .               /// An expectation is also added for diagnostics purposes.
    17,990 ( 0.00%)      fn check_keyword(&mut self, kw: Symbol) -> bool {
    20,173 ( 0.00%)          self.expected_tokens.push(TokenType::Keyword(kw));
   263,456 ( 0.00%)          self.token.is_keyword(kw)
         .               }
         .           
         .               /// If the next token is the given keyword, eats it and returns `true`.
         .               /// Otherwise, returns `false`. An expectation is also added for diagnostics purposes.
         .               // Public for rustfmt usage.
    55,990 ( 0.00%)      pub fn eat_keyword(&mut self, kw: Symbol) -> bool {
    43,168 ( 0.00%)          if self.check_keyword(kw) {
    10,320 ( 0.00%)              self.bump();
         .                       true
         .                   } else {
         .                       false
         .                   }
    55,990 ( 0.00%)      }
         .           
         .               fn eat_keyword_noexpect(&mut self, kw: Symbol) -> bool {
     1,018 ( 0.00%)          if self.token.is_keyword(kw) {
       241 ( 0.00%)              self.bump();
         .                       true
         .                   } else {
         .                       false
         .                   }
         .               }
         .           
         .               /// If the given word is not a keyword, signals an error.
         .               /// If the next token is not the given word, signals an error.
         .               /// Otherwise, eats it.
       105 ( 0.00%)      fn expect_keyword(&mut self, kw: Symbol) -> PResult<'a, ()> {
         .                   if !self.eat_keyword(kw) { self.unexpected() } else { Ok(()) }
        84 ( 0.00%)      }
         .           
         .               /// Is the given keyword `kw` followed by a non-reserved identifier?
   466,848 ( 0.00%)      fn is_kw_followed_by_ident(&self, kw: Symbol) -> bool {
   233,424 ( 0.00%)          self.token.is_keyword(kw) && self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
   525,204 ( 0.00%)      }
         .           
    62,286 ( 0.00%)      fn check_or_expected(&mut self, ok: bool, typ: TokenType) -> bool {
    49,948 ( 0.00%)          if ok {
         .                       true
         .                   } else {
     3,640 ( 0.00%)              self.expected_tokens.push(typ);
         .                       false
         .                   }
    62,286 ( 0.00%)      }
         .           
         .               fn check_ident(&mut self) -> bool {
    12,942 ( 0.00%)          self.check_or_expected(self.token.is_ident(), TokenType::Ident)
         .               }
         .           
    33,376 ( 0.00%)      fn check_path(&mut self) -> bool {
    84,396 ( 0.00%)          self.check_or_expected(self.token.is_path_start(), TokenType::Path)
    41,720 ( 0.00%)      }
         .           
         .               fn check_type(&mut self) -> bool {
       368 ( 0.00%)          self.check_or_expected(self.token.can_begin_type(), TokenType::Type)
         .               }
         .           
         .               fn check_const_arg(&mut self) -> bool {
       368 ( 0.00%)          self.check_or_expected(self.token.can_begin_const_arg(), TokenType::Const)
         .               }
         .           
    14,103 ( 0.00%)      fn check_inline_const(&self, dist: usize) -> bool {
     7,835 ( 0.00%)          self.is_keyword_ahead(dist, &[kw::Const])
         .                       && self.look_ahead(dist + 1, |t| match t.kind {
         .                           token::Interpolated(ref nt) => matches!(**nt, token::NtBlock(..)),
         .                           token::OpenDelim(DelimToken::Brace) => true,
         .                           _ => false,
         .                       })
    14,103 ( 0.00%)      }
         .           
         .               /// Checks to see if the next token is either `+` or `+=`.
         .               /// Otherwise returns `false`.
         .               fn check_plus(&mut self) -> bool {
       796 ( 0.00%)          self.check_or_expected(
       398 ( 0.00%)              self.token.is_like_plus(),
       398 ( 0.00%)              TokenType::Token(token::BinOp(token::Plus)),
         .                   )
         .               }
         .           
         .               /// Eats the expected token if it's present possibly breaking
         .               /// compound tokens like multi-character operators in process.
         .               /// Returns `true` if the token was eaten.
   140,712 ( 0.00%)      fn break_and_eat(&mut self, expected: TokenKind) -> bool {
    82,082 ( 0.00%)          if self.token.kind == expected {
     7,172 ( 0.00%)              self.bump();
         .                       return true;
         .                   }
    40,700 ( 0.00%)          match self.token.kind.break_two_token_op() {
       595 ( 0.00%)              Some((first, second)) if first == expected => {
        16 ( 0.00%)                  let first_span = self.sess.source_map().start_point(self.token.span);
        20 ( 0.00%)                  let second_span = self.token.span.with_lo(first_span.hi());
        36 ( 0.00%)                  self.token = Token::new(first, first_span);
         .                           // Keep track of this token - if we end token capturing now,
         .                           // we'll want to append this token to the captured stream.
         .                           //
         .                           // If we consume any additional tokens, then this token
         .                           // is not needed (we'll capture the entire 'glued' token),
         .                           // and `next_tok` will set this field to `None`
         4 ( 0.00%)                  self.token_cursor.break_last_token = true;
         .                           // Use the spacing of the glued token as the spacing
         .                           // of the unglued second token.
        56 ( 0.00%)                  self.bump_with((Token::new(second, second_span), self.token_spacing));
         .                           true
         .                       }
         .                       _ => {
    24,408 ( 0.00%)                  self.expected_tokens.push(TokenType::Token(expected));
         .                           false
         .                       }
         .                   }
   138,267 ( 0.00%)      }
         .           
         .               /// Eats `+` possibly breaking tokens like `+=` in process.
         .               fn eat_plus(&mut self) -> bool {
        36 ( 0.00%)          self.break_and_eat(token::BinOp(token::Plus))
         .               }
         .           
         .               /// Eats `&` possibly breaking tokens like `&&` in process.
         .               /// Signals an error if `&` is not eaten.
         .               fn expect_and(&mut self) -> PResult<'a, ()> {
    20,634 ( 0.00%)          if self.break_and_eat(token::BinOp(token::And)) { Ok(()) } else { self.unexpected() }
         .               }
         .           
         .               /// Eats `|` possibly breaking tokens like `||` in process.
         .               /// Signals an error if `|` was not eaten.
         .               fn expect_or(&mut self) -> PResult<'a, ()> {
       246 ( 0.00%)          if self.break_and_eat(token::BinOp(token::Or)) { Ok(()) } else { self.unexpected() }
         .               }
         .           
         .               /// Eats `<` possibly breaking tokens like `<<` in process.
       868 ( 0.00%)      fn eat_lt(&mut self) -> bool {
    24,652 ( 0.00%)          let ate = self.break_and_eat(token::Lt);
    16,410 ( 0.00%)          if ate {
         .                       // See doc comment for `unmatched_angle_bracket_count`.
       220 ( 0.00%)              self.unmatched_angle_bracket_count += 1;
       229 ( 0.00%)              self.max_angle_bracket_count += 1;
         .                       debug!("eat_lt: (increment) count={:?}", self.unmatched_angle_bracket_count);
         .                   }
         .                   ate
       868 ( 0.00%)      }
         .           
         .               /// Eats `<` possibly breaking tokens like `<<` in process.
         .               /// Signals an error if `<` was not eaten.
         .               fn expect_lt(&mut self) -> PResult<'a, ()> {
         .                   if self.eat_lt() { Ok(()) } else { self.unexpected() }
         .               }
         .           
         .               /// Eats `>` possibly breaking tokens like `>>` in process.
         .               /// Signals an error if `>` was not eaten.
         .               fn expect_gt(&mut self) -> PResult<'a, ()> {
       330 ( 0.00%)          if self.break_and_eat(token::Gt) {
         .                       // See doc comment for `unmatched_angle_bracket_count`.
       165 ( 0.00%)              if self.unmatched_angle_bracket_count > 0 {
       110 ( 0.00%)                  self.unmatched_angle_bracket_count -= 1;
         .                           debug!("expect_gt: (decrement) count={:?}", self.unmatched_angle_bracket_count);
         .                       }
         .                       Ok(())
         .                   } else {
         .                       self.unexpected()
         .                   }
         .               }
         .           
         .               fn expect_any_with_type(&mut self, kets: &[&TokenKind], expect: TokenExpectType) -> bool {
         .                   kets.iter().any(|k| match expect {
    21,570 ( 0.00%)              TokenExpectType::Expect => self.check(k),
       651 ( 0.00%)              TokenExpectType::NoExpect => self.token == **k,
         .                   })
         .               }
         .           
         .               fn parse_seq_to_before_tokens<T>(
         .                   &mut self,
         .                   kets: &[&TokenKind],
         .                   sep: SeqSep,
         .                   expect: TokenExpectType,
-- line 759 ----------------------------------------
-- line 761 ----------------------------------------
         .               ) -> PResult<'a, (Vec<T>, bool /* trailing */, bool /* recovered */)> {
         .                   let mut first = true;
         .                   let mut recovered = false;
         .                   let mut trailing = false;
         .                   let mut v = vec![];
         .                   let unclosed_delims = !self.unclosed_delims.is_empty();
         .           
         .                   while !self.expect_any_with_type(kets, expect) {
    39,926 ( 0.00%)              if let token::CloseDelim(..) | token::Eof = self.token.kind {
         .                           break;
         .                       }
    28,076 ( 0.00%)              if let Some(ref t) = sep.sep {
    28,671 ( 0.00%)                  if first {
         .                               first = false;
         .                           } else {
    20,254 ( 0.00%)                      match self.expect(t) {
         .                                   Ok(false) => {
         .                                       self.current_closure.take();
         .                                   }
         .                                   Ok(true) => {
         .                                       self.current_closure.take();
         .                                       recovered = true;
         .                                       break;
         .                                   }
-- line 784 ----------------------------------------
-- line 857 ----------------------------------------
         .                                               e.cancel();
         .                                               break;
         .                                           }
         .                                       }
         .                                   }
         .                               }
         .                           }
         .                       }
    13,380 ( 0.00%)              if sep.trailing_sep_allowed && self.expect_any_with_type(kets, expect) {
         .                           trailing = true;
         .                           break;
         .                       }
         .           
     6,507 ( 0.00%)              let t = f(self)?;
       861 ( 0.00%)              v.push(t);
         .                   }
         .           
    19,140 ( 0.00%)          Ok((v, trailing, recovered))
         .               }
         .           
         .               fn recover_missing_braces_around_closure_body(
         .                   &mut self,
         .                   closure_spans: ClosureSpans,
         .                   mut expect_err: DiagnosticBuilder<'_>,
         .               ) -> PResult<'a, ()> {
         .                   let initial_semicolon = self.token.span;
-- line 882 ----------------------------------------
-- line 937 ----------------------------------------
         .               /// `f` must consume tokens until reaching the next separator or
         .               /// closing bracket.
         .               fn parse_seq_to_before_end<T>(
         .                   &mut self,
         .                   ket: &TokenKind,
         .                   sep: SeqSep,
         .                   f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
         .               ) -> PResult<'a, (Vec<T>, bool, bool)> {
    18,966 ( 0.00%)          self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
         .               }
         .           
         .               /// Parses a sequence, including the closing delimiter. The function
         .               /// `f` must consume tokens until reaching the next separator or
         .               /// closing bracket.
    45,260 ( 0.00%)      fn parse_seq_to_end<T>(
         .                   &mut self,
         .                   ket: &TokenKind,
         .                   sep: SeqSep,
         .                   f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
         .               ) -> PResult<'a, (Vec<T>, bool /* trailing */)> {
    14,038 ( 0.00%)          let (val, trailing, recovered) = self.parse_seq_to_before_end(ket, sep, f)?;
     4,938 ( 0.00%)          if !recovered {
         .                       self.eat(ket);
         .                   }
    41,459 ( 0.00%)          Ok((val, trailing))
    36,208 ( 0.00%)      }
         .           
         .               /// Parses a sequence, including the closing delimiter. The function
         .               /// `f` must consume tokens until reaching the next separator or
         .               /// closing bracket.
         .               fn parse_unspanned_seq<T>(
         .                   &mut self,
         .                   bra: &TokenKind,
         .                   ket: &TokenKind,
         .                   sep: SeqSep,
         .                   f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
         .               ) -> PResult<'a, (Vec<T>, bool)> {
    13,952 ( 0.00%)          self.expect(bra)?;
    36,208 ( 0.00%)          self.parse_seq_to_end(ket, sep, f)
         .               }
         .           
         .               fn parse_delim_comma_seq<T>(
         .                   &mut self,
         .                   delim: DelimToken,
         .                   f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
         .               ) -> PResult<'a, (Vec<T>, bool)> {
         .                   self.parse_unspanned_seq(
     4,739 ( 0.00%)              &token::OpenDelim(delim),
     4,954 ( 0.00%)              &token::CloseDelim(delim),
         .                       SeqSep::trailing_allowed(token::Comma),
         .                       f,
         .                   )
         .               }
         .           
         .               fn parse_paren_comma_seq<T>(
         .                   &mut self,
         .                   f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
         .               ) -> PResult<'a, (Vec<T>, bool)> {
         .                   self.parse_delim_comma_seq(token::Paren, f)
         .               }
         .           
         .               /// Advance the parser by one token using provided token as the next one.
11,199,955 ( 0.03%)      fn bump_with(&mut self, (next_token, next_spacing): (Token, Spacing)) {
         .                   // Bumping after EOF is a bad sign, usually an infinite loop.
 5,169,210 ( 0.01%)          if self.prev_token.kind == TokenKind::Eof {
         .                       let msg = "attempted to bump the parser past EOF (may be stuck in a loop)";
         .                       self.span_bug(self.token.span, msg);
         .                   }
         .           
         .                   // Update the current and previous tokens.
 3,446,140 ( 0.01%)          self.prev_token = mem::replace(&mut self.token, next_token);
   861,535 ( 0.00%)          self.token_spacing = next_spacing;
         .           
         .                   // Diagnostics.
   861,535 ( 0.00%)          self.expected_tokens.clear();
         .               }
         .           
         .               /// Advance the parser by one token.
 6,892,248 ( 0.02%)      pub fn bump(&mut self) {
 3,446,124 ( 0.01%)          let next_token = self.next_tok(self.token.span);
 5,169,186 ( 0.01%)          self.bump_with(next_token);
 6,892,248 ( 0.02%)      }
         .           
         .               /// Look-ahead `dist` tokens of `self.token` and get access to that token there.
         .               /// When `dist == 0` then the current token is looked at.
       656 ( 0.00%)      pub fn look_ahead<R>(&self, dist: usize, looker: impl FnOnce(&Token) -> R) -> R {
     3,494 ( 0.00%)          if dist == 0 {
     1,634 ( 0.00%)              return looker(&self.token);
         .                   }
         .           
    59,510 ( 0.00%)          let frame = &self.token_cursor.frame;
    64,327 ( 0.00%)          if frame.delim != DelimToken::NoDelim {
         .                       let all_normal = (0..dist).all(|i| {
    90,349 ( 0.00%)                  let token = frame.tree_cursor.look_ahead(i);
   121,279 ( 0.00%)                  !matches!(token, Some(TokenTree::Delimited(_, DelimToken::NoDelim, _)))
         .                       });
         .                       if all_normal {
   149,155 ( 0.00%)                  return match frame.tree_cursor.look_ahead(dist - 1) {
    55,848 ( 0.00%)                      Some(tree) => match tree {
    27,582 ( 0.00%)                          TokenTree::Token(token) => looker(token),
         .                                   TokenTree::Delimited(dspan, delim, _) => {
     3,972 ( 0.00%)                              looker(&Token::new(token::OpenDelim(*delim), dspan.open))
         .                                   }
         .                               },
    19,219 ( 0.00%)                      None => looker(&Token::new(token::CloseDelim(frame.delim), frame.span.close)),
         .                           };
         .                       }
         .                   }
         .           
         .                   let mut cursor = self.token_cursor.clone();
         .                   let mut i = 0;
    33,714 ( 0.00%)          let mut token = Token::dummy();
       984 ( 0.00%)          while i < dist {
   236,352 ( 0.00%)              token = cursor.next().0;
   101,294 ( 0.00%)              if matches!(
    67,497 ( 0.00%)                  token.kind,
         .                           token::OpenDelim(token::NoDelim) | token::CloseDelim(token::NoDelim)
         .                       ) {
         .                           continue;
         .                       }
       410 ( 0.00%)              i += 1;
         .                   }
    16,193 ( 0.00%)          return looker(&token);
       738 ( 0.00%)      }
         .           
         .               /// Returns whether any of the given keywords are `dist` tokens ahead of the current one.
    14,769 ( 0.00%)      fn is_keyword_ahead(&self, dist: usize, kws: &[Symbol]) -> bool {
     3,453 ( 0.00%)          self.look_ahead(dist, |t| kws.iter().any(|&kw| t.is_keyword(kw)))
    14,769 ( 0.00%)      }
         .           
         .               /// Parses asyncness: `async` or nothing.
         .               fn parse_asyncness(&mut self) -> Async {
         .                   if self.eat_keyword(kw::Async) {
         .                       let span = self.prev_token.uninterpolated_span();
         .                       Async::Yes { span, closure_id: DUMMY_NODE_ID, return_impl_trait_id: DUMMY_NODE_ID }
         .                   } else {
         .                       Async::No
         .                   }
         .               }
         .           
         .               /// Parses unsafety: `unsafe` or nothing.
       142 ( 0.00%)      fn parse_unsafety(&mut self) -> Unsafe {
         .                   if self.eat_keyword(kw::Unsafe) {
         .                       Unsafe::Yes(self.prev_token.uninterpolated_span())
         .                   } else {
         .                       Unsafe::No
         .                   }
       568 ( 0.00%)      }
         .           
         .               /// Parses constness: `const` or nothing.
     3,896 ( 0.00%)      fn parse_constness(&mut self) -> Const {
         .                   // Avoid const blocks to be parsed as const items
     1,090 ( 0.00%)          if self.look_ahead(1, |t| t != &token::OpenDelim(DelimToken::Brace))
         .                       && self.eat_keyword(kw::Const)
         .                   {
         .                       Const::Yes(self.prev_token.uninterpolated_span())
         .                   } else {
         .                       Const::No
         .                   }
     6,818 ( 0.00%)      }
         .           
         .               /// Parses inline const expressions.
         .               fn parse_const_block(&mut self, span: Span, pat: bool) -> PResult<'a, P<Expr>> {
         .                   if pat {
         .                       self.sess.gated_spans.gate(sym::inline_const_pat, span);
         .                   } else {
         .                       self.sess.gated_spans.gate(sym::inline_const, span);
         .                   }
-- line 1104 ----------------------------------------
-- line 1108 ----------------------------------------
         .                       id: DUMMY_NODE_ID,
         .                       value: self.mk_expr(blk.span, ExprKind::Block(blk, None), AttrVec::new()),
         .                   };
         .                   let blk_span = anon_const.value.span;
         .                   Ok(self.mk_expr(span.to(blk_span), ExprKind::ConstBlock(anon_const), AttrVec::new()))
         .               }
         .           
         .               /// Parses mutability (`mut` or nothing).
        64 ( 0.00%)      fn parse_mutability(&mut self) -> Mutability {
         .                   if self.eat_keyword(kw::Mut) { Mutability::Mut } else { Mutability::Not }
     6,968 ( 0.00%)      }
         .           
         .               /// Possibly parses mutability (`const` or `mut`).
         .               fn parse_const_or_mut(&mut self) -> Option<Mutability> {
         .                   if self.eat_keyword(kw::Mut) {
         .                       Some(Mutability::Mut)
         .                   } else if self.eat_keyword(kw::Const) {
         .                       Some(Mutability::Not)
         .                   } else {
         .                       None
         .                   }
         .               }
         .           
         .               fn parse_field_name(&mut self) -> PResult<'a, Ident> {
       114 ( 0.00%)          if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = self.token.kind
         .                   {
         .                       self.expect_no_suffix(self.token.span, "a tuple index", suffix);
         .                       self.bump();
         .                       Ok(Ident::new(symbol, self.prev_token.span))
         .                   } else {
       171 ( 0.00%)              self.parse_ident_common(true)
         .                   }
         .               }
         .           
         .               fn parse_mac_args(&mut self) -> PResult<'a, P<MacArgs>> {
    27,012 ( 0.00%)          self.parse_mac_args_common(true).map(P)
         .               }
         .           
         .               fn parse_attr_args(&mut self) -> PResult<'a, MacArgs> {
       141 ( 0.00%)          self.parse_mac_args_common(false)
         .               }
         .           
   113,292 ( 0.00%)      fn parse_mac_args_common(&mut self, delimited_only: bool) -> PResult<'a, MacArgs> {
   100,704 ( 0.00%)          Ok(
    63,536 ( 0.00%)              if self.check(&token::OpenDelim(DelimToken::Paren))
       447 ( 0.00%)                  || self.check(&token::OpenDelim(DelimToken::Bracket))
       447 ( 0.00%)                  || self.check(&token::OpenDelim(DelimToken::Brace))
         .                       {
    50,328 ( 0.00%)                  match self.parse_token_tree() {
    62,910 ( 0.00%)                      TokenTree::Delimited(dspan, delim, tokens) =>
         .                               // We've confirmed above that there is a delimiter so unwrapping is OK.
         .                               {
    25,164 ( 0.00%)                          MacArgs::Delimited(dspan, MacDelimiter::from_token(delim).unwrap(), tokens)
         .                               }
         .                               _ => unreachable!(),
         .                           }
        12 ( 0.00%)              } else if !delimited_only {
         .                           if self.eat(&token::Eq) {
         .                               let eq_span = self.prev_token.span;
         .           
         .                               // Collect tokens because they are used during lowering to HIR.
         .                               let expr = self.parse_expr_force_collect()?;
         .                               let span = expr.span;
         .           
         .                               let token_kind = token::Interpolated(Lrc::new(token::NtExpr(expr)));
-- line 1172 ----------------------------------------
-- line 1173 ----------------------------------------
         .                               MacArgs::Eq(eq_span, Token::new(token_kind, span))
         .                           } else {
         .                               MacArgs::Empty
         .                           }
         .                       } else {
         .                           return self.unexpected();
         .                       },
         .                   )
    88,116 ( 0.00%)      }
         .           
         .               fn parse_or_use_outer_attributes(
         .                   &mut self,
         .                   already_parsed_attrs: Option<AttrWrapper>,
         .               ) -> PResult<'a, AttrWrapper> {
    40,281 ( 0.00%)          if let Some(attrs) = already_parsed_attrs {
         .                       Ok(attrs)
         .                   } else {
    25,290 ( 0.00%)              self.parse_outer_attributes()
         .                   }
         .               }
         .           
         .               /// Parses a single token tree from the input.
 1,379,952 ( 0.00%)      pub(crate) fn parse_token_tree(&mut self) -> TokenTree {
 1,097,626 ( 0.00%)          match self.token.kind {
         .                       token::OpenDelim(..) => {
         .                           let depth = self.token_cursor.stack.len();
         .           
         .                           // We keep advancing the token cursor until we hit
         .                           // the matching `CloseDelim` token.
 1,100,808 ( 0.00%)                  while !(depth == self.token_cursor.stack.len()
         .                               && matches!(self.token.kind, token::CloseDelim(_)))
         .                           {
         .                               // Advance one token at a time, so `TokenCursor::next()`
         .                               // can capture these tokens if necessary.
   766,210 ( 0.00%)                      self.bump();
         .                           }
         .                           // We are still inside the frame corresponding
         .                           // to the delimited stream we captured, so grab
         .                           // the tokens from this frame.
         .                           let frame = &self.token_cursor.frame;
    54,916 ( 0.00%)                  let stream = frame.tree_cursor.stream.clone();
    54,916 ( 0.00%)                  let span = frame.span;
    27,458 ( 0.00%)                  let delim = frame.delim;
         .                           // Consume close delimiter
    54,916 ( 0.00%)                  self.bump();
   137,290 ( 0.00%)                  TokenTree::Delimited(span, delim, stream)
         .                       }
         .                       token::CloseDelim(_) | token::Eof => unreachable!(),
         .                       _ => {
   290,072 ( 0.00%)                  self.bump();
   725,180 ( 0.00%)                  TokenTree::Token(self.prev_token.clone())
         .                       }
         .                   }
 1,207,458 ( 0.00%)      }
         .           
         .               /// Parses a stream of tokens into a list of `TokenTree`s, up to EOF.
         .               pub fn parse_all_token_trees(&mut self) -> PResult<'a, Vec<TokenTree>> {
         .                   let mut tts = Vec::new();
         .                   while self.token != token::Eof {
         .                       tts.push(self.parse_token_tree());
         .                   }
         .                   Ok(tts)
         .               }
         .           
        40 ( 0.00%)      pub fn parse_tokens(&mut self) -> TokenStream {
         .                   let mut result = Vec::new();
         .                   loop {
        80 ( 0.00%)              match self.token.kind {
         .                           token::Eof | token::CloseDelim(..) => break,
        27 ( 0.00%)                  _ => result.push(self.parse_token_tree().into()),
         .                       }
         .                   }
        30 ( 0.00%)          TokenStream::new(result)
        40 ( 0.00%)      }
         .           
         .               /// Evaluates the closure with restrictions in place.
         .               ///
         .               /// Afters the closure is evaluated, restrictions are reset.
         .               fn with_res<T>(&mut self, res: Restrictions, f: impl FnOnce(&mut Self) -> T) -> T {
    16,717 ( 0.00%)          let old = self.restrictions;
    20,882 ( 0.00%)          self.restrictions = res;
         .                   let res = f(self);
    17,934 ( 0.00%)          self.restrictions = old;
         .                   res
         .               }
         .           
   118,064 ( 0.00%)      fn is_crate_vis(&self) -> bool {
    73,790 ( 0.00%)          self.token.is_keyword(kw::Crate) && self.look_ahead(1, |t| t != &token::ModSep)
   132,822 ( 0.00%)      }
         .           
         .               /// Parses `pub`, `pub(crate)` and `pub(in path)` plus shortcuts `crate` for `pub(crate)`,
         .               /// `pub(self)` for `pub(in self)` and `pub(super)` for `pub(in super)`.
         .               /// If the following element can't be a tuple (i.e., it's a function definition), then
         .               /// it's not a tuple struct field), and the contents within the parentheses aren't valid,
         .               /// so emit a proper diagnostic.
         .               // Public for rustfmt usage.
     5,810 ( 0.00%)      pub fn parse_visibility(&mut self, fbt: FollowedByType) -> PResult<'a, Visibility> {
     1,171 ( 0.00%)          maybe_whole!(self, NtVis, |x| x);
         .           
       581 ( 0.00%)          self.expected_tokens.push(TokenType::Keyword(kw::Crate));
     2,324 ( 0.00%)          if self.is_crate_vis() {
         .                       self.bump(); // `crate`
         .                       self.sess.gated_spans.gate(sym::crate_visibility_modifier, self.prev_token.span);
         .                       return Ok(Visibility {
         .                           span: self.prev_token.span,
         .                           kind: VisibilityKind::Crate(CrateSugar::JustCrate),
         .                           tokens: None,
         .                       });
         .                   }
         .           
         .                   if !self.eat_keyword(kw::Pub) {
         .                       // We need a span for our `Spanned<VisibilityKind>`, but there's inherently no
         .                       // keyword to grab a span from for inherited visibility; an empty span at the
         .                       // beginning of the current token would seem to be the "Schelling span".
       511 ( 0.00%)              return Ok(Visibility {
     1,533 ( 0.00%)                  span: self.token.span.shrink_to_lo(),
         .                           kind: VisibilityKind::Inherited,
         .                           tokens: None,
         .                       });
         .                   }
        70 ( 0.00%)          let lo = self.prev_token.span;
         .           
       350 ( 0.00%)          if self.check(&token::OpenDelim(token::Paren)) {
         .                       // We don't `self.bump()` the `(` yet because this might be a struct definition where
         .                       // `()` or a tuple might be allowed. For example, `struct Struct(pub (), pub (usize));`.
         .                       // Because of this, we only `bump` the `(` if we're assured it is appropriate to do so
         .                       // by the following tokens.
        90 ( 0.00%)              if self.is_keyword_ahead(1, &[kw::Crate]) && self.look_ahead(2, |t| t != &token::ModSep)
         .                       // account for `pub(crate::foo)`
         .                       {
         .                           // Parse `pub(crate)`.
        30 ( 0.00%)                  self.bump(); // `(`
        20 ( 0.00%)                  self.bump(); // `crate`
        30 ( 0.00%)                  self.expect(&token::CloseDelim(token::Paren))?; // `)`
        10 ( 0.00%)                  let vis = VisibilityKind::Crate(CrateSugar::PubCrate);
         .                           return Ok(Visibility {
        30 ( 0.00%)                      span: lo.to(self.prev_token.span),
         .                               kind: vis,
         .                               tokens: None,
         .                           });
         .                       } else if self.is_keyword_ahead(1, &[kw::In]) {
         .                           // Parse `pub(in path)`.
         .                           self.bump(); // `(`
         .                           self.bump(); // `in`
         .                           let path = self.parse_path(PathStyle::Mod)?; // `path`
-- line 1317 ----------------------------------------
-- line 1338 ----------------------------------------
         .                       } else if let FollowedByType::No = fbt {
         .                           // Provide this diagnostic if a type cannot follow;
         .                           // in particular, if this is not a tuple struct.
         .                           self.recover_incorrect_vis_restriction()?;
         .                           // Emit diagnostic, but continue with public visibility.
         .                       }
         .                   }
         .           
       180 ( 0.00%)          Ok(Visibility { span: lo, kind: VisibilityKind::Public, tokens: None })
     5,229 ( 0.00%)      }
         .           
         .               /// Recovery for e.g. `pub(something) fn ...` or `struct X { pub(something) y: Z }`
         .               fn recover_incorrect_vis_restriction(&mut self) -> PResult<'a, ()> {
         .                   self.bump(); // `(`
         .                   let path = self.parse_path(PathStyle::Mod)?;
         .                   self.expect(&token::CloseDelim(token::Paren))?; // `)`
         .           
         .                   let msg = "incorrect visibility restriction";
-- line 1355 ----------------------------------------
-- line 1370 ----------------------------------------
         .                       )
         .                       .emit();
         .           
         .                   Ok(())
         .               }
         .           
         .               /// Parses `extern string_literal?`.
         .               fn parse_extern(&mut self) -> Extern {
        52 ( 0.00%)          if self.eat_keyword(kw::Extern) { Extern::from_abi(self.parse_abi()) } else { Extern::None }
         .               }
         .           
         .               /// Parses a string literal as an ABI spec.
         .               fn parse_abi(&mut self) -> Option<StrLit> {
         .                   match self.parse_str_lit() {
         .                       Ok(str_lit) => Some(str_lit),
         .                       Err(Some(lit)) => match lit.kind {
         .                           ast::LitKind::Err(_) => None,
-- line 1386 ----------------------------------------
-- line 1395 ----------------------------------------
         .                                   .emit();
         .                               None
         .                           }
         .                       },
         .                       Err(None) => None,
         .                   }
         .               }
         .           
     7,650 ( 0.00%)      pub fn collect_tokens_no_attrs<R: AstLike>(
         .                   &mut self,
         .                   f: impl FnOnce(&mut Self) -> PResult<'a, R>,
         .               ) -> PResult<'a, R> {
         .                   // The only reason to call `collect_tokens_no_attrs` is if you want tokens, so use
         .                   // `ForceCollect::Yes`
         .                   self.collect_tokens_trailing_token(
         .                       AttrWrapper::empty(),
         .                       ForceCollect::Yes,
       830 ( 0.00%)              |this, _attrs| Ok((f(this)?, TrailingToken::None)),
         .                   )
     7,650 ( 0.00%)      }
         .           
         .               /// `::{` or `::*`
   350,472 ( 0.00%)      fn is_import_coupler(&mut self) -> bool {
   175,236 ( 0.00%)          self.check(&token::ModSep)
         .                       && self.look_ahead(1, |t| {
   209,728 ( 0.00%)                  *t == token::OpenDelim(token::Brace) || *t == token::BinOp(token::Star)
         .                       })
   349,317 ( 0.00%)      }
         .           
         .               pub fn clear_expected_tokens(&mut self) {
         .                   self.expected_tokens.clear();
         .               }
         .           }
         .           
         .           crate fn make_unclosed_delims_error(
         .               unmatched: UnmatchedBrace,
-- line 1430 ----------------------------------------
-- line 1450 ----------------------------------------
         .                   err.span_label(sp, "closing delimiter possibly meant for this");
         .               }
         .               if let Some(sp) = unmatched.unclosed_span {
         .                   err.span_label(sp, "unclosed delimiter");
         .               }
         .               Some(err)
         .           }
         .           
 1,261,312 ( 0.00%)  pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedBrace>, sess: &ParseSess) {
   630,656 ( 0.00%)      *sess.reached_eof.borrow_mut() |=
         .                   unclosed_delims.iter().any(|unmatched_delim| unmatched_delim.found_delim.is_none());
   630,656 ( 0.00%)      for unmatched in unclosed_delims.drain(..) {
         .                   if let Some(mut e) = make_unclosed_delims_error(unmatched, sess) {
         .                       e.emit();
         .                   }
         .               }
 1,261,312 ( 0.00%)  }
         .           
         .           /// A helper struct used when building an `AttrAnnotatedTokenStream` from
         .           /// a `LazyTokenStream`. Both delimiter and non-delimited tokens
         .           /// are stored as `FlatToken::Token`. A vector of `FlatToken`s
         .           /// is then 'parsed' to build up an `AttrAnnotatedTokenStream` with nested
         .           /// `AttrAnnotatedTokenTree::Delimited` tokens
         .           #[derive(Debug, Clone)]
         .           pub enum FlatToken {
-- line 1474 ----------------------------------------

 4,578,437 ( 0.01%)  <counts for unidentified lines in /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_parse/src/parser/mod.rs>

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs
--------------------------------------------------------------------------------
Ir                  

-- line 293 ----------------------------------------
         .           
         .           #[allow(deprecated)]
         .           impl From<LayoutErr> for CollectionAllocErr {
         .               fn from(_: LayoutErr) -> Self {
         .                   CollectionAllocErr::CapacityOverflow
         .               }
         .           }
         .           
     2,917 ( 0.00%)  fn infallible<T>(result: Result<T, CollectionAllocErr>) -> T {
 1,265,665 ( 0.00%)      match result {
         .                   Ok(x) => x,
         .                   Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
         .                   Err(CollectionAllocErr::AllocErr { layout }) => alloc::alloc::handle_alloc_error(layout),
         .               }
     5,834 ( 0.00%)  }
         .           
         .           /// FIXME: use `Layout::array` when we require a Rust version where it’s stable
         .           /// https://github.com/rust-lang/rust/issues/55724
         .           fn layout_array<T>(n: usize) -> Result<Layout, CollectionAllocErr> {
         .               let size = mem::size_of::<T>()
         .                   .checked_mul(n)
         .                   .ok_or(CollectionAllocErr::CapacityOverflow)?;
         .               let align = mem::align_of::<T>();
-- line 315 ----------------------------------------
-- line 422 ----------------------------------------
         .           #[cfg(feature = "union")]
         .           impl<A: Array> SmallVecData<A> {
         .               #[inline]
         .               unsafe fn inline(&self) -> *const A::Item {
         .                   self.inline.as_ptr() as *const A::Item
         .               }
         .               #[inline]
         .               unsafe fn inline_mut(&mut self) -> *mut A::Item {
   153,280 ( 0.00%)          self.inline.as_mut_ptr() as *mut A::Item
         .               }
         .               #[inline]
         .               fn from_inline(inline: MaybeUninit<A>) -> SmallVecData<A> {
         .                   SmallVecData {
         .                       inline: core::mem::ManuallyDrop::new(inline),
         .                   }
         .               }
         .               #[inline]
         .               unsafe fn into_inline(self) -> MaybeUninit<A> {
         .                   core::mem::ManuallyDrop::into_inner(self.inline)
         .               }
         .               #[inline]
         .               unsafe fn heap(&self) -> (*mut A::Item, usize) {
   256,775 ( 0.00%)          self.heap
         .               }
         .               #[inline]
         .               unsafe fn heap_mut(&mut self) -> &mut (*mut A::Item, usize) {
         .                   &mut self.heap
         .               }
         .               #[inline]
         .               fn from_heap(ptr: *mut A::Item, len: usize) -> SmallVecData<A> {
         .                   SmallVecData { heap: (ptr, len) }
-- line 452 ----------------------------------------
-- line 557 ----------------------------------------
         .               #[inline]
         .               pub fn new() -> SmallVec<A> {
         .                   // Try to detect invalid custom implementations of `Array`. Hopefully,
         .                   // this check should be optimized away entirely for valid ones.
         .                   assert!(
         .                       mem::size_of::<A>() == A::size() * mem::size_of::<A::Item>()
         .                           && mem::align_of::<A>() >= mem::align_of::<A::Item>()
         .                   );
 2,262,873 ( 0.01%)          SmallVec {
         .                       capacity: 0,
         .                       data: SmallVecData::from_inline(MaybeUninit::uninit()),
         .                   }
         .               }
         .           
         .               /// Construct an empty vector with enough capacity pre-allocated to store at least `n`
         .               /// elements.
         .               ///
-- line 573 ----------------------------------------
-- line 597 ----------------------------------------
         .               ///
         .               /// let vec = vec![1, 2, 3, 4, 5];
         .               /// let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);
         .               ///
         .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
         .               /// ```
         .               #[inline]
         .               pub fn from_vec(mut vec: Vec<A::Item>) -> SmallVec<A> {
     2,358 ( 0.00%)          if vec.capacity() <= Self::inline_capacity() {
         .                       unsafe {
         .                           let mut data = SmallVecData::<A>::from_inline(MaybeUninit::uninit());
         .                           let len = vec.len();
         .                           vec.set_len(0);
         .                           ptr::copy_nonoverlapping(vec.as_ptr(), data.inline_mut(), len);
         .           
         .                           SmallVec {
         .                               capacity: len,
         .                               data,
         .                           }
         .                       }
         .                   } else {
         .                       let (ptr, cap, len) = (vec.as_mut_ptr(), vec.capacity(), vec.len());
         .                       mem::forget(vec);
         .           
     3,843 ( 0.00%)              SmallVec {
         .                           capacity: cap,
         .                           data: SmallVecData::from_heap(ptr, len),
         .                       }
         .                   }
         .               }
         .           
         .               /// Constructs a new `SmallVec` on the stack from an `A` without
         .               /// copying elements.
-- line 629 ----------------------------------------
-- line 635 ----------------------------------------
         .               /// let small_vec: SmallVec<_> = SmallVec::from_buf(buf);
         .               ///
         .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
         .               /// ```
         .               #[inline]
         .               pub fn from_buf(buf: A) -> SmallVec<A> {
         .                   SmallVec {
         .                       capacity: A::size(),
     9,828 ( 0.00%)              data: SmallVecData::from_inline(MaybeUninit::new(buf)),
         .                   }
         .               }
         .           
         .               /// Constructs a new `SmallVec` on the stack from an `A` without
         .               /// copying elements. Also sets the length, which must be less or
         .               /// equal to the size of `buf`.
         .               ///
         .               /// ```rust
-- line 651 ----------------------------------------
-- line 653 ----------------------------------------
         .               ///
         .               /// let buf = [1, 2, 3, 4, 5, 0, 0, 0];
         .               /// let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);
         .               ///
         .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
         .               /// ```
         .               #[inline]
         .               pub fn from_buf_and_len(buf: A, len: usize) -> SmallVec<A> {
    70,166 ( 0.00%)          assert!(len <= A::size());
   210,498 ( 0.00%)          unsafe { SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), len) }
         .               }
         .           
         .               /// Constructs a new `SmallVec` on the stack from an `A` without
         .               /// copying elements. Also sets the length. The user is responsible
         .               /// for ensuring that `len <= A::size()`.
         .               ///
         .               /// ```rust
         .               /// use smallvec::SmallVec;
-- line 670 ----------------------------------------
-- line 674 ----------------------------------------
         .               /// let small_vec: SmallVec<_> = unsafe {
         .               ///     SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)
         .               /// };
         .               ///
         .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
         .               /// ```
         .               #[inline]
         .               pub unsafe fn from_buf_and_len_unchecked(buf: MaybeUninit<A>, len: usize) -> SmallVec<A> {
    35,083 ( 0.00%)          SmallVec {
         .                       capacity: len,
         .                       data: SmallVecData::from_inline(buf),
         .                   }
         .               }
         .           
         .               /// Sets the length of a vector.
         .               ///
         .               /// This will explicitly set the size of the vector, without actually
         .               /// modifying its buffers, so it is up to the caller to ensure that the
         .               /// vector is actually the specified size.
         .               pub unsafe fn set_len(&mut self, new_len: usize) {
         .                   let (_, len_ptr, _) = self.triple_mut();
   212,352 ( 0.00%)          *len_ptr = new_len;
         .               }
         .           
         .               /// The maximum number of elements this vector can hold inline
         .               #[inline]
         .               fn inline_capacity() -> usize {
         .                   if mem::size_of::<A::Item>() > 0 {
        24 ( 0.00%)              A::size()
         .                   } else {
         .                       // For zero-size items code like `ptr.add(offset)` always returns the same pointer.
         .                       // Therefore all items are at the same address,
         .                       // and any array size has capacity for infinitely many items.
         .                       // The capacity is limited by the bit width of the length field.
         .                       //
         .                       // `Vec` also does this:
         .                       // https://github.com/rust-lang/rust/blob/1.44.0/src/liballoc/raw_vec.rs#L186
-- line 710 ----------------------------------------
-- line 725 ----------------------------------------
         .               #[inline]
         .               pub fn len(&self) -> usize {
         .                   self.triple().1
         .               }
         .           
         .               /// Returns `true` if the vector is empty
         .               #[inline]
         .               pub fn is_empty(&self) -> bool {
 1,296,901 ( 0.00%)          self.len() == 0
         .               }
         .           
         .               /// The number of items the vector can hold without reallocating
         .               #[inline]
         .               pub fn capacity(&self) -> usize {
         .                   self.triple().2
         .               }
         .           
         .               /// Returns a tuple with (data ptr, len, capacity)
         .               /// Useful to get all SmallVec properties with a single check of the current storage variant.
         .               #[inline]
         .               fn triple(&self) -> (*const A::Item, usize, usize) {
         .                   unsafe {
 9,834,897 ( 0.02%)              if self.spilled() {
         .                           let (ptr, len) = self.data.heap();
         .                           (ptr, len, self.capacity)
         .                       } else {
         .                           (self.data.inline(), self.capacity, Self::inline_capacity())
         .                       }
         .                   }
         .               }
         .           
         .               /// Returns a tuple with (data ptr, len ptr, capacity)
         .               #[inline]
         .               fn triple_mut(&mut self) -> (*mut A::Item, &mut usize, usize) {
         .                   unsafe {
33,859,490 ( 0.08%)              if self.spilled() {
    50,057 ( 0.00%)                  let &mut (ptr, ref mut len_ptr) = self.data.heap_mut();
         .                           (ptr, len_ptr, self.capacity)
         .                       } else {
         .                           (
         .                               self.data.inline_mut(),
         .                               &mut self.capacity,
         .                               Self::inline_capacity(),
         .                           )
         .                       }
         .                   }
         .               }
         .           
         .               /// Returns `true` if the data has spilled into a separate heap-allocated buffer.
         .               #[inline]
         .               pub fn spilled(&self) -> bool {
26,043,154 ( 0.06%)          self.capacity > Self::inline_capacity()
         .               }
         .           
         .               /// Creates a draining iterator that removes the specified range in the vector
         .               /// and yields the removed items.
         .               ///
         .               /// Note 1: The element range is removed even if the iterator is only
         .               /// partially consumed or not consumed at all.
         .               ///
-- line 784 ----------------------------------------
-- line 821 ----------------------------------------
         .                           iter: range_slice.iter(),
         .                           vec: NonNull::from(self),
         .                       }
         .                   }
         .               }
         .           
         .               /// Append an item to the vector.
         .               #[inline]
   199,340 ( 0.00%)      pub fn push(&mut self, value: A::Item) {
         .                   unsafe {
         .                       let (mut ptr, mut len, cap) = self.triple_mut();
 5,145,832 ( 0.01%)              if *len == cap {
     4,029 ( 0.00%)                  self.reserve(1);
    41,937 ( 0.00%)                  let &mut (heap_ptr, ref mut heap_len) = self.data.heap_mut();
         .                           ptr = heap_ptr;
         .                           len = heap_len;
         .                       }
    61,781 ( 0.00%)              ptr::write(ptr.add(*len), value);
 6,951,913 ( 0.02%)              *len += 1;
         .                   }
   159,472 ( 0.00%)      }
         .           
         .               /// Remove an item from the end of the vector and return it, or None if empty.
         .               #[inline]
         .               pub fn pop(&mut self) -> Option<A::Item> {
         .                   unsafe {
         .                       let (ptr, len_ptr, _) = self.triple_mut();
 3,056,819 ( 0.01%)              if *len_ptr == 0 {
     3,518 ( 0.00%)                  return None;
         .                       }
   841,261 ( 0.00%)              let last_index = *len_ptr - 1;
 1,126,466 ( 0.00%)              *len_ptr = last_index;
   118,435 ( 0.00%)              Some(ptr::read(ptr.add(last_index)))
         .                   }
    10,390 ( 0.00%)      }
         .           
         .               /// Moves all the elements of `other` into `self`, leaving `other` empty.
         .               ///
         .               /// # Example
         .               ///
         .               /// ```
         .               /// # use smallvec::{SmallVec, smallvec};
         .               /// let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];
-- line 863 ----------------------------------------
-- line 879 ----------------------------------------
         .               /// or if the capacity computation overflows `usize`.
         .               pub fn grow(&mut self, new_cap: usize) {
         .                   infallible(self.try_grow(new_cap))
         .               }
         .           
         .               /// Re-allocate to set the capacity to `max(new_cap, inline_size())`.
         .               ///
         .               /// Panics if `new_cap` is less than the vector's length
     3,331 ( 0.00%)      pub fn try_grow(&mut self, new_cap: usize) -> Result<(), CollectionAllocErr> {
         .                   unsafe {
       101 ( 0.00%)              let (ptr, &mut len, cap) = self.triple_mut();
         .                       let unspilled = !self.spilled();
    81,470 ( 0.00%)              assert!(new_cap >= len);
    81,470 ( 0.00%)              if new_cap <= self.inline_size() {
         .                           if unspilled {
         .                               return Ok(());
         .                           }
         .                           self.data = SmallVecData::from_inline(MaybeUninit::uninit());
         .                           ptr::copy_nonoverlapping(ptr, self.data.inline_mut(), len);
         .                           self.capacity = len;
         .                           deallocate(ptr, cap);
    81,470 ( 0.00%)              } else if new_cap != cap {
    73,159 ( 0.00%)                  let layout = layout_array::<A::Item>(new_cap)?;
         .                           debug_assert!(layout.size() > 0);
         .                           let new_alloc;
    40,735 ( 0.00%)                  if unspilled {
         .                               new_alloc = NonNull::new(alloc::alloc::alloc(layout))
         .                                   .ok_or(CollectionAllocErr::AllocErr { layout })?
         .                                   .cast()
         .                                   .as_ptr();
         .                               ptr::copy_nonoverlapping(ptr, new_alloc, len);
         .                           } else {
         .                               // This should never fail since the same succeeded
         .                               // when previously allocating `ptr`.
    23,095 ( 0.00%)                      let old_layout = layout_array::<A::Item>(cap)?;
         .           
         .                               let new_ptr = alloc::alloc::realloc(ptr as *mut u8, old_layout, layout.size());
         .                               new_alloc = NonNull::new(new_ptr)
         .                                   .ok_or(CollectionAllocErr::AllocErr { layout })?
         .                                   .cast()
         .                                   .as_ptr();
         .                           }
    81,470 ( 0.00%)                  self.data = SmallVecData::from_heap(new_alloc, len);
   116,329 ( 0.00%)                  self.capacity = new_cap;
         .                       }
         .                       Ok(())
         .                   }
     3,432 ( 0.00%)      }
         .           
         .               /// Reserve capacity for `additional` more elements to be inserted.
         .               ///
         .               /// May reserve more space to avoid frequent reallocations.
         .               ///
         .               /// Panics if the capacity computation overflows `usize`.
         .               #[inline]
   310,023 ( 0.00%)      pub fn reserve(&mut self, additional: usize) {
 1,349,607 ( 0.00%)          infallible(self.try_reserve(additional))
   351,832 ( 0.00%)      }
         .           
         .               /// Reserve capacity for `additional` more elements to be inserted.
         .               ///
         .               /// May reserve more space to avoid frequent reallocations.
 5,228,864 ( 0.01%)      pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
         .                   // prefer triple_mut() even if triple() would work
         .                   // so that the optimizer removes duplicated calls to it
         .                   // from callers like insert()
    15,297 ( 0.00%)          let (_, &mut len, cap) = self.triple_mut();
 4,091,106 ( 0.01%)          if cap - len >= additional {
         .                       return Ok(());
         .                   }
         .                   let new_cap = len
         .                       .checked_add(additional)
         .                       .and_then(usize::checked_next_power_of_two)
         .                       .ok_or(CollectionAllocErr::CapacityOverflow)?;
       755 ( 0.00%)          self.try_grow(new_cap)
 5,693,926 ( 0.01%)      }
         .           
         .               /// Reserve the minimum capacity for `additional` more elements to be inserted.
         .               ///
         .               /// Panics if the new capacity overflows `usize`.
         .               pub fn reserve_exact(&mut self, additional: usize) {
         .                   infallible(self.try_reserve_exact(additional))
         .               }
         .           
         .               /// Reserve the minimum capacity for `additional` more elements to be inserted.
         .               pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
         .                   let (_, &mut len, cap) = self.triple_mut();
   134,233 ( 0.00%)          if cap - len >= additional {
         .                       return Ok(());
         .                   }
         .                   let new_cap = len
         .                       .checked_add(additional)
         .                       .ok_or(CollectionAllocErr::CapacityOverflow)?;
        65 ( 0.00%)          self.try_grow(new_cap)
        65 ( 0.00%)      }
         .           
         .               /// Shrink the capacity of the vector as much as possible.
         .               ///
         .               /// When possible, this will move data from an external heap buffer to the vector's inline
         .               /// storage.
         .               pub fn shrink_to_fit(&mut self) {
         .                   if !self.spilled() {
         .                       return;
-- line 981 ----------------------------------------
-- line 999 ----------------------------------------
         .               /// If `len` is greater than or equal to the vector's current length, this has no
         .               /// effect.
         .               ///
         .               /// This does not re-allocate.  If you want the vector's capacity to shrink, call
         .               /// `shrink_to_fit` after truncating.
         .               pub fn truncate(&mut self, len: usize) {
         .                   unsafe {
         .                       let (ptr, len_ptr, _) = self.triple_mut();
   104,200 ( 0.00%)              while len < *len_ptr {
         .                           let last_index = *len_ptr - 1;
         .                           *len_ptr = last_index;
         .                           ptr::drop_in_place(ptr.add(last_index));
         .                       }
         .                   }
         .               }
         .           
         .               /// Extracts a slice containing the entire vector.
-- line 1015 ----------------------------------------
-- line 1044 ----------------------------------------
         .               pub fn clear(&mut self) {
         .                   self.truncate(0);
         .               }
         .           
         .               /// Remove and return the element at position `index`, shifting all elements after it to the
         .               /// left.
         .               ///
         .               /// Panics if `index` is out of bounds.
       400 ( 0.00%)      pub fn remove(&mut self, index: usize) -> A::Item {
         .                   unsafe {
         .                       let (mut ptr, len_ptr, _) = self.triple_mut();
     9,484 ( 0.00%)              let len = *len_ptr;
    29,520 ( 0.00%)              assert!(index < len);
    48,648 ( 0.00%)              *len_ptr = len - 1;
         .                       ptr = ptr.add(index);
         .                       let item = ptr::read(ptr);
    19,680 ( 0.00%)              ptr::copy(ptr.add(1), ptr, len - index - 1);
         .                       item
         .                   }
       500 ( 0.00%)      }
         .           
         .               /// Insert an element at position `index`, shifting all elements after it to the right.
         .               ///
         .               /// Panics if `index` is out of bounds.
    70,387 ( 0.00%)      pub fn insert(&mut self, index: usize, element: A::Item) {
         .                   self.reserve(1);
         .           
         .                   unsafe {
         .                       let (mut ptr, len_ptr, _) = self.triple_mut();
    20,873 ( 0.00%)              let len = *len_ptr;
    41,738 ( 0.00%)              assert!(index <= len);
    83,476 ( 0.00%)              *len_ptr = len + 1;
         .                       ptr = ptr.add(index);
    41,738 ( 0.00%)              ptr::copy(ptr, ptr.add(1), len - index);
         .                       ptr::write(ptr, element);
         .                   }
    44,794 ( 0.00%)      }
         .           
         .               /// Insert multiple elements at position `index`, shifting all following elements toward the
         .               /// back.
         .               pub fn insert_many<I: IntoIterator<Item = A::Item>>(&mut self, index: usize, iterable: I) {
         .                   let mut iter = iterable.into_iter();
         .                   if index == self.len() {
         .                       return self.extend(iter);
         .                   }
-- line 1088 ----------------------------------------
-- line 1201 ----------------------------------------
         .                   }
         .               }
         .           
         .               /// Retains only the elements specified by the predicate.
         .               ///
         .               /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
         .               /// This method operates in place and preserves the order of the retained
         .               /// elements.
   238,401 ( 0.00%)      pub fn retain<F: FnMut(&mut A::Item) -> bool>(&mut self, mut f: F) {
         .                   let mut del = 0;
         .                   let len = self.len();
         .                   for i in 0..len {
    40,372 ( 0.00%)              if !f(&mut self[i]) {
       228 ( 0.00%)                  del += 1;
    12,110 ( 0.00%)              } else if del > 0 {
        12 ( 0.00%)                  self.swap(i - del, i);
         .                       }
         .                   }
    52,978 ( 0.00%)          self.truncate(len - del);
   211,912 ( 0.00%)      }
         .           
         .               /// Removes consecutive duplicate elements.
         .               pub fn dedup(&mut self)
         .               where
         .                   A::Item: PartialEq<A::Item>,
         .               {
         .                   self.dedup_by(|a, b| a == b);
         .               }
-- line 1228 ----------------------------------------
-- line 1418 ----------------------------------------
         .                           capacity: len,
         .                           data: SmallVecData::from_inline(unsafe {
         .                               let mut data: MaybeUninit<A> = MaybeUninit::uninit();
         .                               ptr::copy_nonoverlapping(
         .                                   slice.as_ptr(),
         .                                   data.as_mut_ptr() as *mut A::Item,
         .                                   len,
         .                               );
     1,214 ( 0.00%)                      data
         .                           }),
         .                       }
         .                   } else {
         .                       let mut b = slice.to_vec();
         .                       let (ptr, cap) = (b.as_mut_ptr(), b.capacity());
         .                       mem::forget(b);
         .                       SmallVec {
         .                           capacity: cap,
-- line 1434 ----------------------------------------
-- line 1436 ----------------------------------------
         .                       }
         .                   }
         .               }
         .           
         .               /// Copy elements from a slice into the vector at position `index`, shifting any following
         .               /// elements toward the back.
         .               ///
         .               /// For slices of `Copy` types, this is more efficient than `insert`.
   463,775 ( 0.00%)      pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item]) {
         .                   self.reserve(slice.len());
         .           
         .                   let len = self.len();
   147,747 ( 0.00%)          assert!(index <= len);
         .           
         .                   unsafe {
         .                       let slice_ptr = slice.as_ptr();
         .                       let ptr = self.as_mut_ptr().add(index);
         .                       ptr::copy(ptr, ptr.add(slice.len()), len - index);
         .                       ptr::copy_nonoverlapping(slice_ptr, ptr, slice.len());
    98,498 ( 0.00%)              self.set_len(len + slice.len());
         .                   }
   393,992 ( 0.00%)      }
         .           
         .               /// Copy elements from a slice and append them to the vector.
         .               ///
         .               /// For slices of `Copy` types, this is more efficient than `extend`.
         .               #[inline]
         .               pub fn extend_from_slice(&mut self, slice: &[A::Item]) {
         .                   let len = self.len();
   118,624 ( 0.00%)          self.insert_from_slice(len, slice);
         .               }
         .           }
         .           
         .           impl<A: Array> SmallVec<A>
         .           where
         .               A::Item: Clone,
         .           {
         .               /// Resizes the vector so that its length is equal to `len`.
-- line 1473 ----------------------------------------
-- line 1489 ----------------------------------------
         .               /// Creates a `SmallVec` with `n` copies of `elem`.
         .               /// ```
         .               /// use smallvec::SmallVec;
         .               ///
         .               /// let v = SmallVec::<[char; 128]>::from_elem('d', 2);
         .               /// assert_eq!(v, SmallVec::from_buf(['d', 'd']));
         .               /// ```
         .               pub fn from_elem(elem: A::Item, n: usize) -> Self {
    14,168 ( 0.00%)          if n > Self::inline_capacity() {
         .                       vec![elem; n].into()
         .                   } else {
         .                       let mut v = SmallVec::<A>::new();
         .                       unsafe {
         .                           let (ptr, len_ptr, _) = v.triple_mut();
         .                           let mut local_len = SetLenOnDrop::new(len_ptr);
         .           
         .                           for i in 0..n {
         .                               ::core::ptr::write(ptr.add(i), elem.clone());
         .                               local_len.increment_len(1);
         .                           }
         .                       }
    20,946 ( 0.00%)              v
         .                   }
         .               }
         .           }
         .           
         .           impl<A: Array> ops::Deref for SmallVec<A> {
         .               type Target = [A::Item];
         .               #[inline]
         .               fn deref(&self) -> &[A::Item] {
-- line 1518 ----------------------------------------
-- line 1522 ----------------------------------------
         .                   }
         .               }
         .           }
         .           
         .           impl<A: Array> ops::DerefMut for SmallVec<A> {
         .               #[inline]
         .               fn deref_mut(&mut self) -> &mut [A::Item] {
         .                   unsafe {
   282,939 ( 0.00%)              let (ptr, &mut len, _) = self.triple_mut();
         .                       slice::from_raw_parts_mut(ptr, len)
         .                   }
         .               }
         .           }
         .           
         .           impl<A: Array> AsRef<[A::Item]> for SmallVec<A> {
         .               #[inline]
         .               fn as_ref(&self) -> &[A::Item] {
-- line 1538 ----------------------------------------
-- line 1716 ----------------------------------------
         .                   SmallVec::extend_from_slice(self, other)
         .               }
         .           }
         .           
         .           impl<A: Array> FromIterator<A::Item> for SmallVec<A> {
         .               #[inline]
         .               fn from_iter<I: IntoIterator<Item = A::Item>>(iterable: I) -> SmallVec<A> {
         .                   let mut v = SmallVec::new();
 1,622,743 ( 0.00%)          v.extend(iterable);
         .                   v
         .               }
         .           }
         .           
         .           impl<A: Array> Extend<A::Item> for SmallVec<A> {
 6,980,853 ( 0.02%)      fn extend<I: IntoIterator<Item = A::Item>>(&mut self, iterable: I) {
   538,695 ( 0.00%)          let mut iter = iterable.into_iter();
         .                   let (lower_size_bound, _) = iter.size_hint();
    50,154 ( 0.00%)          self.reserve(lower_size_bound);
         .           
         .                   unsafe {
         .                       let (ptr, len_ptr, cap) = self.triple_mut();
         .                       let mut len = SetLenOnDrop::new(len_ptr);
 2,699,824 ( 0.01%)              while len.get() < cap {
   790,602 ( 0.00%)                  if let Some(out) = iter.next() {
         .                               ptr::write(ptr.add(len.get()), out);
         .                               len.increment_len(1);
         .                           } else {
         .                               return;
         .                           }
         .                       }
         .                   }
         .           
   296,805 ( 0.00%)          for elem in iter {
     2,824 ( 0.00%)              self.push(elem);
         .                   }
 5,908,928 ( 0.01%)      }
         .           }
         .           
         .           impl<A: Array> fmt::Debug for SmallVec<A>
         .           where
         .               A::Item: fmt::Debug,
         .           {
         .               fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         .                   f.debug_list().entries(self.iter()).finish()
-- line 1759 ----------------------------------------
-- line 1764 ----------------------------------------
         .               #[inline]
         .               fn default() -> SmallVec<A> {
         .                   SmallVec::new()
         .               }
         .           }
         .           
         .           #[cfg(feature = "may_dangle")]
         .           unsafe impl<#[may_dangle] A: Array> Drop for SmallVec<A> {
11,466,855 ( 0.03%)      fn drop(&mut self) {
         .                   unsafe {
 5,360,550 ( 0.01%)              if self.spilled() {
         .                           let (ptr, len) = self.data.heap();
         .                           Vec::from_raw_parts(ptr, len, self.capacity);
         .                       } else {
         .                           ptr::drop_in_place(&mut self[..]);
         .                       }
         .                   }
11,631,945 ( 0.03%)      }
         .           }
         .           
         .           #[cfg(not(feature = "may_dangle"))]
         .           impl<A: Array> Drop for SmallVec<A> {
         .               fn drop(&mut self) {
         .                   unsafe {
         .                       if self.spilled() {
         .                           let (ptr, len) = self.data.heap();
-- line 1789 ----------------------------------------
-- line 1888 ----------------------------------------
         .               A::Item: Clone,
         .           {
         .               fn clone(&self) -> IntoIter<A> {
         .                   SmallVec::from(self.as_slice()).into_iter()
         .               }
         .           }
         .           
         .           impl<A: Array> Drop for IntoIter<A> {
     1,301 ( 0.00%)      fn drop(&mut self) {
    45,623 ( 0.00%)          for _ in self {}
     1,256 ( 0.00%)      }
         .           }
         .           
         .           impl<A: Array> Iterator for IntoIter<A> {
         .               type Item = A::Item;
         .           
         .               #[inline]
         .               fn next(&mut self) -> Option<A::Item> {
   737,491 ( 0.00%)          if self.current == self.end {
         .                       None
         .                   } else {
         .                       unsafe {
         .                           let current = self.current;
   416,854 ( 0.00%)                  self.current += 1;
     6,274 ( 0.00%)                  Some(ptr::read(self.data.as_ptr().add(current)))
         .                       }
         .                   }
         .               }
         .           
         .               #[inline]
         .               fn size_hint(&self) -> (usize, Option<usize>) {
    30,283 ( 0.00%)          let size = self.end - self.current;
         .                   (size, Some(size))
         .               }
         .           }
         .           
         .           impl<A: Array> DoubleEndedIterator for IntoIter<A> {
         .               #[inline]
         .               fn next_back(&mut self) -> Option<A::Item> {
         .                   if self.current == self.end {
-- line 1927 ----------------------------------------
-- line 1955 ----------------------------------------
         .           impl<A: Array> IntoIterator for SmallVec<A> {
         .               type IntoIter = IntoIter<A>;
         .               type Item = A::Item;
         .               fn into_iter(mut self) -> Self::IntoIter {
         .                   unsafe {
         .                       // Set SmallVec len to zero as `IntoIter` drop handles dropping of the elements
         .                       let len = self.len();
         .                       self.set_len(0);
    57,247 ( 0.00%)              IntoIter {
   438,538 ( 0.00%)                  data: self,
         .                           current: 0,
         .                           end: len,
         .                       }
         .                   }
         .               }
         .           }
         .           
         .           impl<'a, A: Array> IntoIterator for &'a SmallVec<A> {
-- line 1972 ----------------------------------------
-- line 2000 ----------------------------------------
         .               len: &'a mut usize,
         .               local_len: usize,
         .           }
         .           
         .           impl<'a> SetLenOnDrop<'a> {
         .               #[inline]
         .               fn new(len: &'a mut usize) -> Self {
         .                   SetLenOnDrop {
   745,550 ( 0.00%)              local_len: *len,
         .                       len,
         .                   }
         .               }
         .           
         .               #[inline]
         .               fn get(&self) -> usize {
         .                   self.local_len
         .               }
         .           
         .               #[inline]
         .               fn increment_len(&mut self, increment: usize) {
   336,927 ( 0.00%)          self.local_len += increment;
         .               }
         .           }
         .           
         .           impl<'a> Drop for SetLenOnDrop<'a> {
         .               #[inline]
         .               fn drop(&mut self) {
   862,574 ( 0.00%)          *self.len = self.local_len;
         .               }
         .           }
         .           
         .           #[cfg(feature = "const_new")]
         .           impl<T, const N: usize> SmallVec<[T; N]> {
         .               /// Construct an empty vector.
         .               ///
         .               /// This is a `const` version of [`SmallVec::new`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.
-- line 2035 ----------------------------------------

14,006,887 ( 0.03%)  <counts for unidentified lines in /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs>

--------------------------------------------------------------------------------
The following files chosen for auto-annotation could not be found:
--------------------------------------------------------------------------------
  ./malloc/malloc.c
  ./stdlib/msort.c
  ./string/../sysdeps/x86_64/multiarch/memchr-avx2.S
  ./string/../sysdeps/x86_64/multiarch/memcmp-avx2-movbe.S
  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S
  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
  ./string/../sysdeps/x86_64/multiarch/strcmp-avx2.S
  /tmp/gcc-build/x86_64-unknown-linux-gnu/libstdc++-v3/libsupc++/../../../../gcc-5.5.0/libstdc++-v3/libsupc++/new_op.cc

--------------------------------------------------------------------------------
Ir                   
--------------------------------------------------------------------------------
416,883,165 ( 0.96%)  events annotated