SYMBOL INDEX (107 symbols across 5 files)

FILE: src/input.rs
  constant DEFAULT_STD_URL (line 7) | const DEFAULT_STD_URL: &str = "https://doc.rust-lang.org/std/";
  type InputData (line 10) | pub struct InputData {
    method from_file (line 21) | pub fn from_file(path: impl AsRef<Path>) -> Result<Self, Box<dyn Error...
  type BaseUrlMap (line 28) | pub struct BaseUrlMap(HashMap<String, String>);
    method get_url_for (line 31) | pub fn get_url_for(&self, name: &str) -> Option<&str> {
  type Part (line 44) | pub enum Part {
  type Mod (line 50) | pub struct Mod {
  type Type (line 58) | pub struct Type {
  type Kind (line 68) | pub enum Kind {
    method to_str (line 78) | pub fn to_str(self) -> &'static str {
  type Group (line 91) | pub struct Group {
  type InputItem (line 98) | pub enum InputItem {
    method content (line 107) | pub fn content(&self) -> &str {
    method trait_impl (line 114) | pub fn trait_impl(&self) -> Option<&str> {
  type TraitImplPattern (line 123) | pub struct TraitImplPattern {
  type References (line 130) | pub struct References {

FILE: src/main.rs
  function main (line 17) | fn main() -> Result<(), Box<dyn Error>> {

FILE: src/page_gen.rs
  function generate_to (line 15) | pub fn generate_to(path: impl AsRef<Path>, input: &InputData) -> io::Res...
  type PageContentWriter (line 27) | struct PageContentWriter<'a> {
  method fmt (line 32) | fn fmt(&self, f: &mut Formatter) -> Result {
  type Generator (line 44) | struct Generator<'a> {
  type TraitImpl (line 50) | struct TraitImpl<'a> {
  function new (line 57) | fn new(
  function generate (line 107) | fn generate(&self, f: &mut Formatter, data: &[Vec<Part>]) -> Result {
  function generate_section (line 115) | fn generate_section(&self, f: &mut Formatter, section: &[Part]) -> Result {
  function generate_part (line 124) | fn generate_part(&self, f: &mut Formatter, part: &Part) -> Result {
  function build_part_info (line 149) | fn build_part_info(&self, part: &'a Part) -> PartInfo<'a> {
  function build_part_info_for_mod (line 156) | fn build_part_info_for_mod(&self, m: &'a Mod) -> PartInfo<'a> {
  function build_part_info_for_type (line 168) | fn build_part_info_for_type(&self, t: &'a Type) -> PartInfo<'a> {
  function generate_impls (line 209) | fn generate_impls(&self, f: &mut Formatter, impls: &[String]) -> Result {
  function generate_group (line 224) | fn generate_group(&self, f: &mut Formatter, group: &Group, part_info: &P...
  function generate_item (line 237) | fn generate_item(&self, f: &mut Formatter, item: &InputItem, part_info: ...
  function generate_tokens (line 270) | fn generate_tokens(&self, f: &mut Formatter, tokens: &TokenStream<'_>, f...
  function generate_type (line 287) | fn generate_type(&self, f: &mut Formatter, tokens: &TokenStream<'_>, fla...
  function generate_identifier (line 325) | fn generate_identifier(&self, f: &mut Formatter, ident: &str, flags: Fla...
  function generate_primitive (line 339) | fn generate_primitive(
  function get_primitive_url (line 357) | fn get_primitive_url(&self, primitive: &Primitive<'_>) -> String {
  function generate_range (line 370) | fn generate_range(&self, f: &mut Formatter, range: RangeToken, flags: Fl...
  function parse_type (line 393) | fn parse_type(ty: &str) -> TokenStream<'_> {
  function build_type_url (line 399) | fn build_type_url(base: &BaseUrlMap, path: &[&str], kind: Kind, name: &s...
  function build_path_url (line 405) | fn build_path_url(base: &BaseUrlMap, path: &[&str]) -> String {
  function build_tokens_with_replacement (line 418) | fn build_tokens_with_replacement<'a>(
  type Reference (line 440) | struct Reference {
  type PartInfo (line 445) | struct PartInfo<'a> {
  function parse_path (line 453) | fn parse_path(s: &str) -> (Box<[&str]>, &str) {
  type FunctionType (line 461) | enum FunctionType {

FILE: src/parser.rs
  type ParsedItem (line 14) | pub struct ParsedItem<'a> {
  function parse (line 21) | pub fn parse(input: &'a str) -> Result<Self, ()> {
  function parse_constraints (line 31) | pub fn parse_constraints(input: &str) -> Result<TokenStream<'_>, ()> {
  function parse_type (line 35) | pub fn parse_type(input: &str) -> Result<TokenStream<'_>, ()> {
  function parse_impl (line 42) | pub fn parse_impl(input: &str) -> Result<TokenStream<'_>, ()> {
  function parse_trait_impl (line 50) | pub fn parse_trait_impl(input: &str) -> Result<TokenStream<'_>, ()> {
  function parse (line 72) | fn parse<'a, T>(mut parser: parser_str_to!('a, T), input: &'a str) -> Re...
  function item_after_name (line 82) | fn item_after_name<'a>() -> parser_str_to_iter_token!('a) {
  function where_clause (line 92) | fn where_clause<'a>() -> parser_str_to_iter_token!('a) {
  function single_where_constraint (line 99) | fn single_where_constraint<'a>() -> parser_str_to_iter_token!('a) {
  type BoxedTokenIter (line 107) | type BoxedTokenIter<'a> = Box<dyn Iterator<Item = Token<'a>> + 'a>;
  function type_like_inner (line 116) | fn type_like_inner<'a>() -> parser_str_to!('a, BoxedTokenIter<'a>) {
  function single_type_like_inner (line 127) | fn single_type_like_inner<'a>() -> parser_str_to!('a, BoxedTokenIter<'a>) {
  function to_boxed_iter (line 131) | fn to_boxed_iter<'a, T>(iter: impl Iterator<Item = T> + 'a) -> Box<dyn I...
  function single_type_like_token (line 135) | fn single_type_like_token<'a>() -> parser_str_to!('a, Token<'a>) {
  function ref_type (line 147) | fn ref_type<'a>() -> parser_str_to_iter_token!('a) {
  function ptr_type (line 160) | fn ptr_type<'a>() -> parser_str_to_iter_token!('a) {
  function slice_type (line 169) | fn slice_type<'a>() -> parser_str_to_iter_token!('a) {
  function fn_type (line 177) | fn fn_type<'a>() -> parser_str_to_iter_token!('a) {
  function tuple_type (line 186) | fn tuple_type<'a>() -> parser_str_to_iter_token!('a) {
  function nested_type_like_list (line 205) | fn nested_type_like_list<'a>() -> parser_str_to_iter_token!('a) {
  function range_type (line 214) | fn range_type<'a>() -> parser_str_to_iter_token!('a) {
  function range_token (line 239) | fn range_token(s: &str, range: RangeToken) -> impl Iterator<Item = Token...
  function named_type (line 254) | fn named_type<'a>() -> parser_str_to_iter_token!('a) {
  function simple_named_type_inner (line 275) | fn simple_named_type_inner<'a>() -> parser_str_to!('a, BoxedTokenIter<'a...
  function to_type_token (line 295) | fn to_type_token<'a>(inner: parser_str_to_iter_token!('a)) -> parser_str...
  function is_primitive (line 306) | fn is_primitive(ident: &str) -> bool {
  function type_param (line 315) | fn type_param<'a>() -> parser_str_to_iter_token!('a) {
  function lifetime_param (line 323) | fn lifetime_param<'a>() -> parser_str_to_iter_token!('a) {
  function assoc_type_param (line 327) | fn assoc_type_param<'a>() -> parser_str_to_iter_token!('a) {
  function optional_tokens (line 335) | fn optional_tokens<'a>(inner: parser_str_to_iter_token!('a)) -> parser_s...
  function sep1_by_lex (line 341) | fn sep1_by_lex<'a, P, I>(
  function lex (line 355) | fn lex<'a>(s: &'static str) -> parser_str_to_iter_token!('a) {
  function lex_str (line 359) | fn lex_str<'a>(s: &'static str) -> parser_str_to!('a, &'a str) {
  function wrap_start (line 363) | fn wrap_start<'a>(
  function wrap_end (line 374) | fn wrap_end<'a>(inner: &'static str, token: impl Into<Token<'a>>) -> par...
  function wrap (line 382) | fn wrap<'a>(inner: &'static str, token: impl Into<Token<'a>>) -> parser_...
  function maybe_spaces (line 391) | fn maybe_spaces<'a>() -> parser_str_to_iter_token!('a) {
  function text (line 398) | fn text<'a>(inner: impl Parser<&'a str>) -> parser_str_to_iter_token!('a) {
  function text_token (line 402) | fn text_token<'a>(inner: impl Parser<&'a str>) -> impl Parser<&'a str, O...
  function lifetime (line 406) | fn lifetime<'a>() -> parser_str_to!('a, &'a str) {
  function identifier_str (line 410) | fn identifier_str<'a>() -> parser_str_to!('a, &'a str) {

FILE: src/token.rs
  type TokenStream (line 5) | pub struct TokenStream<'a>(pub Vec<Token<'a>>);
  function matches (line 8) | pub fn matches(
  function tokens_match (line 22) | fn tokens_match<'a>(
  method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from_iter (line 67) | fn from_iter<I: IntoIterator<Item = Token<'a>>>(iter: I) -> Self {
  type Item (line 73) | type Item = Token<'a>;
  type IntoIter (line 74) | type IntoIter = <Vec<Token<'a>> as IntoIterator>::IntoIter;
  method into_iter (line 76) | fn into_iter(self) -> Self::IntoIter {
  function extend (line 82) | fn extend<I: IntoIterator<Item = Token<'a>>>(&mut self, iter: I) {
  function extend (line 91) | fn extend<I: IntoIterator<Item = Iter>>(&mut self, iter: I) {
  type Token (line 97) | pub enum Token<'a> {
  function is_whitespace_only (line 109) | pub fn is_whitespace_only(&self) -> bool {
  function from (line 118) | fn from(primitive: Primitive<'a>) -> Self {
  method fmt (line 124) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Primitive (line 136) | pub enum Primitive<'a> {
  method fmt (line 148) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type RangeToken (line 161) | pub enum RangeToken {
  method fmt (line 171) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function token_stream_matches (line 188) | fn token_stream_matches() {