Module Raw

Gets the immediate child indexed at index. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct.

INTERNAL: Do not use. An ABI specification for an extern function or block.

INTERNAL: Do not use. Something that can be addressed by a path.

INTERNAL: Do not use. A list of arguments in a function or method call.

INTERNAL: Do not use.

INTERNAL: Do not use. An array type representation.

INTERNAL: Do not use. A clobbered ABI in an inline assembly block.

INTERNAL: Do not use. A constant operand in an inline assembly block.

INTERNAL: Do not use. An inline assembly direction specifier.

INTERNAL: Do not use. An inline assembly expression. For example: rust unsafe { #[inline(always)] builtin # asm("cmp {0}, {1}", in(reg) a, in(reg) b); }

INTERNAL: Do not use. A label in an inline assembly block.

INTERNAL: Do not use.

INTERNAL: Do not use. An operand expression in an inline assembly block.

INTERNAL: Do not use. A named operand in an inline assembly block.

INTERNAL: Do not use. An option in an inline assembly block.

INTERNAL: Do not use. A list of options in an inline assembly block.

INTERNAL: Do not use.

INTERNAL: Do not use. A register operand in an inline assembly block.

INTERNAL: Do not use. A register specification in an inline assembly block.

INTERNAL: Do not use. A symbol operand in an inline assembly block.

INTERNAL: Do not use. An associated item in a Trait or Impl.

INTERNAL: Do not use. A list of AssocItem elements, as appearing in a Trait or Impl.

INTERNAL: Do not use. An associated type argument in a path.

INTERNAL: Do not use.

INTERNAL: Do not use. An attribute applied to an item.

INTERNAL: Do not use. An await expression. For example: rust async { let x = foo().await; x }

INTERNAL: Do not use. A become expression. For example: rust fn fact_a(n: i32, a: i32) -> i32 { if n == 0 { a } else { become fact_a(n - 1, n * a) } }

INTERNAL: Do not use. A binary operation expression. For example: rust x + y; x && y; x <= y; x = y; x += y;

INTERNAL: Do not use. A block expression. For example: rust { let x = 42; } rust 'label: { let x = 42; x }

INTERNAL: Do not use. A box pattern. For example: rust match x { box Option::Some(y) => y, box Option::None => 0, };

INTERNAL: Do not use. A break expression. For example: rust loop { if not_ready() { break; } } rust let x = 'label: loop { if done() { break 'label 42; } }; rust let x = 'label: { if exit() { break 'label 42; } 0; };

INTERNAL: Do not use. NOTE: Consider using Call instead, as that excludes call expressions that are instantiations of tuple structs and tuple variants.

INTERNAL: Do not use. A callable. Either a Function or a ClosureExpr.

INTERNAL: Do not use. A type cast expression. For example: rust value as u64;

INTERNAL: Do not use. A closure expression. For example: rust |x| x + 1; move |x: i32| -> i32 { x + 1 }; async |x: i32, y| x + y; #[coroutine] |x| yield x; #[coroutine] static |x| yield x; for<T: std::fmt::Debug> |x: T| { println!("{:?}", x); };

INTERNAL: Do not use. A comment. For example: rust // this is a comment /// This is a doc comment

INTERNAL: Do not use. A constant item declaration.

INTERNAL: Do not use. A constant argument in a generic argument list.

INTERNAL: Do not use. A const block pattern. For example: rust match x { const { 1 + 2 + 3 } => "ok", _ => "fail", };

INTERNAL: Do not use. A constant parameter in a generic parameter list.

INTERNAL: Do not use. A continue expression. For example: rust loop { if not_ready() { continue; } } rust 'label: loop { if not_ready() { continue 'label; } }

INTERNAL: Do not use.

INTERNAL: Do not use. A dynamic trait object type.

INTERNAL: Do not use.

INTERNAL: Do not use. An enum declaration.

INTERNAL: Do not use. The base class for expressions.

INTERNAL: Do not use. An expression statement. For example: rust start(); finish(); use std::env;

INTERNAL: Do not use. An extern block containing foreign function declarations.

INTERNAL: Do not use. An extern crate declaration.

INTERNAL: Do not use. An item inside an extern block.

INTERNAL: Do not use. A list of items inside an extern block.

INTERNAL: Do not use.

INTERNAL: Do not use. A field access expression. For example: rust x.foo

INTERNAL: Do not use. A list of fields in a struct or enum variant.

