Struct rustc_typeck::check::FnCtxt

pub struct FnCtxt<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
    // some fields omitted
}

Unstable (rustc_private)

Methods

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn check_match(&self, expr: &'gcx Expr, discrim: &'gcx Expr, arms: &'gcx [Arm], expected: Expectation<'tcx>, match_src: MatchSource)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn resolve_type_vars_in_expr(&self, e: &Expr)

fn resolve_type_vars_in_fn(&self, decl: &FnDecl, blk: &Block)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn regionck_expr(&self, e: &Expr)

fn regionck_item(&self, item_id: NodeId, span: Span, wf_tys: &[Ty<'tcx>])

Unstable (rustc_private)

Region checking during the WF phase for items. wf_tys are the types from which we should derive implied bounds, if any.

fn regionck_fn(&self, fn_id: NodeId, fn_span: Span, decl: &FnDecl, blk: &Block)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn try_coerce(&self, expr: &Expr, target: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>

Unstable (rustc_private)

Attempt to coerce an expression to a type, and return the adjusted type of the expression, if successful. Adjustments are only recorded if the coercion succeeded. The expressions must not have any pre-existing adjustments.

fn try_find_coercion_lub<'b, E, I>(&self, origin: TypeOrigin, exprs: E, prev_ty: Ty<'tcx>, new: &'b Expr) -> RelateResult<'tcx, Ty<'tcx>> where E: Fn() -> I, I: IntoIterator<Item=&'b Expr>

Unstable (rustc_private)

Given some expressions, their known unified type and another expression, tries to unify the types, potentially inserting coercions on any of the provided expressions and returns their LUB (aka "common supertype").

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>)

fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>)

fn demand_coerce(&self, expr: &Expr, expected: Ty<'tcx>)

fn require_same_types(&self, span: Span, t1: Ty<'tcx>, t2: Ty<'tcx>, msg: &str) -> bool

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn confirm_method(&self, span: Span, self_expr: &'gcx Expr, call_expr: &'gcx Expr, unadjusted_self_ty: Ty<'tcx>, pick: Pick<'tcx>, supplied_method_types: Vec<Ty<'tcx>>) -> MethodCallee<'tcx>

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn probe_method(&self, span: Span, mode: Mode, item_name: Name, self_ty: Ty<'tcx>, scope_expr_id: NodeId) -> PickResult<'tcx>

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn report_method_error(&self, span: Span, rcvr_ty: Ty<'tcx>, item_name: Name, rcvr_expr: Option<&Expr>, error: MethodError<'tcx>)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn method_exists(&self, span: Span, method_name: Name, self_ty: Ty<'tcx>, call_expr_id: NodeId, allow_private: bool) -> bool

Unstable (rustc_private)

Determines whether the type self_ty supports a method name method_name or not.

fn lookup_method(&self, span: Span, method_name: Name, self_ty: Ty<'tcx>, supplied_method_types: Vec<Ty<'tcx>>, call_expr: &'gcx Expr, self_expr: &'gcx Expr) -> Result<MethodCallee<'tcx>, MethodError<'tcx>>

Unstable (rustc_private)

Performs method lookup. If lookup is successful, it will return the callee and store an appropriate adjustment for the self-expr. In some cases it may report an error (e.g., invoking the drop method).

Arguments

Given a method call like foo.bar::<T1,...Tn>(...):

• fcx: the surrounding FnCtxt (!)
• span: the span for the method call
• method_name: the name of the method being called (bar)
• self_ty: the (unadjusted) type of the self expression (foo)
• supplied_method_types: the explicit method type parameters, if any (T1..Tn)
• self_expr: the self expression (foo)

fn lookup_method_in_trait(&self, span: Span, self_expr: Option<&Expr>, m_name: Name, trait_def_id: DefId, self_ty: Ty<'tcx>, opt_input_types: Option<Vec<Ty<'tcx>>>) -> Option<MethodCallee<'tcx>>

fn lookup_method_in_trait_adjusted(&self, span: Span, self_expr: Option<&Expr>, m_name: Name, trait_def_id: DefId, autoderefs: usize, unsize: bool, self_ty: Ty<'tcx>, opt_input_types: Option<Vec<Ty<'tcx>>>) -> Option<MethodCallee<'tcx>>

Unstable (rustc_private)

lookup_in_trait_adjusted is used for overloaded operators. It does a very narrow slice of what the normal probe/confirm path does. In particular, it doesn't really do any probing: it simply constructs an obligation for aparticular trait with the given self-type and checks whether that trait is implemented.

FIXME(#18741) -- It seems likely that we can consolidate some of this code with the other method-lookup code. In particular, autoderef on index is basically identical to autoderef with normal probes, except that the test also looks for built-in indexing. Also, the second half of this method is basically the same as confirmation.

fn resolve_ufcs(&self, span: Span, method_name: Name, self_ty: Ty<'tcx>, expr_id: NodeId) -> Result<Def, MethodError<'tcx>>

fn trait_item(&self, trait_def_id: DefId, item_name: Name) -> Option<ImplOrTraitItem<'tcx>>

Unstable (rustc_private)

Find item with name item_name defined in trait_def_id and return it, or None, if no such item.

fn impl_item(&self, impl_def_id: DefId, item_name: Name) -> Option<ImplOrTraitItem<'tcx>>

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn closure_analyze_fn(&self, body: &Block)

fn closure_analyze_const(&self, body: &Expr)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn check_expr_closure(&self, expr: &Expr, _capture: CaptureClause, decl: &'gcx FnDecl, body: &'gcx Block, expected: Expectation<'tcx>)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn check_call(&self, call_expr: &'gcx Expr, callee_expr: &'gcx Expr, arg_exprs: &'gcx [P<Expr>], expected: Expectation<'tcx>)

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn check_binop_assign(&self, expr: &'gcx Expr, op: BinOp, lhs_expr: &'gcx Expr, rhs_expr: &'gcx Expr)

Unstable (rustc_private)

Check a a <op>= b

fn check_binop(&self, expr: &'gcx Expr, op: BinOp, lhs_expr: &'gcx Expr, rhs_expr: &'gcx Expr)

Unstable (rustc_private)

Check a potentially overloaded binary operator.

fn check_user_unop(&self, op_str: &str, mname: &str, trait_did: Option<DefId>, ex: &'gcx Expr, operand_expr: &'gcx Expr, operand_ty: Ty<'tcx>, op: UnOp) -> Ty<'tcx>

impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx>

fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>, rty: FnOutput<'tcx>, body_id: NodeId) -> FnCtxt<'a, 'gcx, 'tcx>

fn param_env(&self) -> &ParameterEnvironment<'tcx>

fn sess(&self) -> &Session

fn err_count_since_creation(&self) -> usize

fn tag(&self) -> String

fn local_ty(&self, span: Span, nid: NodeId) -> Ty<'tcx>

fn write_ty(&self, node_id: NodeId, ty: Ty<'tcx>)

fn write_substs(&self, node_id: NodeId, substs: ItemSubsts<'tcx>)

fn write_autoderef_adjustment(&self, node_id: NodeId, derefs: usize)

fn write_adjustment(&self, node_id: NodeId, adj: AutoAdjustment<'tcx>)

fn instantiate_type(&self, did: DefId, path: &Path) -> Ty<'tcx>

Unstable (rustc_private)

Instantiates the type in did with the generics in path and returns it (registering the necessary trait obligations along the way).

Note that this function is only intended to be used with type-paths, not with value-paths.

fn def_struct_variant(&self, def: Def, _span: Span) -> Option<(AdtDef<'tcx>, VariantDef<'tcx>)>

Unstable (rustc_private)

Return the dict-like variant corresponding to a given Def.

fn write_nil(&self, node_id: NodeId)

fn write_error(&self, node_id: NodeId)

fn require_type_meets(&self, ty: Ty<'tcx>, span: Span, code: ObligationCauseCode<'tcx>, bound: BuiltinBound)

fn require_type_is_sized(&self, ty: Ty<'tcx>, span: Span, code: ObligationCauseCode<'tcx>)

fn require_expr_have_sized_type(&self, expr: &Expr, code: ObligationCauseCode<'tcx>)

fn register_builtin_bound(&self, ty: Ty<'tcx>, builtin_bound: BuiltinBound, cause: ObligationCause<'tcx>)

fn register_predicate(&self, obligation: PredicateObligation<'tcx>)

fn to_ty(&self, ast_t: &Ty) -> Ty<'tcx>

fn expr_ty(&self, ex: &Expr) -> Ty<'tcx>

fn adjust_expr_ty(&self, expr: &Expr, adjustment: Option<&AutoAdjustment<'tcx>>) -> Ty<'tcx>

Unstable (rustc_private)

Apply adjustment to the type of expr

fn node_ty(&self, id: NodeId) -> Ty<'tcx>

fn item_substs(&self) -> Ref<NodeMap<ItemSubsts<'tcx>>>

fn opt_node_ty_substs<F>(&self, id: NodeId, f: F) where F: FnOnce(&ItemSubsts<'tcx>)

fn register_region_obligation(&self, ty: Ty<'tcx>, region: Region, cause: ObligationCause<'tcx>)

Unstable (rustc_private)

Registers an obligation for checking later, during regionck, that the type ty must outlive the region r.

fn register_wf_obligation(&self, ty: Ty<'tcx>, span: Span, code: ObligationCauseCode<'tcx>)

Unstable (rustc_private)

Registers an obligation for checking later, during regionck, that the type ty must outlive the region r.

fn register_old_wf_obligation(&self, ty: Ty<'tcx>, span: Span, code: ObligationCauseCode<'tcx>)

fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &Expr)

Unstable (rustc_private)

Registers obligations that all types appearing in substs are well-formed.

fn add_obligations_for_parameters(&self, cause: ObligationCause<'tcx>, predicates: &InstantiatedPredicates<'tcx>)

Unstable (rustc_private)

Given a fully substituted set of bounds (generic_bounds), and the values with which each type/region parameter was instantiated (substs), creates and registers suitable trait/region obligations.

For example, if there is a function:

fn foo<'a,T:'a>(...)

and a reference:

let f = foo;

Then we will create a fresh region variable '$0 and a fresh type variable $1 for 'a and T. This routine will add a region obligation $1:'$0 and register it locally.

fn field_ty(&self, span: Span, field: FieldDef<'tcx>, substs: &Substs<'tcx>) -> Ty<'tcx>

fn autoderef<'b, E, I, T, F>(&self, sp: Span, base_ty: Ty<'tcx>, maybe_exprs: E, unresolved_type_action: UnresolvedTypeAction, lvalue_pref: LvaluePreference, should_stop: F) -> (Ty<'tcx>, usize, Option<T>) where E: Fn() -> I, I: IntoIterator<Item=&'b Expr>, F: FnMut(Ty<'tcx>, usize) -> Option<T>

Unstable (rustc_private)

Executes an autoderef loop for the type t. At each step, invokes should_stop to decide whether to terminate the loop. Returns the final type and number of derefs that it performed.

Note: this method does not modify the adjustments table. The caller is responsible for inserting an AutoAdjustment record into the self using one of the suitable methods.

fn check_expr_has_type(&self, expr: &'gcx Expr, expected: Ty<'tcx>)

fn impl_self_ty(&self, span: Span, did: DefId) -> TypeAndSubsts<'tcx>

fn resolve_ty_and_def_ufcs<'b>(&self, path_res: PathResolution, opt_self_ty: Option<Ty<'tcx>>, path: &'b Path, span: Span, node_id: NodeId) -> Option<(Option<Ty<'tcx>>, &'b [PathSegment], Def)>

fn check_decl_initializer(&self, local: &'gcx Local, init: &'gcx Expr)

fn check_decl_local(&self, local: &'gcx Local)

fn check_stmt(&self, stmt: &'gcx Stmt)

fn check_block_no_value(&self, blk: &'gcx Block)

fn instantiate_path(&self, segments: &[PathSegment], type_scheme: TypeScheme<'tcx>, type_predicates: &GenericPredicates<'tcx>, opt_self_ty: Option<Ty<'tcx>>, def: Def, span: Span, node_id: NodeId)

fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx>

Trait Implementations

impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx>

type Target = Inherited<'a, 'gcx, 'tcx>

The resulting type after dereferencing

fn deref(&self) -> &Self::Target

The method called to dereference a value

Derived Implementations

impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> Clone for FnCtxt<'a, 'gcx, 'tcx>

fn clone(&self) -> FnCtxt<'a, 'gcx, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.