Enum ra_ap_hir::term_search::Expr

pub enum Expr {
    Const(Const),
    Static(Static),
    Local(Local),
    ConstParam(ConstParam),
    FamousType {
        ty: Type,
        value: &'static str,
    },
    Function {
        func: Function,
        generics: Vec<Type>,
        params: Vec<Expr>,
    },
    Method {
        func: Function,
        generics: Vec<Type>,
        target: Box<Expr>,
        params: Vec<Expr>,
    },
    Variant {
        variant: Variant,
        generics: Vec<Type>,
        params: Vec<Expr>,
    },
    Struct {
        strukt: Struct,
        generics: Vec<Type>,
        params: Vec<Expr>,
    },
    Tuple {
        ty: Type,
        params: Vec<Expr>,
    },
    Field {
        expr: Box<Expr>,
        field: Field,
    },
    Reference(Box<Expr>),
    Many(Type),
}

Type tree shows how can we get from set of types to some type.

Consider the following code as an example

fn foo(x: i32, y: bool) -> Option<i32> { None }
fn bar() {
   let a = 1;
   let b = true;
   let c: Option<i32> = _;
}

If we generate type tree in the place of _ we get

      Option<i32>
          |
    foo(i32, bool)
     /        \
 a: i32      b: bool

So in short it pretty much gives us a way to get type Option<i32> using the items we have in scope.

Variants

Const(Const)

Constant

Static(Static)

Static variable

Local(Local)

Local variable

ConstParam(ConstParam)

Constant generic parameter

FamousType

Fields

ty: Type

value: &'static str

Well known type (such as true for bool)

Function

Fields

func: Function

generics: Vec<Type>

params: Vec<Expr>

Function call (does not take self param)

Method

Fields

func: Function

generics: Vec<Type>

target: Box<Expr>

params: Vec<Expr>

Method call (has self param)

Variant

Fields

variant: Variant

generics: Vec<Type>

params: Vec<Expr>

Enum variant construction

Struct

Fields

strukt: Struct

generics: Vec<Type>

params: Vec<Expr>

Struct construction

Tuple

Fields

ty: Type

params: Vec<Expr>

Tuple construction

Field

Fields

expr: Box<Expr>

field: Field

Struct field access

Reference(Box<Expr>)

Passing type as reference (with &)

Many(Type)

Indicates possibility of many different options that all evaluate to ty

Implementations

impl Expr

pub fn gen_source_code( &self, sema_scope: &SemanticsScope<'_>, many_formatter: &mut dyn FnMut(&Type) -> String, prefer_no_std: bool, prefer_prelude: bool ) -> Result<String, DisplaySourceCodeError>

Generate source code for type tree.

Note that trait imports are not added to generated code. To make sure that the code is valid, callee has to also ensure that all the traits listed by traits_used method are also imported.

pub fn ty(&self, db: &dyn HirDatabase) -> Type

Get type of the type tree.

Same as getting the type of root node

pub fn traits_used(&self, db: &dyn HirDatabase) -> Vec<Trait>

List the traits used in type tree

pub fn is_many(&self) -> bool

Helper function to check if outermost type tree is Expr::Many variant

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Hash for Expr

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 Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Expr

impl StructuralPartialEq for Expr