INTERNAL: Do not use. A function pointer type.

INTERNAL: Do not use. A for binder, specifying lifetime or type parameters for a closure or a type.

INTERNAL: Do not use. A for loop expression.

INTERNAL: Do not use. A function pointer type with a for modifier.

INTERNAL: Do not use. A FormatArgsArg. For example the "world" in: rust format_args!("Hello, {}!", "world")

INTERNAL: Do not use. A FormatArgsExpr. For example: rust format_args!("no args"); format_args!("{} foo {:?}", 1, 2); format_args!("{b} foo {a:?}", a=1, b=2); let (x, y) = (1, 42); format_args!("{x}, {y}");

INTERNAL: Do not use. A function declaration. For example rust fn foo(x: u32) -> u64 {(x + 1).into()} A function declaration within a trait might not have a body: rust trait Trait { fn bar(); }

INTERNAL: Do not use. A generic argument in a generic argument list.

INTERNAL: Do not use. The base class for generic arguments. rust x.foo::<u32, u64>(42);

INTERNAL: Do not use. A generic parameter in a generic parameter list.

INTERNAL: Do not use. A list of generic parameters. For example: rust fn f<A, B>(a: A, b: B) {} // ^^^^^^ type Foo<T1, T2> = (T1, T2); // ^^^^^^^^

INTERNAL: Do not use. A binding pattern. For example: rust match x { Option::Some(y) => y, Option::None => 0, }; rust match x { y@Option::Some(_) => y, Option::None => 0, };

INTERNAL: Do not use. An if expression. For example: rust if x == 42 { println!("that's the answer"); } rust let y = if x > 0 { 1 } else { 0 };

