Trait cairo_lang_lowering::db::LoweringGroup

pub trait LoweringGroup: Database + HasQueryGroup<LoweringDatabase> + SemanticGroup + Upcast<dyn SemanticGroup> {
    // Required methods
    fn priv_function_with_body_lowered_structured(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Arc<FlatLowered>>;
    fn priv_inline_data(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Arc<PrivInlineData>>;
    fn priv_function_with_body_lowered_flat(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Arc<FlatLowered>>;
    fn priv_concrete_function_with_body_lowered_flat(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<Arc<FlatLowered>>;
    fn concrete_function_with_body_lowered(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<Arc<FlatLowered>>;
    fn concrete_function_with_body_direct_callees(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<Vec<ConcreteFunction>>;
    fn concrete_function_with_body_direct_callees_with_body(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<Vec<ConcreteFunctionWithBodyId>>;
    fn function_with_body_lowering_diagnostics(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Arc<Diagnostics<LoweringDiagnostic>>>;
    fn module_lowering_diagnostics(
        &self,
        key0: ModuleId
    ) -> Maybe<Diagnostics<LoweringDiagnostic>>;
    fn file_lowering_diagnostics(
        &self,
        key0: FileId
    ) -> Maybe<Diagnostics<LoweringDiagnostic>>;
    fn function_scc_explicit_implicits(
        &self,
        key0: ConcreteSCCRepresentative
    ) -> Maybe<HashSet<TypeId>>;
    fn function_all_implicits(&self, key0: FunctionId) -> Maybe<Vec<TypeId>>;
    fn concrete_function_with_body_all_implicits(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<HashSet<TypeId>>;
    fn concrete_function_with_body_all_implicits_vec(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<Vec<TypeId>>;
    fn implicit_precedence(&self) -> Arc<Vec<TypeId>>;
    fn set_implicit_precedence(&mut self, value__: Arc<Vec<TypeId>>);
    fn set_implicit_precedence_with_durability(
        &mut self,
        value__: Arc<Vec<TypeId>>,
        durability__: Durability
    );
    fn function_may_panic(&self, key0: FunctionId) -> Maybe<bool>;
    fn function_with_body_may_panic(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<bool>;
    fn concrete_function_with_body_scc_representative(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> ConcreteSCCRepresentative;
    fn concrete_function_with_body_scc(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Vec<ConcreteFunctionWithBodyId> ;
    fn function_scc_representative(
        &self,
        key0: FunctionWithBodyId
    ) -> SCCRepresentative;
    fn function_with_body_scc(
        &self,
        key0: FunctionWithBodyId
    ) -> Vec<FunctionWithBodyId> ;
    fn function_with_body_feedback_set(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> Maybe<HashSet<ConcreteFunctionWithBodyId>>;
    fn priv_function_with_body_feedback_set_of_representative(
        &self,
        key0: ConcreteSCCRepresentative
    ) -> Maybe<HashSet<ConcreteFunctionWithBodyId>>;
}

Required Methods

fn priv_function_with_body_lowered_structured( &self, key0: FunctionWithBodyId ) -> Maybe<Arc<FlatLowered>>

Computes the lowered representation of a function with a body.

fn priv_inline_data( &self, key0: FunctionWithBodyId ) -> Maybe<Arc<PrivInlineData>>

fn priv_function_with_body_lowered_flat( &self, key0: FunctionWithBodyId ) -> Maybe<Arc<FlatLowered>>

Computes the lowered representation of a function with a body.

fn priv_concrete_function_with_body_lowered_flat( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<Arc<FlatLowered>>

A concrete version of priv_function_with_body_lowered_flat

fn concrete_function_with_body_lowered( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<Arc<FlatLowered>>

Computes the final lowered representation (after all the internal transformations).

fn concrete_function_with_body_direct_callees( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<Vec<ConcreteFunction>>

Returns the set of direct callees of a concrete function with a body.

fn concrete_function_with_body_direct_callees_with_body( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<Vec<ConcreteFunctionWithBodyId>>

Returns the set of direct callees which are functions with body of a concrete function with a body (i.e. excluding libfunc callees).

fn function_with_body_lowering_diagnostics( &self, key0: FunctionWithBodyId ) -> Maybe<Arc<Diagnostics<LoweringDiagnostic>>>

Aggregates function level semantic diagnostics.

fn module_lowering_diagnostics( &self, key0: ModuleId ) -> Maybe<Diagnostics<LoweringDiagnostic>>

Aggregates module level semantic diagnostics.

fn file_lowering_diagnostics( &self, key0: FileId ) -> Maybe<Diagnostics<LoweringDiagnostic>>

Aggregates file level lowering diagnostics.

fn function_scc_explicit_implicits( &self, key0: ConcreteSCCRepresentative ) -> Maybe<HashSet<TypeId>>

Returns the explicit implicits required by all the functions in the SCC of this function. These are all the implicit parameters that are explicitly declared in the functions of the given function’s SCC.

For better caching, this function should be called only with the representative of the SCC.

fn function_all_implicits(&self, key0: FunctionId) -> Maybe<Vec<TypeId>>

Returns all the implicit parameters that the function requires (according to both its signature and the functions it calls). The items in the returned vector are unique and the order is consistent, but not necessarily related to the order of the explicit implicits in the signature of the function.

fn concrete_function_with_body_all_implicits( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<HashSet<TypeId>>

Returns all the implicit parameters that a concrete function with a body requires (according to both its signature and the functions it calls).

fn concrete_function_with_body_all_implicits_vec( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<Vec<TypeId>>

Returns all the implicit parameters that a function with a body requires (according to both its signature and the functions it calls). The items in the returned vector are unique and the order is consistent, but not necessarily related to the order of the explicit implicits in the signature of the function.

fn implicit_precedence(&self) -> Arc<Vec<TypeId>>

An array that sets the precedence of implicit types.

fn set_implicit_precedence(&mut self, value__: Arc<Vec<TypeId>>)

Set the value of the implicit_precedence input.

See implicit_precedence for details.

Note: Setting values will trigger cancellation of any ongoing queries; this method blocks until those queries have been cancelled.

fn set_implicit_precedence_with_durability( &mut self, value__: Arc<Vec<TypeId>>, durability__: Durability )

Set the value of the implicit_precedence input and promise that its value will never change again.

See implicit_precedence for details.

Note: Setting values will trigger cancellation of any ongoing queries; this method blocks until those queries have been cancelled.

fn function_may_panic(&self, key0: FunctionId) -> Maybe<bool>

Returns whether the function may panic.

fn function_with_body_may_panic(&self, key0: FunctionWithBodyId) -> Maybe<bool>

Returns whether the function may panic.

fn concrete_function_with_body_scc_representative( &self, key0: ConcreteFunctionWithBodyId ) -> ConcreteSCCRepresentative

Returns the representative of the concrete function’s strongly connected component. The representative is consistently chosen for all the concrete functions in the same SCC.

fn concrete_function_with_body_scc( &self, key0: ConcreteFunctionWithBodyId ) -> Vec<ConcreteFunctionWithBodyId>

Returns all the concrete functions in the same strongly connected component as the given concrete function.

fn function_scc_representative( &self, key0: FunctionWithBodyId ) -> SCCRepresentative

Returns the representative of the function’s strongly connected component. The representative is consistently chosen for all the functions in the same SCC.

fn function_with_body_scc( &self, key0: FunctionWithBodyId ) -> Vec<FunctionWithBodyId>

Returns all the functions in the same strongly connected component as the given function.

fn function_with_body_feedback_set( &self, key0: ConcreteFunctionWithBodyId ) -> Maybe<HashSet<ConcreteFunctionWithBodyId>>

Returns the feedback-vertex-set of the given concrete function. A feedback-vertex-set is the set of vertices whose removal leaves a graph without cycles.

fn priv_function_with_body_feedback_set_of_representative( &self, key0: ConcreteSCCRepresentative ) -> Maybe<HashSet<ConcreteFunctionWithBodyId>>

Returns the feedback-vertex-set of the given concrete-function SCC-representative. A feedback-vertex-set is the set of vertices whose removal leaves a graph without cycles.

Implementors

impl<DB> LoweringGroup for DBwhere DB: SemanticGroup + Upcast<dyn SemanticGroup> + Database + HasQueryGroup<LoweringDatabase>,