servius/rapr-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d5ecda4c73a5479d0abb59de7aced9466ac40e60
rapr-rs/docs/src/proc_macro2/lib.rs.html
T
Uttarayan Mondal d5ecda4c73 Initial docs commit
2021-03-15 01:27:34 +05:30

2475 lines
151 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/home/fs0c131y/.local/share/cargo/registry/src/github.com-1ecc6299db9ec823/proc-macro2-1.0.24/src/lib.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>lib.rs - source</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css" disabled ><link rel="stylesheet" type="text/css" href="../../ayu.css" disabled ><script id="default-settings"></script><script src="../../storage.js"></script><noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="icon" type="image/svg+xml" href="../../favicon.svg">
<link rel="alternate icon" type="image/png" href="../../favicon-16x16.png">
<link rel="alternate icon" type="image/png" href="../../favicon-32x32.png"><style type="text/css">#crate-search{background-image:url("../../down-arrow.svg");}</style></head><body class="rustdoc source"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">&#9776;</div><a href='../../proc_macro2/index.html'><div class='logo-container rust-logo'><img src='../../rust-logo.png' alt='logo'></div></a></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices" role="menu"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" disabled autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><button type="button" class="help-button">?</button>
<a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><pre class="line-numbers"><span id="1"> 1</span>
<span id="2"> 2</span>
<span id="3"> 3</span>
<span id="4"> 4</span>
<span id="5"> 5</span>
<span id="6"> 6</span>
<span id="7"> 7</span>
<span id="8"> 8</span>
<span id="9"> 9</span>
<span id="10"> 10</span>
<span id="11"> 11</span>
<span id="12"> 12</span>
<span id="13"> 13</span>
<span id="14"> 14</span>
<span id="15"> 15</span>
<span id="16"> 16</span>
<span id="17"> 17</span>
<span id="18"> 18</span>
<span id="19"> 19</span>
<span id="20"> 20</span>
<span id="21"> 21</span>
<span id="22"> 22</span>
<span id="23"> 23</span>
<span id="24"> 24</span>
<span id="25"> 25</span>
<span id="26"> 26</span>
<span id="27"> 27</span>
<span id="28"> 28</span>
<span id="29"> 29</span>
<span id="30"> 30</span>
<span id="31"> 31</span>
<span id="32"> 32</span>
<span id="33"> 33</span>
<span id="34"> 34</span>
<span id="35"> 35</span>
<span id="36"> 36</span>
<span id="37"> 37</span>
<span id="38"> 38</span>
<span id="39"> 39</span>
<span id="40"> 40</span>
<span id="41"> 41</span>
<span id="42"> 42</span>
<span id="43"> 43</span>
<span id="44"> 44</span>
<span id="45"> 45</span>
<span id="46"> 46</span>
<span id="47"> 47</span>
<span id="48"> 48</span>
<span id="49"> 49</span>
<span id="50"> 50</span>
<span id="51"> 51</span>
<span id="52"> 52</span>
<span id="53"> 53</span>
<span id="54"> 54</span>
<span id="55"> 55</span>
<span id="56"> 56</span>
<span id="57"> 57</span>
<span id="58"> 58</span>
<span id="59"> 59</span>
<span id="60"> 60</span>
<span id="61"> 61</span>
<span id="62"> 62</span>
<span id="63"> 63</span>
<span id="64"> 64</span>
<span id="65"> 65</span>
<span id="66"> 66</span>
<span id="67"> 67</span>
<span id="68"> 68</span>
<span id="69"> 69</span>
<span id="70"> 70</span>
<span id="71"> 71</span>
<span id="72"> 72</span>
<span id="73"> 73</span>
<span id="74"> 74</span>
<span id="75"> 75</span>
<span id="76"> 76</span>
<span id="77"> 77</span>
<span id="78"> 78</span>
<span id="79"> 79</span>
<span id="80"> 80</span>
<span id="81"> 81</span>
<span id="82"> 82</span>
<span id="83"> 83</span>
<span id="84"> 84</span>
<span id="85"> 85</span>
<span id="86"> 86</span>
<span id="87"> 87</span>
<span id="88"> 88</span>
<span id="89"> 89</span>
<span id="90"> 90</span>
<span id="91"> 91</span>
<span id="92"> 92</span>
<span id="93"> 93</span>
<span id="94"> 94</span>
<span id="95"> 95</span>
<span id="96"> 96</span>
<span id="97"> 97</span>
<span id="98"> 98</span>
<span id="99"> 99</span>
<span id="100"> 100</span>
<span id="101"> 101</span>
<span id="102"> 102</span>
<span id="103"> 103</span>
<span id="104"> 104</span>
<span id="105"> 105</span>
<span id="106"> 106</span>
<span id="107"> 107</span>
<span id="108"> 108</span>
<span id="109"> 109</span>
<span id="110"> 110</span>
<span id="111"> 111</span>
<span id="112"> 112</span>
<span id="113"> 113</span>
<span id="114"> 114</span>
<span id="115"> 115</span>
<span id="116"> 116</span>
<span id="117"> 117</span>
<span id="118"> 118</span>
<span id="119"> 119</span>
<span id="120"> 120</span>
<span id="121"> 121</span>
<span id="122"> 122</span>
<span id="123"> 123</span>
<span id="124"> 124</span>
<span id="125"> 125</span>
<span id="126"> 126</span>
<span id="127"> 127</span>
<span id="128"> 128</span>
<span id="129"> 129</span>
<span id="130"> 130</span>
<span id="131"> 131</span>
<span id="132"> 132</span>
<span id="133"> 133</span>
<span id="134"> 134</span>
<span id="135"> 135</span>
<span id="136"> 136</span>
<span id="137"> 137</span>
<span id="138"> 138</span>
<span id="139"> 139</span>
<span id="140"> 140</span>
<span id="141"> 141</span>
<span id="142"> 142</span>
<span id="143"> 143</span>
<span id="144"> 144</span>
<span id="145"> 145</span>
<span id="146"> 146</span>
<span id="147"> 147</span>
<span id="148"> 148</span>
<span id="149"> 149</span>
<span id="150"> 150</span>
<span id="151"> 151</span>
<span id="152"> 152</span>
<span id="153"> 153</span>
<span id="154"> 154</span>
<span id="155"> 155</span>
<span id="156"> 156</span>
<span id="157"> 157</span>
<span id="158"> 158</span>
<span id="159"> 159</span>
<span id="160"> 160</span>
<span id="161"> 161</span>
<span id="162"> 162</span>
<span id="163"> 163</span>
<span id="164"> 164</span>
<span id="165"> 165</span>
<span id="166"> 166</span>
<span id="167"> 167</span>
<span id="168"> 168</span>
<span id="169"> 169</span>
<span id="170"> 170</span>
<span id="171"> 171</span>
<span id="172"> 172</span>
<span id="173"> 173</span>
<span id="174"> 174</span>
<span id="175"> 175</span>
<span id="176"> 176</span>
<span id="177"> 177</span>
<span id="178"> 178</span>
<span id="179"> 179</span>
<span id="180"> 180</span>
<span id="181"> 181</span>
<span id="182"> 182</span>
<span id="183"> 183</span>
<span id="184"> 184</span>
<span id="185"> 185</span>
<span id="186"> 186</span>
<span id="187"> 187</span>
<span id="188"> 188</span>
<span id="189"> 189</span>
<span id="190"> 190</span>
<span id="191"> 191</span>
<span id="192"> 192</span>
<span id="193"> 193</span>
<span id="194"> 194</span>
<span id="195"> 195</span>
<span id="196"> 196</span>
<span id="197"> 197</span>
<span id="198"> 198</span>
<span id="199"> 199</span>
<span id="200"> 200</span>
<span id="201"> 201</span>
<span id="202"> 202</span>
<span id="203"> 203</span>
<span id="204"> 204</span>
<span id="205"> 205</span>
<span id="206"> 206</span>
<span id="207"> 207</span>
<span id="208"> 208</span>
<span id="209"> 209</span>
<span id="210"> 210</span>
<span id="211"> 211</span>
<span id="212"> 212</span>
<span id="213"> 213</span>
<span id="214"> 214</span>
<span id="215"> 215</span>
<span id="216"> 216</span>
<span id="217"> 217</span>
<span id="218"> 218</span>
<span id="219"> 219</span>
<span id="220"> 220</span>
<span id="221"> 221</span>
<span id="222"> 222</span>
<span id="223"> 223</span>
<span id="224"> 224</span>
<span id="225"> 225</span>
<span id="226"> 226</span>
<span id="227"> 227</span>
<span id="228"> 228</span>
<span id="229"> 229</span>
<span id="230"> 230</span>
<span id="231"> 231</span>
<span id="232"> 232</span>
<span id="233"> 233</span>
<span id="234"> 234</span>
<span id="235"> 235</span>
<span id="236"> 236</span>
<span id="237"> 237</span>
<span id="238"> 238</span>
<span id="239"> 239</span>
<span id="240"> 240</span>
<span id="241"> 241</span>
<span id="242"> 242</span>
<span id="243"> 243</span>
<span id="244"> 244</span>
<span id="245"> 245</span>
<span id="246"> 246</span>
<span id="247"> 247</span>
<span id="248"> 248</span>
<span id="249"> 249</span>
<span id="250"> 250</span>
<span id="251"> 251</span>
<span id="252"> 252</span>
<span id="253"> 253</span>
<span id="254"> 254</span>
<span id="255"> 255</span>
<span id="256"> 256</span>
<span id="257"> 257</span>
<span id="258"> 258</span>
<span id="259"> 259</span>
<span id="260"> 260</span>
<span id="261"> 261</span>
<span id="262"> 262</span>
<span id="263"> 263</span>
<span id="264"> 264</span>
<span id="265"> 265</span>
<span id="266"> 266</span>
<span id="267"> 267</span>
<span id="268"> 268</span>
<span id="269"> 269</span>
<span id="270"> 270</span>
<span id="271"> 271</span>
<span id="272"> 272</span>
<span id="273"> 273</span>
<span id="274"> 274</span>
<span id="275"> 275</span>
<span id="276"> 276</span>
<span id="277"> 277</span>
<span id="278"> 278</span>
<span id="279"> 279</span>
<span id="280"> 280</span>
<span id="281"> 281</span>
<span id="282"> 282</span>
<span id="283"> 283</span>
<span id="284"> 284</span>
<span id="285"> 285</span>
<span id="286"> 286</span>
<span id="287"> 287</span>
<span id="288"> 288</span>
<span id="289"> 289</span>
<span id="290"> 290</span>
<span id="291"> 291</span>
<span id="292"> 292</span>
<span id="293"> 293</span>
<span id="294"> 294</span>
<span id="295"> 295</span>
<span id="296"> 296</span>
<span id="297"> 297</span>
<span id="298"> 298</span>
<span id="299"> 299</span>
<span id="300"> 300</span>
<span id="301"> 301</span>
<span id="302"> 302</span>
<span id="303"> 303</span>
<span id="304"> 304</span>
<span id="305"> 305</span>
<span id="306"> 306</span>
<span id="307"> 307</span>
<span id="308"> 308</span>
<span id="309"> 309</span>
<span id="310"> 310</span>
<span id="311"> 311</span>
<span id="312"> 312</span>
<span id="313"> 313</span>
<span id="314"> 314</span>
<span id="315"> 315</span>
<span id="316"> 316</span>
<span id="317"> 317</span>
<span id="318"> 318</span>
<span id="319"> 319</span>
<span id="320"> 320</span>
<span id="321"> 321</span>
<span id="322"> 322</span>
<span id="323"> 323</span>
<span id="324"> 324</span>
<span id="325"> 325</span>
<span id="326"> 326</span>
<span id="327"> 327</span>
<span id="328"> 328</span>
<span id="329"> 329</span>
<span id="330"> 330</span>
<span id="331"> 331</span>
<span id="332"> 332</span>
<span id="333"> 333</span>
<span id="334"> 334</span>
<span id="335"> 335</span>
<span id="336"> 336</span>
<span id="337"> 337</span>
<span id="338"> 338</span>
<span id="339"> 339</span>
<span id="340"> 340</span>
<span id="341"> 341</span>
<span id="342"> 342</span>
<span id="343"> 343</span>
<span id="344"> 344</span>
<span id="345"> 345</span>
<span id="346"> 346</span>
<span id="347"> 347</span>
<span id="348"> 348</span>
<span id="349"> 349</span>
<span id="350"> 350</span>
<span id="351"> 351</span>
<span id="352"> 352</span>
<span id="353"> 353</span>
<span id="354"> 354</span>
<span id="355"> 355</span>
<span id="356"> 356</span>
<span id="357"> 357</span>
<span id="358"> 358</span>
<span id="359"> 359</span>
<span id="360"> 360</span>
<span id="361"> 361</span>
<span id="362"> 362</span>
<span id="363"> 363</span>
<span id="364"> 364</span>
<span id="365"> 365</span>
<span id="366"> 366</span>
<span id="367"> 367</span>
<span id="368"> 368</span>
<span id="369"> 369</span>
<span id="370"> 370</span>
<span id="371"> 371</span>
<span id="372"> 372</span>
<span id="373"> 373</span>
<span id="374"> 374</span>
<span id="375"> 375</span>
<span id="376"> 376</span>
<span id="377"> 377</span>
<span id="378"> 378</span>
<span id="379"> 379</span>
<span id="380"> 380</span>
<span id="381"> 381</span>
<span id="382"> 382</span>
<span id="383"> 383</span>
<span id="384"> 384</span>
<span id="385"> 385</span>
<span id="386"> 386</span>
<span id="387"> 387</span>
<span id="388"> 388</span>
<span id="389"> 389</span>
<span id="390"> 390</span>
<span id="391"> 391</span>
<span id="392"> 392</span>
<span id="393"> 393</span>
<span id="394"> 394</span>
<span id="395"> 395</span>
<span id="396"> 396</span>
<span id="397"> 397</span>
<span id="398"> 398</span>
<span id="399"> 399</span>
<span id="400"> 400</span>
<span id="401"> 401</span>
<span id="402"> 402</span>
<span id="403"> 403</span>
<span id="404"> 404</span>
<span id="405"> 405</span>
<span id="406"> 406</span>
<span id="407"> 407</span>
<span id="408"> 408</span>
<span id="409"> 409</span>
<span id="410"> 410</span>
<span id="411"> 411</span>
<span id="412"> 412</span>
<span id="413"> 413</span>
<span id="414"> 414</span>
<span id="415"> 415</span>
<span id="416"> 416</span>
<span id="417"> 417</span>
<span id="418"> 418</span>
<span id="419"> 419</span>
<span id="420"> 420</span>
<span id="421"> 421</span>
<span id="422"> 422</span>
<span id="423"> 423</span>
<span id="424"> 424</span>
<span id="425"> 425</span>
<span id="426"> 426</span>
<span id="427"> 427</span>
<span id="428"> 428</span>
<span id="429"> 429</span>
<span id="430"> 430</span>
<span id="431"> 431</span>
<span id="432"> 432</span>
<span id="433"> 433</span>
<span id="434"> 434</span>
<span id="435"> 435</span>
<span id="436"> 436</span>
<span id="437"> 437</span>
<span id="438"> 438</span>
<span id="439"> 439</span>
<span id="440"> 440</span>
<span id="441"> 441</span>
<span id="442"> 442</span>
<span id="443"> 443</span>
<span id="444"> 444</span>
<span id="445"> 445</span>
<span id="446"> 446</span>
<span id="447"> 447</span>
<span id="448"> 448</span>
<span id="449"> 449</span>
<span id="450"> 450</span>
<span id="451"> 451</span>
<span id="452"> 452</span>
<span id="453"> 453</span>
<span id="454"> 454</span>
<span id="455"> 455</span>
<span id="456"> 456</span>
<span id="457"> 457</span>
<span id="458"> 458</span>
<span id="459"> 459</span>
<span id="460"> 460</span>
<span id="461"> 461</span>
<span id="462"> 462</span>
<span id="463"> 463</span>
<span id="464"> 464</span>
<span id="465"> 465</span>
<span id="466"> 466</span>
<span id="467"> 467</span>
<span id="468"> 468</span>
<span id="469"> 469</span>
<span id="470"> 470</span>
<span id="471"> 471</span>
<span id="472"> 472</span>
<span id="473"> 473</span>
<span id="474"> 474</span>
<span id="475"> 475</span>
<span id="476"> 476</span>
<span id="477"> 477</span>
<span id="478"> 478</span>
<span id="479"> 479</span>
<span id="480"> 480</span>
<span id="481"> 481</span>
<span id="482"> 482</span>
<span id="483"> 483</span>
<span id="484"> 484</span>
<span id="485"> 485</span>
<span id="486"> 486</span>
<span id="487"> 487</span>
<span id="488"> 488</span>
<span id="489"> 489</span>
<span id="490"> 490</span>
<span id="491"> 491</span>
<span id="492"> 492</span>
<span id="493"> 493</span>
<span id="494"> 494</span>
<span id="495"> 495</span>
<span id="496"> 496</span>
<span id="497"> 497</span>
<span id="498"> 498</span>
<span id="499"> 499</span>
<span id="500"> 500</span>
<span id="501"> 501</span>
<span id="502"> 502</span>
<span id="503"> 503</span>
<span id="504"> 504</span>
<span id="505"> 505</span>
<span id="506"> 506</span>
<span id="507"> 507</span>
<span id="508"> 508</span>
<span id="509"> 509</span>
<span id="510"> 510</span>
<span id="511"> 511</span>
<span id="512"> 512</span>
<span id="513"> 513</span>
<span id="514"> 514</span>
<span id="515"> 515</span>
<span id="516"> 516</span>
<span id="517"> 517</span>
<span id="518"> 518</span>
<span id="519"> 519</span>
<span id="520"> 520</span>
<span id="521"> 521</span>
<span id="522"> 522</span>
<span id="523"> 523</span>
<span id="524"> 524</span>
<span id="525"> 525</span>
<span id="526"> 526</span>
<span id="527"> 527</span>
<span id="528"> 528</span>
<span id="529"> 529</span>
<span id="530"> 530</span>
<span id="531"> 531</span>
<span id="532"> 532</span>
<span id="533"> 533</span>
<span id="534"> 534</span>
<span id="535"> 535</span>
<span id="536"> 536</span>
<span id="537"> 537</span>
<span id="538"> 538</span>
<span id="539"> 539</span>
<span id="540"> 540</span>
<span id="541"> 541</span>
<span id="542"> 542</span>
<span id="543"> 543</span>
<span id="544"> 544</span>
<span id="545"> 545</span>
<span id="546"> 546</span>
<span id="547"> 547</span>
<span id="548"> 548</span>
<span id="549"> 549</span>
<span id="550"> 550</span>
<span id="551"> 551</span>
<span id="552"> 552</span>
<span id="553"> 553</span>
<span id="554"> 554</span>
<span id="555"> 555</span>
<span id="556"> 556</span>
<span id="557"> 557</span>
<span id="558"> 558</span>
<span id="559"> 559</span>
<span id="560"> 560</span>
<span id="561"> 561</span>
<span id="562"> 562</span>
<span id="563"> 563</span>
<span id="564"> 564</span>
<span id="565"> 565</span>
<span id="566"> 566</span>
<span id="567"> 567</span>
<span id="568"> 568</span>
<span id="569"> 569</span>
<span id="570"> 570</span>
<span id="571"> 571</span>
<span id="572"> 572</span>
<span id="573"> 573</span>
<span id="574"> 574</span>
<span id="575"> 575</span>
<span id="576"> 576</span>
<span id="577"> 577</span>
<span id="578"> 578</span>
<span id="579"> 579</span>
<span id="580"> 580</span>
<span id="581"> 581</span>
<span id="582"> 582</span>
<span id="583"> 583</span>
<span id="584"> 584</span>
<span id="585"> 585</span>
<span id="586"> 586</span>
<span id="587"> 587</span>
<span id="588"> 588</span>
<span id="589"> 589</span>
<span id="590"> 590</span>
<span id="591"> 591</span>
<span id="592"> 592</span>
<span id="593"> 593</span>
<span id="594"> 594</span>
<span id="595"> 595</span>
<span id="596"> 596</span>
<span id="597"> 597</span>
<span id="598"> 598</span>
<span id="599"> 599</span>
<span id="600"> 600</span>
<span id="601"> 601</span>
<span id="602"> 602</span>
<span id="603"> 603</span>
<span id="604"> 604</span>
<span id="605"> 605</span>
<span id="606"> 606</span>
<span id="607"> 607</span>
<span id="608"> 608</span>
<span id="609"> 609</span>
<span id="610"> 610</span>
<span id="611"> 611</span>
<span id="612"> 612</span>
<span id="613"> 613</span>
<span id="614"> 614</span>
<span id="615"> 615</span>
<span id="616"> 616</span>
<span id="617"> 617</span>
<span id="618"> 618</span>
<span id="619"> 619</span>
<span id="620"> 620</span>
<span id="621"> 621</span>
<span id="622"> 622</span>
<span id="623"> 623</span>
<span id="624"> 624</span>
<span id="625"> 625</span>
<span id="626"> 626</span>
<span id="627"> 627</span>
<span id="628"> 628</span>
<span id="629"> 629</span>
<span id="630"> 630</span>
<span id="631"> 631</span>
<span id="632"> 632</span>
<span id="633"> 633</span>
<span id="634"> 634</span>
<span id="635"> 635</span>
<span id="636"> 636</span>
<span id="637"> 637</span>
<span id="638"> 638</span>
<span id="639"> 639</span>
<span id="640"> 640</span>
<span id="641"> 641</span>
<span id="642"> 642</span>
<span id="643"> 643</span>
<span id="644"> 644</span>
<span id="645"> 645</span>
<span id="646"> 646</span>
<span id="647"> 647</span>
<span id="648"> 648</span>
<span id="649"> 649</span>
<span id="650"> 650</span>
<span id="651"> 651</span>
<span id="652"> 652</span>
<span id="653"> 653</span>
<span id="654"> 654</span>
<span id="655"> 655</span>
<span id="656"> 656</span>
<span id="657"> 657</span>
<span id="658"> 658</span>
<span id="659"> 659</span>
<span id="660"> 660</span>
<span id="661"> 661</span>
<span id="662"> 662</span>
<span id="663"> 663</span>
<span id="664"> 664</span>
<span id="665"> 665</span>
<span id="666"> 666</span>
<span id="667"> 667</span>
<span id="668"> 668</span>
<span id="669"> 669</span>
<span id="670"> 670</span>
<span id="671"> 671</span>
<span id="672"> 672</span>
<span id="673"> 673</span>
<span id="674"> 674</span>
<span id="675"> 675</span>
<span id="676"> 676</span>
<span id="677"> 677</span>
<span id="678"> 678</span>
<span id="679"> 679</span>
<span id="680"> 680</span>
<span id="681"> 681</span>
<span id="682"> 682</span>
<span id="683"> 683</span>
<span id="684"> 684</span>
<span id="685"> 685</span>
<span id="686"> 686</span>
<span id="687"> 687</span>
<span id="688"> 688</span>
<span id="689"> 689</span>
<span id="690"> 690</span>
<span id="691"> 691</span>
<span id="692"> 692</span>
<span id="693"> 693</span>
<span id="694"> 694</span>
<span id="695"> 695</span>
<span id="696"> 696</span>
<span id="697"> 697</span>
<span id="698"> 698</span>
<span id="699"> 699</span>
<span id="700"> 700</span>
<span id="701"> 701</span>
<span id="702"> 702</span>
<span id="703"> 703</span>
<span id="704"> 704</span>
<span id="705"> 705</span>
<span id="706"> 706</span>
<span id="707"> 707</span>
<span id="708"> 708</span>
<span id="709"> 709</span>
<span id="710"> 710</span>
<span id="711"> 711</span>
<span id="712"> 712</span>
<span id="713"> 713</span>
<span id="714"> 714</span>
<span id="715"> 715</span>
<span id="716"> 716</span>
<span id="717"> 717</span>
<span id="718"> 718</span>
<span id="719"> 719</span>
<span id="720"> 720</span>
<span id="721"> 721</span>
<span id="722"> 722</span>
<span id="723"> 723</span>
<span id="724"> 724</span>
<span id="725"> 725</span>
<span id="726"> 726</span>
<span id="727"> 727</span>
<span id="728"> 728</span>
<span id="729"> 729</span>
<span id="730"> 730</span>
<span id="731"> 731</span>
<span id="732"> 732</span>
<span id="733"> 733</span>
<span id="734"> 734</span>
<span id="735"> 735</span>
<span id="736"> 736</span>
<span id="737"> 737</span>
<span id="738"> 738</span>
<span id="739"> 739</span>
<span id="740"> 740</span>
<span id="741"> 741</span>
<span id="742"> 742</span>
<span id="743"> 743</span>
<span id="744"> 744</span>
<span id="745"> 745</span>
<span id="746"> 746</span>
<span id="747"> 747</span>
<span id="748"> 748</span>
<span id="749"> 749</span>
<span id="750"> 750</span>
<span id="751"> 751</span>
<span id="752"> 752</span>
<span id="753"> 753</span>
<span id="754"> 754</span>
<span id="755"> 755</span>
<span id="756"> 756</span>
<span id="757"> 757</span>
<span id="758"> 758</span>
<span id="759"> 759</span>
<span id="760"> 760</span>
<span id="761"> 761</span>
<span id="762"> 762</span>
<span id="763"> 763</span>
<span id="764"> 764</span>
<span id="765"> 765</span>
<span id="766"> 766</span>
<span id="767"> 767</span>
<span id="768"> 768</span>
<span id="769"> 769</span>
<span id="770"> 770</span>
<span id="771"> 771</span>
<span id="772"> 772</span>
<span id="773"> 773</span>
<span id="774"> 774</span>
<span id="775"> 775</span>
<span id="776"> 776</span>
<span id="777"> 777</span>
<span id="778"> 778</span>
<span id="779"> 779</span>
<span id="780"> 780</span>
<span id="781"> 781</span>
<span id="782"> 782</span>
<span id="783"> 783</span>
<span id="784"> 784</span>
<span id="785"> 785</span>
<span id="786"> 786</span>
<span id="787"> 787</span>
<span id="788"> 788</span>
<span id="789"> 789</span>
<span id="790"> 790</span>
<span id="791"> 791</span>
<span id="792"> 792</span>
<span id="793"> 793</span>
<span id="794"> 794</span>
<span id="795"> 795</span>
<span id="796"> 796</span>
<span id="797"> 797</span>
<span id="798"> 798</span>
<span id="799"> 799</span>
<span id="800"> 800</span>
<span id="801"> 801</span>
<span id="802"> 802</span>
<span id="803"> 803</span>
<span id="804"> 804</span>
<span id="805"> 805</span>
<span id="806"> 806</span>
<span id="807"> 807</span>
<span id="808"> 808</span>
<span id="809"> 809</span>
<span id="810"> 810</span>
<span id="811"> 811</span>
<span id="812"> 812</span>
<span id="813"> 813</span>
<span id="814"> 814</span>
<span id="815"> 815</span>
<span id="816"> 816</span>
<span id="817"> 817</span>
<span id="818"> 818</span>
<span id="819"> 819</span>
<span id="820"> 820</span>
<span id="821"> 821</span>
<span id="822"> 822</span>
<span id="823"> 823</span>
<span id="824"> 824</span>
<span id="825"> 825</span>
<span id="826"> 826</span>
<span id="827"> 827</span>
<span id="828"> 828</span>
<span id="829"> 829</span>
<span id="830"> 830</span>
<span id="831"> 831</span>
<span id="832"> 832</span>
<span id="833"> 833</span>
<span id="834"> 834</span>
<span id="835"> 835</span>
<span id="836"> 836</span>
<span id="837"> 837</span>
<span id="838"> 838</span>
<span id="839"> 839</span>
<span id="840"> 840</span>
<span id="841"> 841</span>
<span id="842"> 842</span>
<span id="843"> 843</span>
<span id="844"> 844</span>
<span id="845"> 845</span>
<span id="846"> 846</span>
<span id="847"> 847</span>
<span id="848"> 848</span>
<span id="849"> 849</span>
<span id="850"> 850</span>
<span id="851"> 851</span>
<span id="852"> 852</span>
<span id="853"> 853</span>
<span id="854"> 854</span>
<span id="855"> 855</span>
<span id="856"> 856</span>
<span id="857"> 857</span>
<span id="858"> 858</span>
<span id="859"> 859</span>
<span id="860"> 860</span>
<span id="861"> 861</span>
<span id="862"> 862</span>
<span id="863"> 863</span>
<span id="864"> 864</span>
<span id="865"> 865</span>
<span id="866"> 866</span>
<span id="867"> 867</span>
<span id="868"> 868</span>
<span id="869"> 869</span>
<span id="870"> 870</span>
<span id="871"> 871</span>
<span id="872"> 872</span>
<span id="873"> 873</span>
<span id="874"> 874</span>
<span id="875"> 875</span>
<span id="876"> 876</span>
<span id="877"> 877</span>
<span id="878"> 878</span>
<span id="879"> 879</span>
<span id="880"> 880</span>
<span id="881"> 881</span>
<span id="882"> 882</span>
<span id="883"> 883</span>
<span id="884"> 884</span>
<span id="885"> 885</span>
<span id="886"> 886</span>
<span id="887"> 887</span>
<span id="888"> 888</span>
<span id="889"> 889</span>
<span id="890"> 890</span>
<span id="891"> 891</span>
<span id="892"> 892</span>
<span id="893"> 893</span>
<span id="894"> 894</span>
<span id="895"> 895</span>
<span id="896"> 896</span>
<span id="897"> 897</span>
<span id="898"> 898</span>
<span id="899"> 899</span>
<span id="900"> 900</span>
<span id="901"> 901</span>
<span id="902"> 902</span>
<span id="903"> 903</span>
<span id="904"> 904</span>
<span id="905"> 905</span>
<span id="906"> 906</span>
<span id="907"> 907</span>
<span id="908"> 908</span>
<span id="909"> 909</span>
<span id="910"> 910</span>
<span id="911"> 911</span>
<span id="912"> 912</span>
<span id="913"> 913</span>
<span id="914"> 914</span>
<span id="915"> 915</span>
<span id="916"> 916</span>
<span id="917"> 917</span>
<span id="918"> 918</span>
<span id="919"> 919</span>
<span id="920"> 920</span>
<span id="921"> 921</span>
<span id="922"> 922</span>
<span id="923"> 923</span>
<span id="924"> 924</span>
<span id="925"> 925</span>
<span id="926"> 926</span>
<span id="927"> 927</span>
<span id="928"> 928</span>
<span id="929"> 929</span>
<span id="930"> 930</span>
<span id="931"> 931</span>
<span id="932"> 932</span>
<span id="933"> 933</span>
<span id="934"> 934</span>
<span id="935"> 935</span>
<span id="936"> 936</span>
<span id="937"> 937</span>
<span id="938"> 938</span>
<span id="939"> 939</span>
<span id="940"> 940</span>
<span id="941"> 941</span>
<span id="942"> 942</span>
<span id="943"> 943</span>
<span id="944"> 944</span>
<span id="945"> 945</span>
<span id="946"> 946</span>
<span id="947"> 947</span>
<span id="948"> 948</span>
<span id="949"> 949</span>
<span id="950"> 950</span>
<span id="951"> 951</span>
<span id="952"> 952</span>
<span id="953"> 953</span>
<span id="954"> 954</span>
<span id="955"> 955</span>
<span id="956"> 956</span>
<span id="957"> 957</span>
<span id="958"> 958</span>
<span id="959"> 959</span>
<span id="960"> 960</span>
<span id="961"> 961</span>
<span id="962"> 962</span>
<span id="963"> 963</span>
<span id="964"> 964</span>
<span id="965"> 965</span>
<span id="966"> 966</span>
<span id="967"> 967</span>
<span id="968"> 968</span>
<span id="969"> 969</span>
<span id="970"> 970</span>
<span id="971"> 971</span>
<span id="972"> 972</span>
<span id="973"> 973</span>
<span id="974"> 974</span>
<span id="975"> 975</span>
<span id="976"> 976</span>
<span id="977"> 977</span>
<span id="978"> 978</span>
<span id="979"> 979</span>
<span id="980"> 980</span>
<span id="981"> 981</span>
<span id="982"> 982</span>
<span id="983"> 983</span>
<span id="984"> 984</span>
<span id="985"> 985</span>
<span id="986"> 986</span>
<span id="987"> 987</span>
<span id="988"> 988</span>
<span id="989"> 989</span>
<span id="990"> 990</span>
<span id="991"> 991</span>
<span id="992"> 992</span>
<span id="993"> 993</span>
<span id="994"> 994</span>
<span id="995"> 995</span>
<span id="996"> 996</span>
<span id="997"> 997</span>
<span id="998"> 998</span>
<span id="999"> 999</span>
<span id="1000">1000</span>
<span id="1001">1001</span>
<span id="1002">1002</span>
<span id="1003">1003</span>
<span id="1004">1004</span>
<span id="1005">1005</span>
<span id="1006">1006</span>
<span id="1007">1007</span>
<span id="1008">1008</span>
<span id="1009">1009</span>
<span id="1010">1010</span>
<span id="1011">1011</span>
<span id="1012">1012</span>
<span id="1013">1013</span>
<span id="1014">1014</span>
<span id="1015">1015</span>
<span id="1016">1016</span>
<span id="1017">1017</span>
<span id="1018">1018</span>
<span id="1019">1019</span>
<span id="1020">1020</span>
<span id="1021">1021</span>
<span id="1022">1022</span>
<span id="1023">1023</span>
<span id="1024">1024</span>
<span id="1025">1025</span>
<span id="1026">1026</span>
<span id="1027">1027</span>
<span id="1028">1028</span>
<span id="1029">1029</span>
<span id="1030">1030</span>
<span id="1031">1031</span>
<span id="1032">1032</span>
<span id="1033">1033</span>
<span id="1034">1034</span>
<span id="1035">1035</span>
<span id="1036">1036</span>
<span id="1037">1037</span>
<span id="1038">1038</span>
<span id="1039">1039</span>
<span id="1040">1040</span>
<span id="1041">1041</span>
<span id="1042">1042</span>
<span id="1043">1043</span>
<span id="1044">1044</span>
<span id="1045">1045</span>
<span id="1046">1046</span>
<span id="1047">1047</span>
<span id="1048">1048</span>
<span id="1049">1049</span>
<span id="1050">1050</span>
<span id="1051">1051</span>
<span id="1052">1052</span>
<span id="1053">1053</span>
<span id="1054">1054</span>
<span id="1055">1055</span>
<span id="1056">1056</span>
<span id="1057">1057</span>
<span id="1058">1058</span>
<span id="1059">1059</span>
<span id="1060">1060</span>
<span id="1061">1061</span>
<span id="1062">1062</span>
<span id="1063">1063</span>
<span id="1064">1064</span>
<span id="1065">1065</span>
<span id="1066">1066</span>
<span id="1067">1067</span>
<span id="1068">1068</span>
<span id="1069">1069</span>
<span id="1070">1070</span>
<span id="1071">1071</span>
<span id="1072">1072</span>
<span id="1073">1073</span>
<span id="1074">1074</span>
<span id="1075">1075</span>
<span id="1076">1076</span>
<span id="1077">1077</span>
<span id="1078">1078</span>
<span id="1079">1079</span>
<span id="1080">1080</span>
<span id="1081">1081</span>
<span id="1082">1082</span>
<span id="1083">1083</span>
<span id="1084">1084</span>
<span id="1085">1085</span>
<span id="1086">1086</span>
<span id="1087">1087</span>
<span id="1088">1088</span>
<span id="1089">1089</span>
<span id="1090">1090</span>
<span id="1091">1091</span>
<span id="1092">1092</span>
<span id="1093">1093</span>
<span id="1094">1094</span>
<span id="1095">1095</span>
<span id="1096">1096</span>
<span id="1097">1097</span>
<span id="1098">1098</span>
<span id="1099">1099</span>
<span id="1100">1100</span>
<span id="1101">1101</span>
<span id="1102">1102</span>
<span id="1103">1103</span>
<span id="1104">1104</span>
<span id="1105">1105</span>
<span id="1106">1106</span>
<span id="1107">1107</span>
<span id="1108">1108</span>
<span id="1109">1109</span>
<span id="1110">1110</span>
<span id="1111">1111</span>
<span id="1112">1112</span>
<span id="1113">1113</span>
<span id="1114">1114</span>
<span id="1115">1115</span>
<span id="1116">1116</span>
<span id="1117">1117</span>
<span id="1118">1118</span>
<span id="1119">1119</span>
<span id="1120">1120</span>
<span id="1121">1121</span>
<span id="1122">1122</span>
<span id="1123">1123</span>
<span id="1124">1124</span>
<span id="1125">1125</span>
<span id="1126">1126</span>
<span id="1127">1127</span>
<span id="1128">1128</span>
<span id="1129">1129</span>
<span id="1130">1130</span>
<span id="1131">1131</span>
<span id="1132">1132</span>
<span id="1133">1133</span>
<span id="1134">1134</span>
<span id="1135">1135</span>
<span id="1136">1136</span>
<span id="1137">1137</span>
<span id="1138">1138</span>
<span id="1139">1139</span>
<span id="1140">1140</span>
<span id="1141">1141</span>
<span id="1142">1142</span>
<span id="1143">1143</span>
<span id="1144">1144</span>
<span id="1145">1145</span>
<span id="1146">1146</span>
<span id="1147">1147</span>
<span id="1148">1148</span>
<span id="1149">1149</span>
<span id="1150">1150</span>
<span id="1151">1151</span>
<span id="1152">1152</span>
<span id="1153">1153</span>
<span id="1154">1154</span>
<span id="1155">1155</span>
<span id="1156">1156</span>
<span id="1157">1157</span>
<span id="1158">1158</span>
<span id="1159">1159</span>
<span id="1160">1160</span>
<span id="1161">1161</span>
<span id="1162">1162</span>
<span id="1163">1163</span>
<span id="1164">1164</span>
<span id="1165">1165</span>
<span id="1166">1166</span>
<span id="1167">1167</span>
<span id="1168">1168</span>
<span id="1169">1169</span>
<span id="1170">1170</span>
<span id="1171">1171</span>
<span id="1172">1172</span>
<span id="1173">1173</span>
<span id="1174">1174</span>
<span id="1175">1175</span>
<span id="1176">1176</span>
<span id="1177">1177</span>
<span id="1178">1178</span>
<span id="1179">1179</span>
<span id="1180">1180</span>
<span id="1181">1181</span>
<span id="1182">1182</span>
<span id="1183">1183</span>
<span id="1184">1184</span>
<span id="1185">1185</span>
<span id="1186">1186</span>
<span id="1187">1187</span>
<span id="1188">1188</span>
<span id="1189">1189</span>
<span id="1190">1190</span>
<span id="1191">1191</span>
<span id="1192">1192</span>
<span id="1193">1193</span>
<span id="1194">1194</span>
<span id="1195">1195</span>
<span id="1196">1196</span>
<span id="1197">1197</span>
<span id="1198">1198</span>
<span id="1199">1199</span>
<span id="1200">1200</span>
<span id="1201">1201</span>
<span id="1202">1202</span>
<span id="1203">1203</span>
<span id="1204">1204</span>
<span id="1205">1205</span>
<span id="1206">1206</span>
<span id="1207">1207</span>
<span id="1208">1208</span>
<span id="1209">1209</span>
<span id="1210">1210</span>
<span id="1211">1211</span>
<span id="1212">1212</span>
<span id="1213">1213</span>
<span id="1214">1214</span>
<span id="1215">1215</span>
<span id="1216">1216</span>
<span id="1217">1217</span>
<span id="1218">1218</span>
<span id="1219">1219</span>
<span id="1220">1220</span>
<span id="1221">1221</span>
<span id="1222">1222</span>
<span id="1223">1223</span>
<span id="1224">1224</span>
<span id="1225">1225</span>
<span id="1226">1226</span>
<span id="1227">1227</span>
<span id="1228">1228</span>
<span id="1229">1229</span>
<span id="1230">1230</span>
<span id="1231">1231</span>
<span id="1232">1232</span>
<span id="1233">1233</span>
<span id="1234">1234</span>
</pre><div class="example-wrap"><pre class="rust ">
<span class="doccomment">//! A wrapper around the procedural macro API of the compiler&#39;s [`proc_macro`]</span>
<span class="doccomment">//! crate. This library serves two purposes:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! - **Bring proc-macro-like functionality to other contexts like build.rs and</span>
<span class="doccomment">//! main.rs.** Types from `proc_macro` are entirely specific to procedural</span>
<span class="doccomment">//! macros and cannot ever exist in code outside of a procedural macro.</span>
<span class="doccomment">//! Meanwhile `proc_macro2` types may exist anywhere including non-macro code.</span>
<span class="doccomment">//! By developing foundational libraries like [syn] and [quote] against</span>
<span class="doccomment">//! `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem</span>
<span class="doccomment">//! becomes easily applicable to many other use cases and we avoid</span>
<span class="doccomment">//! reimplementing non-macro equivalents of those libraries.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! - **Make procedural macros unit testable.** As a consequence of being</span>
<span class="doccomment">//! specific to procedural macros, nothing that uses `proc_macro` can be</span>
<span class="doccomment">//! executed from a unit test. In order for helper libraries or components of</span>
<span class="doccomment">//! a macro to be testable in isolation, they must be implemented using</span>
<span class="doccomment">//! `proc_macro2`.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! [syn]: https://github.com/dtolnay/syn</span>
<span class="doccomment">//! [quote]: https://github.com/dtolnay/quote</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! # Usage</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The skeleton of a typical procedural macro typically looks like this:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ```</span>
<span class="doccomment">//! extern crate proc_macro;</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! # const IGNORE: &amp;str = stringify! {</span>
<span class="doccomment">//! #[proc_macro_derive(MyDerive)]</span>
<span class="doccomment">//! # };</span>
<span class="doccomment">//! # #[cfg(wrap_proc_macro)]</span>
<span class="doccomment">//! pub fn my_derive(input: proc_macro::TokenStream) -&gt; proc_macro::TokenStream {</span>
<span class="doccomment">//! let input = proc_macro2::TokenStream::from(input);</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! let output: proc_macro2::TokenStream = {</span>
<span class="doccomment">//! /* transform input */</span>
<span class="doccomment">//! # input</span>
<span class="doccomment">//! };</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! proc_macro::TokenStream::from(output)</span>
<span class="doccomment">//! }</span>
<span class="doccomment">//! ```</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! If parsing with [Syn], you&#39;ll use [`parse_macro_input!`] instead to</span>
<span class="doccomment">//! propagate parse errors correctly back to the compiler when parsing fails.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! [`parse_macro_input!`]: https://docs.rs/syn/1.0/syn/macro.parse_macro_input.html</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! # Unstable features</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The default feature set of proc-macro2 tracks the most recent stable</span>
<span class="doccomment">//! compiler API. Functionality in `proc_macro` that is not yet stable is not</span>
<span class="doccomment">//! exposed by proc-macro2 by default.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! To opt into the additional APIs available in the most recent nightly</span>
<span class="doccomment">//! compiler, the `procmacro2_semver_exempt` config flag must be passed to</span>
<span class="doccomment">//! rustc. We will polyfill those nightly-only APIs back to Rust 1.31.0. As</span>
<span class="doccomment">//! these are unstable APIs that track the nightly compiler, minor versions of</span>
<span class="doccomment">//! proc-macro2 may make breaking changes to them at any time.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ```sh</span>
<span class="doccomment">//! RUSTFLAGS=&#39;--cfg procmacro2_semver_exempt&#39; cargo build</span>
<span class="doccomment">//! ```</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Note that this must not only be done for your crate, but for any crate that</span>
<span class="doccomment">//! depends on your crate. This infectious nature is intentional, as it serves</span>
<span class="doccomment">//! as a reminder that you are outside of the normal semver guarantees.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Semver exempt methods are marked as such in the proc-macro2 documentation.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! # Thread-Safety</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Most types in this crate are `!Sync` because the underlying compiler</span>
<span class="doccomment">//! types make use of thread-local memory, meaning they cannot be accessed from</span>
<span class="doccomment">//! a different thread.</span>
<span class="comment">// Proc-macro2 types in rustdoc of other crates get linked to here.</span>
<span class="attribute">#![<span class="ident">doc</span>(<span class="ident">html_root_url</span> <span class="op">=</span> <span class="string">&quot;https://docs.rs/proc-macro2/1.0.24&quot;</span>)]</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">any</span>(<span class="ident">proc_macro_span</span>, <span class="ident">super_unstable</span>), <span class="ident">feature</span>(<span class="ident">proc_macro_span</span>))]</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">super_unstable</span>, <span class="ident">feature</span>(<span class="ident">proc_macro_raw_ident</span>, <span class="ident">proc_macro_def_site</span>))]</span>
<span class="attribute">#![<span class="ident">allow</span>(<span class="ident">clippy</span>::<span class="ident">needless_doctest_main</span>)]</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">use_proc_macro</span>)]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">proc_macro</span>;
<span class="kw">mod</span> <span class="ident">marker</span>;
<span class="kw">mod</span> <span class="ident">parse</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">wrap_proc_macro</span>)]</span>
<span class="kw">mod</span> <span class="ident">detection</span>;
<span class="comment">// Public for proc_macro2::fallback::force() and unforce(), but those are quite</span>
<span class="comment">// a niche use case so we omit it from rustdoc.</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">fallback</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">wrap_proc_macro</span>))]</span>
<span class="kw">use</span> <span class="kw">crate</span>::<span class="ident">fallback</span> <span class="kw">as</span> <span class="ident">imp</span>;
<span class="attribute">#[<span class="ident">path</span> <span class="op">=</span> <span class="string">&quot;wrapper.rs&quot;</span>]</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">wrap_proc_macro</span>)]</span>
<span class="kw">mod</span> <span class="ident">imp</span>;
<span class="kw">use</span> <span class="kw">crate</span>::<span class="ident">marker</span>::<span class="ident">Marker</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>::<span class="ident">Ordering</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">error</span>::<span class="ident">Error</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>::{<span class="self">self</span>, <span class="ident">Debug</span>, <span class="ident">Display</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">hash</span>::{<span class="ident">Hash</span>, <span class="ident">Hasher</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">iter</span>::<span class="ident">FromIterator</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ops</span>::<span class="ident">RangeBounds</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">path</span>::<span class="ident">PathBuf</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">str</span>::<span class="ident">FromStr</span>;
<span class="doccomment">/// An abstract stream of tokens, or more concretely a sequence of token trees.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This type provides interfaces for iterating over token trees and for</span>
<span class="doccomment">/// collecting token trees into one stream.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Token stream is both the input and output of `#[proc_macro]`,</span>
<span class="doccomment">/// `#[proc_macro_attribute]` and `#[proc_macro_derive]` definitions.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TokenStream</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">TokenStream</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="doccomment">/// Error returned from `TokenStream::from_str`.</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">LexError</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">LexError</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="kw">impl</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">TokenStream</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenStream</span> {
<span class="ident">TokenStream</span> {
<span class="ident">inner</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="kw">fn</span> <span class="ident">_new_stable</span>(<span class="ident">inner</span>: <span class="ident">fallback</span>::<span class="ident">TokenStream</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenStream</span> {
<span class="ident">TokenStream</span> {
<span class="ident">inner</span>: <span class="ident">inner</span>.<span class="ident">into</span>(),
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="doccomment">/// Returns an empty `TokenStream` containing no token trees.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenStream</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">TokenStream</span>::<span class="ident">new</span>())
}
<span class="doccomment">/// Checks if this `TokenStream` is empty.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">is_empty</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">is_empty</span>()
}
}
<span class="doccomment">/// `TokenStream::default()` returns an empty stream,</span>
<span class="doccomment">/// i.e. this is equivalent with `TokenStream::new()`.</span>
<span class="kw">impl</span> <span class="ident">Default</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">default</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">TokenStream</span>::<span class="ident">new</span>()
}
}
<span class="doccomment">/// Attempts to break the string into tokens and parse those tokens into a token</span>
<span class="doccomment">/// stream.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// May fail for a number of reasons, for example, if the string contains</span>
<span class="doccomment">/// unbalanced delimiters or characters not existing in the language.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// NOTE: Some errors may cause panics instead of returning `LexError`. We</span>
<span class="doccomment">/// reserve the right to change these errors into `LexError`s later.</span>
<span class="kw">impl</span> <span class="ident">FromStr</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">type</span> <span class="prelude-val">Err</span> <span class="op">=</span> <span class="ident">LexError</span>;
<span class="kw">fn</span> <span class="ident">from_str</span>(<span class="ident">src</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">TokenStream</span>, <span class="ident">LexError</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="ident">e</span> <span class="op">=</span> <span class="ident">src</span>.<span class="ident">parse</span>().<span class="ident">map_err</span>(<span class="op">|</span><span class="ident">e</span><span class="op">|</span> <span class="ident">LexError</span> {
<span class="ident">inner</span>: <span class="ident">e</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
})<span class="question-mark">?</span>;
<span class="prelude-val">Ok</span>(<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">e</span>))
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">use_proc_macro</span>)]</span>
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">proc_macro</span>::<span class="ident">TokenStream</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">inner</span>: <span class="ident">proc_macro</span>::<span class="ident">TokenStream</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenStream</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">inner</span>.<span class="ident">into</span>())
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">use_proc_macro</span>)]</span>
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">TokenStream</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">proc_macro</span>::<span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">inner</span>: <span class="ident">TokenStream</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">proc_macro</span>::<span class="ident">TokenStream</span> {
<span class="ident">inner</span>.<span class="ident">inner</span>.<span class="ident">into</span>()
}
}
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">TokenTree</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">token</span>: <span class="ident">TokenTree</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">TokenStream</span>::<span class="ident">from</span>(<span class="ident">token</span>))
}
}
<span class="kw">impl</span> <span class="ident">Extend</span><span class="op">&lt;</span><span class="ident">TokenTree</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">extend</span><span class="op">&lt;</span><span class="ident">I</span>: <span class="ident">IntoIterator</span><span class="op">&lt;</span><span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenTree</span><span class="op">&gt;</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">streams</span>: <span class="ident">I</span>) {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">extend</span>(<span class="ident">streams</span>)
}
}
<span class="kw">impl</span> <span class="ident">Extend</span><span class="op">&lt;</span><span class="ident">TokenStream</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">extend</span><span class="op">&lt;</span><span class="ident">I</span>: <span class="ident">IntoIterator</span><span class="op">&lt;</span><span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenStream</span><span class="op">&gt;</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">streams</span>: <span class="ident">I</span>) {
<span class="self">self</span>.<span class="ident">inner</span>
.<span class="ident">extend</span>(<span class="ident">streams</span>.<span class="ident">into_iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">stream</span><span class="op">|</span> <span class="ident">stream</span>.<span class="ident">inner</span>))
}
}
<span class="doccomment">/// Collects a number of token trees into a single stream.</span>
<span class="kw">impl</span> <span class="ident">FromIterator</span><span class="op">&lt;</span><span class="ident">TokenTree</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">from_iter</span><span class="op">&lt;</span><span class="ident">I</span>: <span class="ident">IntoIterator</span><span class="op">&lt;</span><span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenTree</span><span class="op">&gt;</span><span class="op">&gt;</span>(<span class="ident">streams</span>: <span class="ident">I</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">streams</span>.<span class="ident">into_iter</span>().<span class="ident">collect</span>())
}
}
<span class="kw">impl</span> <span class="ident">FromIterator</span><span class="op">&lt;</span><span class="ident">TokenStream</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">from_iter</span><span class="op">&lt;</span><span class="ident">I</span>: <span class="ident">IntoIterator</span><span class="op">&lt;</span><span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenStream</span><span class="op">&gt;</span><span class="op">&gt;</span>(<span class="ident">streams</span>: <span class="ident">I</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="ident">streams</span>.<span class="ident">into_iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">i</span><span class="op">|</span> <span class="ident">i</span>.<span class="ident">inner</span>).<span class="ident">collect</span>())
}
}
<span class="doccomment">/// Prints the token stream as a string that is supposed to be losslessly</span>
<span class="doccomment">/// convertible back into the same token stream (modulo spans), except for</span>
<span class="doccomment">/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative</span>
<span class="doccomment">/// numeric literals.</span>
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="doccomment">/// Prints token in a form convenient for debugging.</span>
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">LexError</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">LexError</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Error</span> <span class="kw">for</span> <span class="ident">LexError</span> {}
<span class="doccomment">/// The source file of a given `Span`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This type is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">SourceFile</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">SourceFile</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">impl</span> <span class="ident">SourceFile</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">SourceFile</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">SourceFile</span> {
<span class="ident">inner</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="doccomment">/// Get the path to this source file.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ### Note</span>
<span class="doccomment">///</span>
<span class="doccomment">/// If the code span associated with this `SourceFile` was generated by an</span>
<span class="doccomment">/// external macro, this may not be an actual path on the filesystem. Use</span>
<span class="doccomment">/// [`is_real`] to check.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Also note that even if `is_real` returns `true`, if</span>
<span class="doccomment">/// `--remap-path-prefix` was passed on the command line, the path as given</span>
<span class="doccomment">/// may not actually be valid.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// [`is_real`]: #method.is_real</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">path</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">PathBuf</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">path</span>()
}
<span class="doccomment">/// Returns `true` if this source file is a real source file, and not</span>
<span class="doccomment">/// generated by an external macro&#39;s expansion.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">is_real</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">is_real</span>()
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">SourceFile</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="doccomment">/// A line-column pair representing the start or end of a `Span`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This type is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">span_locations</span>)]</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">LineColumn</span> {
<span class="doccomment">/// The 1-indexed line in the source file on which the span starts or ends</span>
<span class="doccomment">/// (inclusive).</span>
<span class="kw">pub</span> <span class="ident">line</span>: <span class="ident">usize</span>,
<span class="doccomment">/// The 0-indexed column (in UTF-8 characters) in the source file on which</span>
<span class="doccomment">/// the span starts or ends (inclusive).</span>
<span class="kw">pub</span> <span class="ident">column</span>: <span class="ident">usize</span>,
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">span_locations</span>)]</span>
<span class="kw">impl</span> <span class="ident">Ord</span> <span class="kw">for</span> <span class="ident">LineColumn</span> {
<span class="kw">fn</span> <span class="ident">cmp</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="self">Self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ordering</span> {
<span class="self">self</span>.<span class="ident">line</span>
.<span class="ident">cmp</span>(<span class="kw-2">&amp;</span><span class="ident">other</span>.<span class="ident">line</span>)
.<span class="ident">then</span>(<span class="self">self</span>.<span class="ident">column</span>.<span class="ident">cmp</span>(<span class="kw-2">&amp;</span><span class="ident">other</span>.<span class="ident">column</span>))
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">span_locations</span>)]</span>
<span class="kw">impl</span> <span class="ident">PartialOrd</span> <span class="kw">for</span> <span class="ident">LineColumn</span> {
<span class="kw">fn</span> <span class="ident">partial_cmp</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="self">Self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Ordering</span><span class="op">&gt;</span> {
<span class="prelude-val">Some</span>(<span class="self">self</span>.<span class="ident">cmp</span>(<span class="ident">other</span>))
}
}
<span class="doccomment">/// A region of source code, along with macro expansion information.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Span</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Span</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="kw">impl</span> <span class="ident">Span</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span> {
<span class="ident">inner</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="kw">fn</span> <span class="ident">_new_stable</span>(<span class="ident">inner</span>: <span class="ident">fallback</span>::<span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span> {
<span class="ident">inner</span>: <span class="ident">inner</span>.<span class="ident">into</span>(),
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="doccomment">/// The span of the invocation of the current procedural macro.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Identifiers created with this span will be resolved as if they were</span>
<span class="doccomment">/// written directly at the macro call location (call-site hygiene) and</span>
<span class="doccomment">/// other code at the macro call site will be able to refer to them as well.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">call_site</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Span</span>::<span class="ident">call_site</span>())
}
<span class="doccomment">/// The span located at the invocation of the procedural macro, but with</span>
<span class="doccomment">/// local variables, labels, and `$crate` resolved at the definition site</span>
<span class="doccomment">/// of the macro. This is the same hygiene behavior as `macro_rules`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function requires Rust 1.45 or later.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">hygiene</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">mixed_site</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Span</span>::<span class="ident">mixed_site</span>())
}
<span class="doccomment">/// A span that resolves at the macro definition site.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">def_site</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Span</span>::<span class="ident">def_site</span>())
}
<span class="doccomment">/// Creates a new span with the same line/column information as `self` but</span>
<span class="doccomment">/// that resolves symbols as though it were at `other`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">resolved_at</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">resolved_at</span>(<span class="ident">other</span>.<span class="ident">inner</span>))
}
<span class="doccomment">/// Creates a new span with the same name resolution behavior as `self` but</span>
<span class="doccomment">/// with the line/column information of `other`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">located_at</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">located_at</span>(<span class="ident">other</span>.<span class="ident">inner</span>))
}
<span class="doccomment">/// Convert `proc_macro2::Span` to `proc_macro::Span`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method is available when building with a nightly compiler, or when</span>
<span class="doccomment">/// building with rustc 1.29+ *without* semver exempt features.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if called from outside of a procedural macro. Unlike</span>
<span class="doccomment">/// `proc_macro2::Span`, the `proc_macro::Span` type can only exist within</span>
<span class="doccomment">/// the context of a procedural macro invocation.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">wrap_proc_macro</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">unwrap</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">proc_macro</span>::<span class="ident">Span</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">unwrap</span>()
}
<span class="comment">// Soft deprecated. Please use Span::unwrap.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">wrap_proc_macro</span>)]</span>
<span class="attribute">#[<span class="ident">doc</span>(<span class="ident">hidden</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">unstable</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">proc_macro</span>::<span class="ident">Span</span> {
<span class="self">self</span>.<span class="ident">unwrap</span>()
}
<span class="doccomment">/// The original source file into which this span points.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">source_file</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">SourceFile</span> {
<span class="ident">SourceFile</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">source_file</span>())
}
<span class="doccomment">/// Get the starting line/column in the source file for this span.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method requires the `&quot;span-locations&quot;` feature to be enabled.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">span_locations</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">start</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">LineColumn</span> {
<span class="kw">let</span> <span class="ident">imp</span>::<span class="ident">LineColumn</span> { <span class="ident">line</span>, <span class="ident">column</span> } <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">start</span>();
<span class="ident">LineColumn</span> { <span class="ident">line</span>, <span class="ident">column</span> }
}
<span class="doccomment">/// Get the ending line/column in the source file for this span.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method requires the `&quot;span-locations&quot;` feature to be enabled.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">span_locations</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">end</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">LineColumn</span> {
<span class="kw">let</span> <span class="ident">imp</span>::<span class="ident">LineColumn</span> { <span class="ident">line</span>, <span class="ident">column</span> } <span class="op">=</span> <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">end</span>();
<span class="ident">LineColumn</span> { <span class="ident">line</span>, <span class="ident">column</span> }
}
<span class="doccomment">/// Create a new span encompassing `self` and `other`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Returns `None` if `self` and `other` are from different files.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Warning: the underlying [`proc_macro::Span::join`] method is</span>
<span class="doccomment">/// nightly-only. When called from within a procedural macro not using a</span>
<span class="doccomment">/// nightly compiler, this method will always return `None`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// [`proc_macro::Span::join`]: https://doc.rust-lang.org/proc_macro/struct.Span.html#method.join</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">join</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Span</span><span class="op">&gt;</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">join</span>(<span class="ident">other</span>.<span class="ident">inner</span>).<span class="ident">map</span>(<span class="ident">Span</span>::<span class="ident">_new</span>)
}
<span class="doccomment">/// Compares two spans to see if they&#39;re equal.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">eq</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">eq</span>(<span class="kw-2">&amp;</span><span class="ident">other</span>.<span class="ident">inner</span>)
}
}
<span class="doccomment">/// Prints a span in a form convenient for debugging.</span>
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Span</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="doccomment">/// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`).</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">TokenTree</span> {
<span class="doccomment">/// A token stream surrounded by bracket delimiters.</span>
<span class="ident">Group</span>(<span class="ident">Group</span>),
<span class="doccomment">/// An identifier.</span>
<span class="ident">Ident</span>(<span class="ident">Ident</span>),
<span class="doccomment">/// A single punctuation character (`+`, `,`, `$`, etc.).</span>
<span class="ident">Punct</span>(<span class="ident">Punct</span>),
<span class="doccomment">/// A literal character (`&#39;a&#39;`), string (`&quot;hello&quot;`), number (`2.3`), etc.</span>
<span class="ident">Literal</span>(<span class="ident">Literal</span>),
}
<span class="kw">impl</span> <span class="ident">TokenTree</span> {
<span class="doccomment">/// Returns the span of this tree, delegating to the `span` method of</span>
<span class="doccomment">/// the contained token or a delimited stream.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="kw">match</span> <span class="self">self</span> {
<span class="ident">TokenTree</span>::<span class="ident">Group</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">span</span>(),
<span class="ident">TokenTree</span>::<span class="ident">Ident</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">span</span>(),
<span class="ident">TokenTree</span>::<span class="ident">Punct</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">span</span>(),
<span class="ident">TokenTree</span>::<span class="ident">Literal</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">span</span>(),
}
}
<span class="doccomment">/// Configures the span for *only this token*.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Note that if this token is a `Group` then this method will not configure</span>
<span class="doccomment">/// the span of each of the internal tokens, this will simply delegate to</span>
<span class="doccomment">/// the `set_span` method of each variant.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_span</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">span</span>: <span class="ident">Span</span>) {
<span class="kw">match</span> <span class="self">self</span> {
<span class="ident">TokenTree</span>::<span class="ident">Group</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">set_span</span>(<span class="ident">span</span>),
<span class="ident">TokenTree</span>::<span class="ident">Ident</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">set_span</span>(<span class="ident">span</span>),
<span class="ident">TokenTree</span>::<span class="ident">Punct</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">set_span</span>(<span class="ident">span</span>),
<span class="ident">TokenTree</span>::<span class="ident">Literal</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">t</span>.<span class="ident">set_span</span>(<span class="ident">span</span>),
}
}
}
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">Group</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">g</span>: <span class="ident">Group</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenTree</span> {
<span class="ident">TokenTree</span>::<span class="ident">Group</span>(<span class="ident">g</span>)
}
}
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">Ident</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">g</span>: <span class="ident">Ident</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenTree</span> {
<span class="ident">TokenTree</span>::<span class="ident">Ident</span>(<span class="ident">g</span>)
}
}
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">Punct</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">g</span>: <span class="ident">Punct</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenTree</span> {
<span class="ident">TokenTree</span>::<span class="ident">Punct</span>(<span class="ident">g</span>)
}
}
<span class="kw">impl</span> <span class="ident">From</span><span class="op">&lt;</span><span class="ident">Literal</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">from</span>(<span class="ident">g</span>: <span class="ident">Literal</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenTree</span> {
<span class="ident">TokenTree</span>::<span class="ident">Literal</span>(<span class="ident">g</span>)
}
}
<span class="doccomment">/// Prints the token tree as a string that is supposed to be losslessly</span>
<span class="doccomment">/// convertible back into the same token tree (modulo spans), except for</span>
<span class="doccomment">/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative</span>
<span class="doccomment">/// numeric literals.</span>
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="kw">match</span> <span class="self">self</span> {
<span class="ident">TokenTree</span>::<span class="ident">Group</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
<span class="ident">TokenTree</span>::<span class="ident">Ident</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
<span class="ident">TokenTree</span>::<span class="ident">Punct</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
<span class="ident">TokenTree</span>::<span class="ident">Literal</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
}
}
}
<span class="doccomment">/// Prints token tree in a form convenient for debugging.</span>
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">TokenTree</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="comment">// Each of these has the name in the struct type in the derived debug,</span>
<span class="comment">// so don&#39;t bother with an extra layer of indirection</span>
<span class="kw">match</span> <span class="self">self</span> {
<span class="ident">TokenTree</span>::<span class="ident">Group</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
<span class="ident">TokenTree</span>::<span class="ident">Ident</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">debug</span> <span class="op">=</span> <span class="ident">f</span>.<span class="ident">debug_struct</span>(<span class="string">&quot;Ident&quot;</span>);
<span class="ident">debug</span>.<span class="ident">field</span>(<span class="string">&quot;sym&quot;</span>, <span class="kw-2">&amp;</span><span class="macro">format_args</span><span class="macro">!</span>(<span class="string">&quot;{}&quot;</span>, <span class="ident">t</span>));
<span class="ident">imp</span>::<span class="ident">debug_span_field_if_nontrivial</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">debug</span>, <span class="ident">t</span>.<span class="ident">span</span>().<span class="ident">inner</span>);
<span class="ident">debug</span>.<span class="ident">finish</span>()
}
<span class="ident">TokenTree</span>::<span class="ident">Punct</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
<span class="ident">TokenTree</span>::<span class="ident">Literal</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="ident">t</span>, <span class="ident">f</span>),
}
}
}
<span class="doccomment">/// A delimited token stream.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// A `Group` internally contains a `TokenStream` which is surrounded by</span>
<span class="doccomment">/// `Delimiter`s.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Group</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Group</span>,
}
<span class="doccomment">/// Describes how a sequence of token trees is delimited.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">Eq</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">Delimiter</span> {
<span class="doccomment">/// `( ... )`</span>
<span class="ident">Parenthesis</span>,
<span class="doccomment">/// `{ ... }`</span>
<span class="ident">Brace</span>,
<span class="doccomment">/// `[ ... ]`</span>
<span class="ident">Bracket</span>,
<span class="doccomment">/// `Ø ... Ø`</span>
<span class="doccomment">///</span>
<span class="doccomment">/// An implicit delimiter, that may, for example, appear around tokens</span>
<span class="doccomment">/// coming from a &quot;macro variable&quot; `$var`. It is important to preserve</span>
<span class="doccomment">/// operator priorities in cases like `$var * 3` where `$var` is `1 + 2`.</span>
<span class="doccomment">/// Implicit delimiters may not survive roundtrip of a token stream through</span>
<span class="doccomment">/// a string.</span>
<span class="prelude-val">None</span>,
}
<span class="kw">impl</span> <span class="ident">Group</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Group</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">Group</span> { <span class="ident">inner</span> }
}
<span class="kw">fn</span> <span class="ident">_new_stable</span>(<span class="ident">inner</span>: <span class="ident">fallback</span>::<span class="ident">Group</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="self">Self</span> {
<span class="ident">Group</span> {
<span class="ident">inner</span>: <span class="ident">inner</span>.<span class="ident">into</span>(),
}
}
<span class="doccomment">/// Creates a new `Group` with the given delimiter and token stream.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This constructor will set the span for this group to</span>
<span class="doccomment">/// `Span::call_site()`. To change the span you can use the `set_span`</span>
<span class="doccomment">/// method below.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">delimiter</span>: <span class="ident">Delimiter</span>, <span class="ident">stream</span>: <span class="ident">TokenStream</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Group</span> {
<span class="ident">Group</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Group</span>::<span class="ident">new</span>(<span class="ident">delimiter</span>, <span class="ident">stream</span>.<span class="ident">inner</span>),
}
}
<span class="doccomment">/// Returns the delimiter of this `Group`</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">delimiter</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Delimiter</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">delimiter</span>()
}
<span class="doccomment">/// Returns the `TokenStream` of tokens that are delimited in this `Group`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Note that the returned token stream does not include the delimiter</span>
<span class="doccomment">/// returned above.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">stream</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">TokenStream</span> {
<span class="ident">TokenStream</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">stream</span>())
}
<span class="doccomment">/// Returns the span for the delimiters of this token stream, spanning the</span>
<span class="doccomment">/// entire `Group`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```text</span>
<span class="doccomment">/// pub fn span(&amp;self) -&gt; Span {</span>
<span class="doccomment">/// ^^^^^^^</span>
<span class="doccomment">/// ```</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">span</span>())
}
<span class="doccomment">/// Returns the span pointing to the opening delimiter of this group.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```text</span>
<span class="doccomment">/// pub fn span_open(&amp;self) -&gt; Span {</span>
<span class="doccomment">/// ^</span>
<span class="doccomment">/// ```</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span_open</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">span_open</span>())
}
<span class="doccomment">/// Returns the span pointing to the closing delimiter of this group.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```text</span>
<span class="doccomment">/// pub fn span_close(&amp;self) -&gt; Span {</span>
<span class="doccomment">/// ^</span>
<span class="doccomment">/// ```</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span_close</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">span_close</span>())
}
<span class="doccomment">/// Configures the span for this `Group`&#39;s delimiters, but not its internal</span>
<span class="doccomment">/// tokens.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method will **not** set the span of all the internal tokens spanned</span>
<span class="doccomment">/// by this group, but rather it will only set the span of the delimiter</span>
<span class="doccomment">/// tokens at the level of the `Group`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_span</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">span</span>: <span class="ident">Span</span>) {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">set_span</span>(<span class="ident">span</span>.<span class="ident">inner</span>)
}
}
<span class="doccomment">/// Prints the group as a string that should be losslessly convertible back</span>
<span class="doccomment">/// into the same group (modulo spans), except for possibly `TokenTree::Group`s</span>
<span class="doccomment">/// with `Delimiter::None` delimiters.</span>
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">Group</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">formatter</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">formatter</span>)
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Group</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">formatter</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">formatter</span>)
}
}
<span class="doccomment">/// An `Punct` is an single punctuation character like `+`, `-` or `#`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Multicharacter operators like `+=` are represented as two instances of</span>
<span class="doccomment">/// `Punct` with different forms of `Spacing` returned.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Punct</span> {
<span class="ident">ch</span>: <span class="ident">char</span>,
<span class="ident">spacing</span>: <span class="ident">Spacing</span>,
<span class="ident">span</span>: <span class="ident">Span</span>,
}
<span class="doccomment">/// Whether an `Punct` is followed immediately by another `Punct` or followed by</span>
<span class="doccomment">/// another token or whitespace.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">Eq</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">Spacing</span> {
<span class="doccomment">/// E.g. `+` is `Alone` in `+ =`, `+ident` or `+()`.</span>
<span class="ident">Alone</span>,
<span class="doccomment">/// E.g. `+` is `Joint` in `+=` or `&#39;` is `Joint` in `&#39;#`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Additionally, single quote `&#39;` can join with identifiers to form</span>
<span class="doccomment">/// lifetimes `&#39;ident`.</span>
<span class="ident">Joint</span>,
}
<span class="kw">impl</span> <span class="ident">Punct</span> {
<span class="doccomment">/// Creates a new `Punct` from the given character and spacing.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// The `ch` argument must be a valid punctuation character permitted by the</span>
<span class="doccomment">/// language, otherwise the function will panic.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// The returned `Punct` will have the default span of `Span::call_site()`</span>
<span class="doccomment">/// which can be further configured with the `set_span` method below.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">ch</span>: <span class="ident">char</span>, <span class="ident">spacing</span>: <span class="ident">Spacing</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Punct</span> {
<span class="ident">Punct</span> {
<span class="ident">ch</span>,
<span class="ident">spacing</span>,
<span class="ident">span</span>: <span class="ident">Span</span>::<span class="ident">call_site</span>(),
}
}
<span class="doccomment">/// Returns the value of this punctuation character as `char`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">as_char</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">char</span> {
<span class="self">self</span>.<span class="ident">ch</span>
}
<span class="doccomment">/// Returns the spacing of this punctuation character, indicating whether</span>
<span class="doccomment">/// it&#39;s immediately followed by another `Punct` in the token stream, so</span>
<span class="doccomment">/// they can potentially be combined into a multicharacter operator</span>
<span class="doccomment">/// (`Joint`), or it&#39;s followed by some other token or whitespace (`Alone`)</span>
<span class="doccomment">/// so the operator has certainly ended.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">spacing</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Spacing</span> {
<span class="self">self</span>.<span class="ident">spacing</span>
}
<span class="doccomment">/// Returns the span for this punctuation character.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="self">self</span>.<span class="ident">span</span>
}
<span class="doccomment">/// Configure the span for this punctuation character.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_span</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">span</span>: <span class="ident">Span</span>) {
<span class="self">self</span>.<span class="ident">span</span> <span class="op">=</span> <span class="ident">span</span>;
}
}
<span class="doccomment">/// Prints the punctuation character as a string that should be losslessly</span>
<span class="doccomment">/// convertible back into the same character.</span>
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">Punct</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">ch</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Punct</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">fmt</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">debug</span> <span class="op">=</span> <span class="ident">fmt</span>.<span class="ident">debug_struct</span>(<span class="string">&quot;Punct&quot;</span>);
<span class="ident">debug</span>.<span class="ident">field</span>(<span class="string">&quot;char&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">ch</span>);
<span class="ident">debug</span>.<span class="ident">field</span>(<span class="string">&quot;spacing&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">spacing</span>);
<span class="ident">imp</span>::<span class="ident">debug_span_field_if_nontrivial</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">debug</span>, <span class="self">self</span>.<span class="ident">span</span>.<span class="ident">inner</span>);
<span class="ident">debug</span>.<span class="ident">finish</span>()
}
}
<span class="doccomment">/// A word of Rust code, which may be a keyword or legal variable name.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// An identifier consists of at least one Unicode code point, the first of</span>
<span class="doccomment">/// which has the XID_Start property and the rest of which have the XID_Continue</span>
<span class="doccomment">/// property.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// - The empty string is not an identifier. Use `Option&lt;Ident&gt;`.</span>
<span class="doccomment">/// - A lifetime is not an identifier. Use `syn::Lifetime` instead.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// An identifier constructed with `Ident::new` is permitted to be a Rust</span>
<span class="doccomment">/// keyword, though parsing one through its [`Parse`] implementation rejects</span>
<span class="doccomment">/// Rust keywords. Use `input.call(Ident::parse_any)` when parsing to match the</span>
<span class="doccomment">/// behaviour of `Ident::new`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// [`Parse`]: https://docs.rs/syn/1.0/syn/parse/trait.Parse.html</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Examples</span>
<span class="doccomment">///</span>
<span class="doccomment">/// A new ident can be created from a string using the `Ident::new` function.</span>
<span class="doccomment">/// A span must be provided explicitly which governs the name resolution</span>
<span class="doccomment">/// behavior of the resulting identifier.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">/// use proc_macro2::{Ident, Span};</span>
<span class="doccomment">///</span>
<span class="doccomment">/// fn main() {</span>
<span class="doccomment">/// let call_ident = Ident::new(&quot;calligraphy&quot;, Span::call_site());</span>
<span class="doccomment">///</span>
<span class="doccomment">/// println!(&quot;{}&quot;, call_ident);</span>
<span class="doccomment">/// }</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">///</span>
<span class="doccomment">/// An ident can be interpolated into a token stream using the `quote!` macro.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">/// use proc_macro2::{Ident, Span};</span>
<span class="doccomment">/// use quote::quote;</span>
<span class="doccomment">///</span>
<span class="doccomment">/// fn main() {</span>
<span class="doccomment">/// let ident = Ident::new(&quot;demo&quot;, Span::call_site());</span>
<span class="doccomment">///</span>
<span class="doccomment">/// // Create a variable binding whose name is this ident.</span>
<span class="doccomment">/// let expanded = quote! { let #ident = 10; };</span>
<span class="doccomment">///</span>
<span class="doccomment">/// // Create a variable binding with a slightly different name.</span>
<span class="doccomment">/// let temp_ident = Ident::new(&amp;format!(&quot;new_{}&quot;, ident), Span::call_site());</span>
<span class="doccomment">/// let expanded = quote! { let #temp_ident = 10; };</span>
<span class="doccomment">/// }</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">///</span>
<span class="doccomment">/// A string representation of the ident is available through the `to_string()`</span>
<span class="doccomment">/// method.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// ```</span>
<span class="doccomment">/// # use proc_macro2::{Ident, Span};</span>
<span class="doccomment">/// #</span>
<span class="doccomment">/// # let ident = Ident::new(&quot;another_identifier&quot;, Span::call_site());</span>
<span class="doccomment">/// #</span>
<span class="doccomment">/// // Examine the ident as a string.</span>
<span class="doccomment">/// let ident_string = ident.to_string();</span>
<span class="doccomment">/// if ident_string.len() &gt; 60 {</span>
<span class="doccomment">/// println!(&quot;Very long identifier: {}&quot;, ident_string)</span>
<span class="doccomment">/// }</span>
<span class="doccomment">/// ```</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Ident</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Ident</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="kw">impl</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Ident</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ident</span> {
<span class="ident">Ident</span> {
<span class="ident">inner</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="doccomment">/// Creates a new `Ident` with the given `string` as well as the specified</span>
<span class="doccomment">/// `span`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// The `string` argument must be a valid identifier permitted by the</span>
<span class="doccomment">/// language, otherwise the function will panic.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Note that `span`, currently in rustc, configures the hygiene information</span>
<span class="doccomment">/// for this identifier.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// As of this time `Span::call_site()` explicitly opts-in to &quot;call-site&quot;</span>
<span class="doccomment">/// hygiene meaning that identifiers created with this span will be resolved</span>
<span class="doccomment">/// as if they were written directly at the location of the macro call, and</span>
<span class="doccomment">/// other code at the macro call site will be able to refer to them as well.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Later spans like `Span::def_site()` will allow to opt-in to</span>
<span class="doccomment">/// &quot;definition-site&quot; hygiene meaning that identifiers created with this</span>
<span class="doccomment">/// span will be resolved at the location of the macro definition and other</span>
<span class="doccomment">/// code at the macro call site will not be able to refer to them.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Due to the current importance of hygiene this constructor, unlike other</span>
<span class="doccomment">/// tokens, requires a `Span` to be specified at construction.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Panics if the input string is neither a keyword nor a legal variable</span>
<span class="doccomment">/// name. If you are not sure whether the string contains an identifier and</span>
<span class="doccomment">/// need to handle an error case, use</span>
<span class="doccomment">/// &lt;a href=&quot;https://docs.rs/syn/1.0/syn/fn.parse_str.html&quot;&gt;&lt;code</span>
<span class="doccomment">/// style=&quot;padding-right:0;&quot;&gt;syn::parse_str&lt;/code&gt;&lt;/a&gt;&lt;code</span>
<span class="doccomment">/// style=&quot;padding-left:0;&quot;&gt;::&amp;lt;Ident&amp;gt;&lt;/code&gt;</span>
<span class="doccomment">/// rather than `Ident::new`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>, <span class="ident">span</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ident</span> {
<span class="ident">Ident</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Ident</span>::<span class="ident">new</span>(<span class="ident">string</span>, <span class="ident">span</span>.<span class="ident">inner</span>))
}
<span class="doccomment">/// Same as `Ident::new`, but creates a raw identifier (`r#ident`).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This method is semver exempt and not exposed by default.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">procmacro2_semver_exempt</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new_raw</span>(<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>, <span class="ident">span</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ident</span> {
<span class="ident">Ident</span>::<span class="ident">_new_raw</span>(<span class="ident">string</span>, <span class="ident">span</span>)
}
<span class="kw">fn</span> <span class="ident">_new_raw</span>(<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>, <span class="ident">span</span>: <span class="ident">Span</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ident</span> {
<span class="ident">Ident</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Ident</span>::<span class="ident">new_raw</span>(<span class="ident">string</span>, <span class="ident">span</span>.<span class="ident">inner</span>))
}
<span class="doccomment">/// Returns the span of this `Ident`.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">span</span>())
}
<span class="doccomment">/// Configures the span of this `Ident`, possibly changing its hygiene</span>
<span class="doccomment">/// context.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_span</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">span</span>: <span class="ident">Span</span>) {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">set_span</span>(<span class="ident">span</span>.<span class="ident">inner</span>);
}
}
<span class="kw">impl</span> <span class="ident">PartialEq</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">eq</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="ident">Ident</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="self">self</span>.<span class="ident">inner</span> <span class="op">=</span><span class="op">=</span> <span class="ident">other</span>.<span class="ident">inner</span>
}
}
<span class="kw">impl</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span> <span class="ident">PartialEq</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span> <span class="kw">for</span> <span class="ident">Ident</span>
<span class="kw">where</span>
<span class="ident">T</span>: <span class="question-mark">?</span><span class="ident">Sized</span> <span class="op">+</span> <span class="ident">AsRef</span><span class="op">&lt;</span><span class="ident">str</span><span class="op">&gt;</span>,
{
<span class="kw">fn</span> <span class="ident">eq</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="ident">T</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="self">self</span>.<span class="ident">inner</span> <span class="op">=</span><span class="op">=</span> <span class="ident">other</span>
}
}
<span class="kw">impl</span> <span class="ident">Eq</span> <span class="kw">for</span> <span class="ident">Ident</span> {}
<span class="kw">impl</span> <span class="ident">PartialOrd</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">partial_cmp</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="ident">Ident</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Ordering</span><span class="op">&gt;</span> {
<span class="prelude-val">Some</span>(<span class="self">self</span>.<span class="ident">cmp</span>(<span class="ident">other</span>))
}
}
<span class="kw">impl</span> <span class="ident">Ord</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">cmp</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">other</span>: <span class="kw-2">&amp;</span><span class="ident">Ident</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Ordering</span> {
<span class="self">self</span>.<span class="ident">to_string</span>().<span class="ident">cmp</span>(<span class="kw-2">&amp;</span><span class="ident">other</span>.<span class="ident">to_string</span>())
}
}
<span class="kw">impl</span> <span class="ident">Hash</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">hash</span><span class="op">&lt;</span><span class="ident">H</span>: <span class="ident">Hasher</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">hasher</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">H</span>) {
<span class="self">self</span>.<span class="ident">to_string</span>().<span class="ident">hash</span>(<span class="ident">hasher</span>)
}
}
<span class="doccomment">/// Prints the identifier as a string that should be losslessly convertible back</span>
<span class="doccomment">/// into the same identifier.</span>
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Ident</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="doccomment">/// A literal string (`&quot;hello&quot;`), byte string (`b&quot;hello&quot;`), character (`&#39;a&#39;`),</span>
<span class="doccomment">/// byte character (`b&#39;a&#39;`), an integer or floating point number with or without</span>
<span class="doccomment">/// a suffix (`1`, `1u8`, `2.3`, `2.3f32`).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Boolean literals like `true` and `false` do not belong here, they are</span>
<span class="doccomment">/// `Ident`s.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Literal</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Literal</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">suffixed_int_literals</span> {
($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>:<span class="ident">ident</span> <span class="op">=</span><span class="op">&gt;</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">kind</span>:<span class="ident">ident</span>,)<span class="kw-2">*</span>) <span class="op">=</span><span class="op">&gt;</span> ($(
<span class="doccomment">/// Creates a new suffixed integer literal with the specified value.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function will create an integer like `1u32` where the integer</span>
<span class="doccomment">/// value specified is the first part of the token and the integral is</span>
<span class="doccomment">/// also suffixed at the end. Literals created from negative numbers may</span>
<span class="doccomment">/// not survive rountrips through `TokenStream` or strings and may be</span>
<span class="doccomment">/// broken into two tokens (`-` and positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Literals created through this method have the `Span::call_site()`</span>
<span class="doccomment">/// span by default, which can be configured with the `set_span` method</span>
<span class="doccomment">/// below.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>(<span class="ident">n</span>: <span class="macro-nonterminal">$</span><span class="macro-nonterminal">kind</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>(<span class="ident">n</span>))
}
)<span class="kw-2">*</span>)
}
<span class="macro">macro_rules</span><span class="macro">!</span> <span class="ident">unsuffixed_int_literals</span> {
($(<span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>:<span class="ident">ident</span> <span class="op">=</span><span class="op">&gt;</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">kind</span>:<span class="ident">ident</span>,)<span class="kw-2">*</span>) <span class="op">=</span><span class="op">&gt;</span> ($(
<span class="doccomment">/// Creates a new unsuffixed integer literal with the specified value.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function will create an integer like `1` where the integer</span>
<span class="doccomment">/// value specified is the first part of the token. No suffix is</span>
<span class="doccomment">/// specified on this token, meaning that invocations like</span>
<span class="doccomment">/// `Literal::i8_unsuffixed(1)` are equivalent to</span>
<span class="doccomment">/// `Literal::u32_unsuffixed(1)`. Literals created from negative numbers</span>
<span class="doccomment">/// may not survive rountrips through `TokenStream` or strings and may</span>
<span class="doccomment">/// be broken into two tokens (`-` and positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Literals created through this method have the `Span::call_site()`</span>
<span class="doccomment">/// span by default, which can be configured with the `set_span` method</span>
<span class="doccomment">/// below.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>(<span class="ident">n</span>: <span class="macro-nonterminal">$</span><span class="macro-nonterminal">kind</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="macro-nonterminal">$</span><span class="macro-nonterminal">name</span>(<span class="ident">n</span>))
}
)<span class="kw-2">*</span>)
}
<span class="kw">impl</span> <span class="ident">Literal</span> {
<span class="kw">fn</span> <span class="ident">_new</span>(<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">Literal</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span> {
<span class="ident">inner</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="kw">fn</span> <span class="ident">_new_stable</span>(<span class="ident">inner</span>: <span class="ident">fallback</span>::<span class="ident">Literal</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span> {
<span class="ident">inner</span>: <span class="ident">inner</span>.<span class="ident">into</span>(),
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
<span class="macro">suffixed_int_literals</span><span class="macro">!</span> {
<span class="ident">u8_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u8</span>,
<span class="ident">u16_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u16</span>,
<span class="ident">u32_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u32</span>,
<span class="ident">u64_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u64</span>,
<span class="ident">u128_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u128</span>,
<span class="ident">usize_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">usize</span>,
<span class="ident">i8_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i8</span>,
<span class="ident">i16_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i16</span>,
<span class="ident">i32_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i32</span>,
<span class="ident">i64_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i64</span>,
<span class="ident">i128_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i128</span>,
<span class="ident">isize_suffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">isize</span>,
}
<span class="macro">unsuffixed_int_literals</span><span class="macro">!</span> {
<span class="ident">u8_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u8</span>,
<span class="ident">u16_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u16</span>,
<span class="ident">u32_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u32</span>,
<span class="ident">u64_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u64</span>,
<span class="ident">u128_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">u128</span>,
<span class="ident">usize_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">usize</span>,
<span class="ident">i8_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i8</span>,
<span class="ident">i16_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i16</span>,
<span class="ident">i32_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i32</span>,
<span class="ident">i64_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i64</span>,
<span class="ident">i128_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">i128</span>,
<span class="ident">isize_unsuffixed</span> <span class="op">=</span><span class="op">&gt;</span> <span class="ident">isize</span>,
}
<span class="doccomment">/// Creates a new unsuffixed floating-point literal.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This constructor is similar to those like `Literal::i8_unsuffixed` where</span>
<span class="doccomment">/// the float&#39;s value is emitted directly into the token but no suffix is</span>
<span class="doccomment">/// used, so it may be inferred to be a `f64` later in the compiler.</span>
<span class="doccomment">/// Literals created from negative numbers may not survive rountrips through</span>
<span class="doccomment">/// `TokenStream` or strings and may be broken into two tokens (`-` and</span>
<span class="doccomment">/// positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function requires that the specified float is finite, for example</span>
<span class="doccomment">/// if it is infinity or NaN this function will panic.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">f64_unsuffixed</span>(<span class="ident">f</span>: <span class="ident">f64</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">f</span>.<span class="ident">is_finite</span>());
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">f64_unsuffixed</span>(<span class="ident">f</span>))
}
<span class="doccomment">/// Creates a new suffixed floating-point literal.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This constructor will create a literal like `1.0f64` where the value</span>
<span class="doccomment">/// specified is the preceding part of the token and `f64` is the suffix of</span>
<span class="doccomment">/// the token. This token will always be inferred to be an `f64` in the</span>
<span class="doccomment">/// compiler. Literals created from negative numbers may not survive</span>
<span class="doccomment">/// rountrips through `TokenStream` or strings and may be broken into two</span>
<span class="doccomment">/// tokens (`-` and positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function requires that the specified float is finite, for example</span>
<span class="doccomment">/// if it is infinity or NaN this function will panic.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">f64_suffixed</span>(<span class="ident">f</span>: <span class="ident">f64</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">f</span>.<span class="ident">is_finite</span>());
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">f64_suffixed</span>(<span class="ident">f</span>))
}
<span class="doccomment">/// Creates a new unsuffixed floating-point literal.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This constructor is similar to those like `Literal::i8_unsuffixed` where</span>
<span class="doccomment">/// the float&#39;s value is emitted directly into the token but no suffix is</span>
<span class="doccomment">/// used, so it may be inferred to be a `f64` later in the compiler.</span>
<span class="doccomment">/// Literals created from negative numbers may not survive rountrips through</span>
<span class="doccomment">/// `TokenStream` or strings and may be broken into two tokens (`-` and</span>
<span class="doccomment">/// positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function requires that the specified float is finite, for example</span>
<span class="doccomment">/// if it is infinity or NaN this function will panic.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">f32_unsuffixed</span>(<span class="ident">f</span>: <span class="ident">f32</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">f</span>.<span class="ident">is_finite</span>());
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">f32_unsuffixed</span>(<span class="ident">f</span>))
}
<span class="doccomment">/// Creates a new suffixed floating-point literal.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This constructor will create a literal like `1.0f32` where the value</span>
<span class="doccomment">/// specified is the preceding part of the token and `f32` is the suffix of</span>
<span class="doccomment">/// the token. This token will always be inferred to be an `f32` in the</span>
<span class="doccomment">/// compiler. Literals created from negative numbers may not survive</span>
<span class="doccomment">/// rountrips through `TokenStream` or strings and may be broken into two</span>
<span class="doccomment">/// tokens (`-` and positive literal).</span>
<span class="doccomment">///</span>
<span class="doccomment">/// # Panics</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function requires that the specified float is finite, for example</span>
<span class="doccomment">/// if it is infinity or NaN this function will panic.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">f32_suffixed</span>(<span class="ident">f</span>: <span class="ident">f32</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">f</span>.<span class="ident">is_finite</span>());
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">f32_suffixed</span>(<span class="ident">f</span>))
}
<span class="doccomment">/// String literal.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">string</span>(<span class="ident">string</span>: <span class="kw-2">&amp;</span><span class="ident">str</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">string</span>(<span class="ident">string</span>))
}
<span class="doccomment">/// Character literal.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">character</span>(<span class="ident">ch</span>: <span class="ident">char</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">character</span>(<span class="ident">ch</span>))
}
<span class="doccomment">/// Byte string literal.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">byte_string</span>(<span class="ident">s</span>: <span class="kw-2">&amp;</span>[<span class="ident">u8</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Literal</span> {
<span class="ident">Literal</span>::<span class="ident">_new</span>(<span class="ident">imp</span>::<span class="ident">Literal</span>::<span class="ident">byte_string</span>(<span class="ident">s</span>))
}
<span class="doccomment">/// Returns the span encompassing this literal.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">span</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">Span</span> {
<span class="ident">Span</span>::<span class="ident">_new</span>(<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">span</span>())
}
<span class="doccomment">/// Configures the span associated for this literal.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">set_span</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">span</span>: <span class="ident">Span</span>) {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">set_span</span>(<span class="ident">span</span>.<span class="ident">inner</span>);
}
<span class="doccomment">/// Returns a `Span` that is a subset of `self.span()` containing only</span>
<span class="doccomment">/// the source bytes in range `range`. Returns `None` if the would-be</span>
<span class="doccomment">/// trimmed span is outside the bounds of `self`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// Warning: the underlying [`proc_macro::Literal::subspan`] method is</span>
<span class="doccomment">/// nightly-only. When called from within a procedural macro not using a</span>
<span class="doccomment">/// nightly compiler, this method will always return `None`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// [`proc_macro::Literal::subspan`]: https://doc.rust-lang.org/proc_macro/struct.Literal.html#method.subspan</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">subspan</span><span class="op">&lt;</span><span class="ident">R</span>: <span class="ident">RangeBounds</span><span class="op">&lt;</span><span class="ident">usize</span><span class="op">&gt;</span><span class="op">&gt;</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">range</span>: <span class="ident">R</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Span</span><span class="op">&gt;</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">subspan</span>(<span class="ident">range</span>).<span class="ident">map</span>(<span class="ident">Span</span>::<span class="ident">_new</span>)
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">Literal</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">Display</span> <span class="kw">for</span> <span class="ident">Literal</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="doccomment">/// Public implementation details for the `TokenStream` type, such as iterators.</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">token_stream</span> {
<span class="kw">use</span> <span class="kw">crate</span>::<span class="ident">marker</span>::<span class="ident">Marker</span>;
<span class="kw">use</span> <span class="kw">crate</span>::{<span class="ident">imp</span>, <span class="ident">TokenTree</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>::{<span class="self">self</span>, <span class="ident">Debug</span>};
<span class="kw">pub</span> <span class="kw">use</span> <span class="kw">crate</span>::<span class="ident">TokenStream</span>;
<span class="doccomment">/// An iterator over `TokenStream`&#39;s `TokenTree`s.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// The iteration is &quot;shallow&quot;, e.g. the iterator doesn&#39;t recurse into</span>
<span class="doccomment">/// delimited groups, and returns whole groups as token trees.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">IntoIter</span> {
<span class="ident">inner</span>: <span class="ident">imp</span>::<span class="ident">TokenTreeIter</span>,
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
<span class="kw">impl</span> <span class="ident">Iterator</span> <span class="kw">for</span> <span class="ident">IntoIter</span> {
<span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenTree</span>;
<span class="kw">fn</span> <span class="ident">next</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">TokenTree</span><span class="op">&gt;</span> {
<span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">next</span>()
}
}
<span class="kw">impl</span> <span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">IntoIter</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">Debug</span>::<span class="ident">fmt</span>(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="ident">inner</span>, <span class="ident">f</span>)
}
}
<span class="kw">impl</span> <span class="ident">IntoIterator</span> <span class="kw">for</span> <span class="ident">TokenStream</span> {
<span class="kw">type</span> <span class="ident">Item</span> <span class="op">=</span> <span class="ident">TokenTree</span>;
<span class="kw">type</span> <span class="ident">IntoIter</span> <span class="op">=</span> <span class="ident">IntoIter</span>;
<span class="kw">fn</span> <span class="ident">into_iter</span>(<span class="self">self</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">IntoIter</span> {
<span class="ident">IntoIter</span> {
<span class="ident">inner</span>: <span class="self">self</span>.<span class="ident">inner</span>.<span class="ident">into_iter</span>(),
<span class="ident">_marker</span>: <span class="ident">Marker</span>,
}
}
}
}
</pre></div>
</section><section id="search" class="content hidden"></section><section class="footer"></section><div id="rustdoc-vars" data-root-path="../../" data-current-crate="proc_macro2"></div>
<script src="../../main.js"></script><script src="../../source-script.js"></script><script src="../../source-files.js"></script><script defer src="../../search-index.js"></script></body></html>
Reference in New Issue View Git Blame Copy Permalink