INTERNAL: Do not use. An `impl`` block.

INTERNAL: Do not use. An impl Trait type.

INTERNAL: Do not use. An index expression. For example: rust list[42]; list[42] = 1;

INTERNAL: Do not use. An inferred type (_).

INTERNAL: Do not use. An item such as a function, struct, enum, etc.

INTERNAL: Do not use. A list of items in a module or block.

INTERNAL: Do not use. A label. For example: rust 'label: loop { println!("Hello, world (once)!"); break 'label; };

INTERNAL: Do not use. The base class for expressions that can be labeled (LoopExpr, ForExpr, WhileExpr or BlockExpr).

INTERNAL: Do not use. An else block in a let-else statement.

INTERNAL: Do not use. A let expression. For example: rust if let Some(x) = maybe_some { println!("{}", x); }

INTERNAL: Do not use. A let statement. For example: rust let x = 42; let x: i32 = 42; let x: i32; let x; let (x, y) = (1, 2); let Some(x) = std::env::var("FOO") else { return; };

INTERNAL: Do not use. A lifetime annotation.

INTERNAL: Do not use. A lifetime argument in a generic argument list.

INTERNAL: Do not use. A lifetime parameter in a generic parameter list.

INTERNAL: Do not use. A literal expression. For example: rust 42; 42.0; "Hello, world!"; b"Hello, world!"; 'x'; b'x'; r"Hello, world!"; true;

INTERNAL: Do not use. A literal pattern. For example: rust match x { 42 => "ok", _ => "fail", }

INTERNAL: Do not use.

INTERNAL: Do not use. A loop expression. For example: rust loop { println!("Hello, world (again)!"); }; rust 'label: loop { println!("Hello, world (once)!"); break 'label; }; rust let mut x = 0; loop { if x < 10 { x += 1; } else { break; } };

INTERNAL: Do not use. The base class for expressions that loop (LoopExpr, ForExpr or WhileExpr).

INTERNAL: Do not use. A macro invocation.

INTERNAL: Do not use. A Rust 2.0 style declarative macro definition.

INTERNAL: Do not use. A macro expression, representing the invocation of a macro that produces an expression.

INTERNAL: Do not use. A sequence of items generated by a macro. For example:

INTERNAL: Do not use. A macro pattern, representing the invocation of a macro that produces a pattern.

INTERNAL: Do not use. A macro definition using the macro_rules! syntax. rust macro_rules! my_macro { () => { println!("This is a macro!"); }; }

INTERNAL: Do not use. A type produced by a macro.

INTERNAL: Do not use. A match arm. For example: rust match x { Option::Some(y) => y, Option::None => 0, }; rust match x { Some(y) if y != 0 => 1 / y, _ => 0, };

INTERNAL: Do not use. A list of arms in a match expression.

INTERNAL: Do not use. A match expression. For example: rust match x { Option::Some(y) => y, Option::None => 0, } rust match x { Some(y) if y != 0 => 1 / y, _ => 0, }

INTERNAL: Do not use. A guard condition in a match arm.

INTERNAL: Do not use. A meta item in an attribute.

INTERNAL: Do not use. NOTE: Consider using MethodCall instead, as that also includes calls to methods using call syntax (such as Foo::method(x)), operation syntax (such as x + y), and indexing syntax (such as x[y]).

INTERNAL: Do not use. The base class marking errors during parsing or resolution.

INTERNAL: Do not use. A module declaration. For example: rust mod foo; rust mod bar { pub fn baz() {} }

INTERNAL: Do not use. An identifier name.

INTERNAL: Do not use. A reference to a name.

INTERNAL: Do not use.

INTERNAL: Do not use. The never type !.

INTERNAL: Do not use. An offset_of expression. For example: rust builtin # offset_of(Struct, field);

INTERNAL: Do not use. An or pattern. For example: rust match x { Option::Some(y) | Option::None => 0, }

INTERNAL: Do not use. A parameter in a function or method. For example x in: rust fn new(x: T) -> Foo<T> { // ... }

INTERNAL: Do not use. A normal parameter, Param, or a self parameter SelfParam.

INTERNAL: Do not use. A list of parameters in a function, method, or closure declaration.

INTERNAL: Do not use. A parenthesized expression.

INTERNAL: Do not use. A parenthesized pattern.

INTERNAL: Do not use. A parenthesized type.

INTERNAL: Do not use. A parenthesized argument list as used in function traits.

INTERNAL: Do not use. The base class for patterns.

INTERNAL: Do not use. A path. For example: rust use some_crate::some_module::some_item; foo::bar;

INTERNAL: Do not use. An AST element wrapping a path (PathExpr, RecordExpr, PathPat, RecordPat, TupleStructPat).

INTERNAL: Do not use. A path expression. For example: rust let x = variable; let x = foo::bar; let y = <T>::foo; let z = <TypeRepr as Trait>::foo;

INTERNAL: Do not use. A path expression or a variable access in a formatting template. See PathExpr and FormatTemplateVariableAccess for further details.

INTERNAL: Do not use. A path pattern. For example: rust match x { Foo::Bar => "ok", _ => "fail", }

INTERNAL: Do not use. A path segment, which is one part of a whole path. For example: - HashMap - HashMap<K, V> - Fn(i32) -> i32 - widgets(..) - <T as Iterator>

INTERNAL: Do not use. A path referring to a type. For example: rust type X = std::collections::HashMap<i32, i32>; type Y = X::Item;

INTERNAL: Do not use. A unary operation expression. For example: rust let x = -42; let y = !true; let z = *ptr;

INTERNAL: Do not use. A pointer type.

INTERNAL: Do not use. A range expression. For example: rust let x = 1..=10; let x = 1..10; let x = 10..; let x = ..10; let x = ..=10; let x = ..;

INTERNAL: Do not use. A range pattern. For example: rust match x { ..15 => "too cold", 16..=25 => "just right", 26.. => "too hot", }

INTERNAL: Do not use. A reference expression. For example: rust let ref_const = &foo; let ref_mut = &mut foo; let raw_const: &mut i32 = &raw const foo; let raw_mut: &mut i32 = &raw mut foo;

INTERNAL: Do not use. A reference pattern. For example: rust match x { &mut Option::Some(y) => y, &Option::None => 0, };

INTERNAL: Do not use. A reference type.

INTERNAL: Do not use. A rename in a use declaration.

INTERNAL: Do not use. A rest pattern (..) in a tuple, slice, or struct pattern.

INTERNAL: Do not use. A return type in a function signature.

INTERNAL: Do not use. A return expression. For example: rust fn some_value() -> i32 { return 42; } rust fn no_value() -> () { return; }

INTERNAL: Do not use. A return type notation (..) to reference or bound the type returned by a trait method

INTERNAL: Do not use. A self parameter. For example self in: rust struct X; impl X { fn one(&self) {} fn two(&mut self) {} fn three(self) {} fn four(mut self) {} fn five<'a>(&'a self) {} }

INTERNAL: Do not use. A slice pattern. For example: rust match x { [1, 2, 3, 4, 5] => "ok", [1, 2, ..] => "fail", [x, y, .., z, 7] => "fail", }

INTERNAL: Do not use. A slice type.

INTERNAL: Do not use. A source file.

INTERNAL: Do not use. A static item declaration.

INTERNAL: Do not use. The base class for statements.

INTERNAL: Do not use. A list of statements in a block, with an optional tail expression at the end that determines the block’s value.

INTERNAL: Do not use. A Struct. For example: rust struct Point { x: i32, y: i32, }

INTERNAL: Do not use. A struct expression. For example: rust let first = Foo { a: 1, b: 2 }; let second = Foo { a: 2, ..first }; let n = Foo { a: 1, b: 2 }.b; Foo { a: m, .. } = second;

INTERNAL: Do not use. A field in a struct expression. For example a: 1 in: rust Foo { a: 1, b: 2 };

INTERNAL: Do not use. A list of fields in a struct expression.

INTERNAL: Do not use. A field in a struct declaration.

INTERNAL: Do not use. A list of fields in a struct declaration.

INTERNAL: Do not use. A struct pattern. For example: rust match x { Foo { a: 1, b: 2 } => "ok", Foo { .. } => "fail", }

INTERNAL: Do not use. A field in a struct pattern. For example a: 1 in: rust let Foo { a: 1, b: 2 } = foo;

INTERNAL: Do not use. A list of fields in a struct pattern.

INTERNAL: Do not use. The base class for all tokens.

INTERNAL: Do not use. A token tree in a macro definition or invocation.

INTERNAL: Do not use. A Trait. For example:

INTERNAL: Do not use. A trait alias.

INTERNAL: Do not use. A try expression using the ? operator.

INTERNAL: Do not use. A tuple expression. For example: rust let tuple = (1, "one"); let n = (2, "two").0; let (a, b) = tuple;

INTERNAL: Do not use. A field in a tuple struct or tuple variant.

INTERNAL: Do not use. A list of fields in a tuple struct or tuple variant.

INTERNAL: Do not use. A tuple pattern. For example: rust let (x, y) = (1, 2); let (a, b, .., z) = (1, 2, 3, 4, 5);

INTERNAL: Do not use. A tuple struct pattern. For example: rust match x { Tuple("a", 1, 2, 3) => "great", Tuple(.., 3) => "fine", Tuple(..) => "fail", };

INTERNAL: Do not use. A tuple type.

INTERNAL: Do not use. A type alias. For example:

INTERNAL: Do not use. A type argument in a generic argument list.

INTERNAL: Do not use. A type bound in a trait or generic parameter.

INTERNAL: Do not use. A list of type bounds.

INTERNAL: Do not use. An item that defines a type. Either a Struct, Enum, or Union.

INTERNAL: Do not use. A type parameter in a generic parameter list.

INTERNAL: Do not use. The base class for type references. rust let x: i32; let y: Vec<i32>; let z: Option<i32>;

INTERNAL: Do not use. An underscore expression. For example: rust _ = 42;

INTERNAL: Do not use. The base class marking everything that was not properly extracted for some reason, such as: * syntax errors * insufficient context information * yet unimplemented parts of the extractor

INTERNAL: Do not use. The base class for unimplemented nodes. This is used to mark nodes that are not yet extracted.

INTERNAL: Do not use. A union declaration.

INTERNAL: Do not use. A use statement. For example: rust use std::collections::HashMap;

INTERNAL: Do not use.

INTERNAL: Do not use. A use<..> bound to control which generic parameters are captured by an impl Trait return type.

INTERNAL: Do not use. A use tree, that is, the part after the use keyword in a use statement. For example: rust use std::collections::HashMap; use std::collections::*; use std::collections::HashMap as MyHashMap; use std::collections::{self, HashMap, HashSet};

INTERNAL: Do not use. A list of use trees in a use declaration.

INTERNAL: Do not use. A variant in an enum declaration.

INTERNAL: Do not use. A list of variants in an enum declaration.

INTERNAL: Do not use. A visibility modifier.

INTERNAL: Do not use. A where clause in a generic declaration.

INTERNAL: Do not use. A predicate in a where clause.

INTERNAL: Do not use. A while loop expression.

INTERNAL: Do not use. A wildcard pattern. For example: rust let _ = 42;

INTERNAL: Do not use. A yeet expression. For example: rust if x < size { do yeet "index out of bounds"; }

INTERNAL: Do not use. A yield expression. For example: rust let one = #[coroutine] || { yield 1; };