Enum RustElementType 

pub enum RustElementType {
    SourceFile,
    Function,
    Trait,
    Impl,
    UseItem,
    Static,
    Const,
    TypeAlias,
    Macro,
    ExternCrate,
    ExternBlock,
    ModuleItem,
    StructItem,
    EnumItem,
    ReturnStatement,
    ParameterList,
    Parameter,
    ReturnType,
    LetStatement,
    ExpressionStatement,
    BlockExpression,
    IfExpression,
    MatchExpression,
    LoopExpression,
    WhileExpression,
    ForExpression,
    IdentifierExpression,
    LiteralExpression,
    PathExpression,
    IntegerLiteral,
    FloatLiteral,
    StringLiteral,
    CharLiteral,
    BooleanLiteral,
    ParenthesizedExpression,
    TupleExpression,
    ArrayExpression,
    StructExpression,
    AssignmentExpression,
    CallExpression,
    MethodCallExpression,
    FieldExpression,
    IndexExpression,
    ReturnExpression,
    BreakExpression,
    ContinueExpression,
    Pattern,
    MatchArm,
    Type,
    PathType,
    TupleType,
    ArrayType,
    SliceType,
    ReferenceType,
    PointerType,
    FunctionType,
    GenericParams,
    GenericArgs,
    WhereClause,
    Attribute,
    Visibility,
    Async,
    Unsafe,
    Extern,
    Identifier,
    Expression,
    BinaryExpression,
    UnaryExpression,
    ItemStatement,
    ArgumentList,
    PubItem,
    Block,
    Error,
}

Rust 语法树中所有可能的元素类型。

Variants

SourceFile

The root element of any Rust source file

// Entire file content
fn main() {}

Function

A function definition

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Trait

A trait definition

trait Display {
    fn fmt(&self) -> String;
}

Impl

An impl block

impl Display for Point {
    fn fmt(&self, f: &mut Formatter) -> Result { /* ... */ }
}

UseItem

A use statement

use std::collections::HashMap;

Static

A static variable

static COUNT: i32 = 0;

Const

A constant

const MAX_SIZE: usize = 100;

TypeAlias

A type alias

type MyResult = Result<i32, String>;

Macro

A macro invocation or definition

println!("Hello, {}!", name);
vec![1, 2, 3]

ExternCrate

An extern crate declaration

extern crate serde;

ExternBlock

An extern block

extern "C" {
    fn call_c_function();
}

ModuleItem

A module item

mod my_module;
mod my_module { /* content */ }

StructItem

A struct definition

struct Point {
    x: f64,
    y: f64,
}

EnumItem

An enum definition

enum Color {
    Red,
    Green,
    Blue,
}

ReturnStatement

A return statement

return 42;

ParameterList

A parameter list in function definitions

fn example(a: i32, b: String) // (a: i32, b: String)

Parameter

A single parameter in a function

fn example(x: i32) // x: i32

ReturnType

A return type annotation

fn example() -> i32 // -> i32

LetStatement

A let statement

let x = 42;
let mut y: String = "hello".to_string();

ExpressionStatement

An expression used as a statement

x + 1; // Expression statement

BlockExpression

A block expression

{
    let x = 1;
    x + 2
}

IfExpression

An if expression

if x > 0 { "positive" } else { "non-positive" }

MatchExpression

A match expression

match x {
    1 => "one",
    2 => "two",
    _ => "other",
}

LoopExpression

A loop expression

loop {
    println!("infinite loop");
}

WhileExpression

A while loop

while x < 10 {
    x += 1;
}

ForExpression

A for loop

for item in collection {
    println!("{}", item);
}

IdentifierExpression

A variable or identifier expression

let name = x; // x is an identifier expression

LiteralExpression

A literal expression (any literal value)

let x = 42; // 42 is a literal expression

PathExpression

A path expression

std::collections::HashMap::new()

IntegerLiteral

An integer literal

42, -10, 0xFF, 0b1010

FloatLiteral

A floating-point literal

3.14, -2.5, 1e10

StringLiteral

A string literal

"hello", "world\n", r#"raw string"#

CharLiteral

A character literal

'a', '\n', '🦀'

BooleanLiteral

A boolean literal

true, false

ParenthesizedExpression

A parenthesized expression

(x + 1) * 2

TupleExpression

A tuple expression

(1, "hello", 3.14)

ArrayExpression

An array expression

[1, 2, 3, 4, 5]

StructExpression

A struct expression (struct instantiation)

Point { x: 1.0, y: 2.0 }

AssignmentExpression

An assignment expression

x = 42

CallExpression

A function call expression

println!("Hello!")

MethodCallExpression

A method call expression

string.trim().to_uppercase()

FieldExpression

A field access expression

point.x, user.name

IndexExpression

An index expression

array[0], vector[1..3]

ReturnExpression

A return expression

return 42;

BreakExpression

A break expression

break;
break 42;

ContinueExpression

A continue expression

continue;

Pattern

A pattern (used in match, let, etc.)

Some(x), Ok(value), Point { x, y }

MatchArm

A match arm

1 => "one", // pattern => expression

Type

A type annotation

i32, String, Vec<T>

PathType

A path type

std::collections::HashMap<K, V>

TupleType

A tuple type

(i32, String)

ArrayType

An array type

[i32; 10]

SliceType

A slice type

[i32], str

ReferenceType

A reference type

&str, &mut i32

PointerType

A raw pointer type

*const i32, *mut String

FunctionType

A function type

fn(i32) -> String

GenericParams

Generic parameters

fn example<T, U>(x: T) -> U
         ^^^^^^ generic parameters

GenericArgs

Generic arguments

Vec<i32>, Option<String>
    ^^^ generic arguments

WhereClause

A where clause

where T: Display + Clone, U: Debug

Attribute

An attribute

#[derive(Debug)]
#[inline]

Visibility

A visibility modifier

pub, pub(crate), private (no modifier)

Async

The async keyword

async fn example() {}

Unsafe

The unsafe keyword

unsafe fn example() {}

Extern

The extern keyword

extern "C" fn example();

Identifier

An identifier

variable_name, function_name, TypeName

Expression

A generic expression (catch-all for expressions)

Any expression that doesn't fit specific categories

BinaryExpression

A binary expression

x + y, a && b, count > 0

UnaryExpression

A unary expression

!flag, -number, *pointer

ItemStatement

An item used as a statement

fn nested() {}

ArgumentList

An argument list in function calls

example(1, "hello", true)

PubItem

A public item

pub struct PublicStruct;

Block

A block expression

{
    statements;
    expr
}

Error

Represents a syntax error in the parsed code

Invalid or unparseable syntax

Trait Implementations

impl Clone for RustElementType

fn clone(&self) -> RustElementType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RustElementType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RustElementType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ElementType for RustElementType

type Role = UniversalElementRole

The associated role type for this element kind.

fn is_root(&self) -> bool

Returns true if this element represents the root of the parsed tree.

fn is_error(&self) -> bool

Returns true if this element represents an error condition.

fn role(&self) -> UniversalElementRole

Returns the general syntactic role of this element.

fn is_role(&self, role: Self::Role) -> bool

Returns true if this element matches the specified language-specific role.

fn is_universal(&self, role: UniversalElementRole) -> bool

Returns true if this element matches the specified universal role.

impl From<RustTokenType> for RustElementType

fn from(token_type: RustTokenType) -> Self

Converts to this type from the input type.

impl Hash for RustElementType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RustElementType

fn eq(&self, other: &RustElementType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RustElementType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RustElementType

impl Eq for RustElementType

impl StructuralPartialEq for RustElementType