Struct clarity_repl::clarity::analysis::type_checker::contexts::ContractContext

pub struct ContractContext {
    pub implemented_traits: HashSet<TraitIdentifier>,
    // some fields omitted
}

Fields

implemented_traits: HashSet<TraitIdentifier>

Implementations

impl ContractContext

pub fn new() -> ContractContext

pub fn check_name_used(&self, name: &str) -> CheckResult<()>

pub fn ft_exists(&self, name: &str) -> bool

pub fn get_nft_type(&self, name: &str) -> Option<&TypeSignature>

pub fn add_public_function_type(
    &mut self,
    name: ClarityName,
    func_type: FunctionType
) -> CheckResult<()>

pub fn add_read_only_function_type(
    &mut self,
    name: ClarityName,
    func_type: FunctionType
) -> CheckResult<()>

pub fn add_private_function_type(
    &mut self,
    name: ClarityName,
    func_type: FunctionType
) -> CheckResult<()>

pub fn add_map_type(
    &mut self,
    map_name: ClarityName,
    map_type: (TypeSignature, TypeSignature)
) -> CheckResult<()>

pub fn add_variable_type(
    &mut self,
    const_name: ClarityName,
    var_type: TypeSignature
) -> CheckResult<()>

pub fn add_persisted_variable_type(
    &mut self,
    var_name: ClarityName,
    var_type: TypeSignature
) -> CheckResult<()>

pub fn add_ft(&mut self, token_name: ClarityName) -> CheckResult<()>

pub fn add_nft(
    &mut self,
    token_name: ClarityName,
    token_type: TypeSignature
) -> CheckResult<()>

pub fn add_trait(
    &mut self,
    trait_name: ClarityName,
    trait_signature: BTreeMap<ClarityName, FunctionSignature>
) -> CheckResult<()>

pub fn add_implemented_trait(
    &mut self,
    trait_identifier: TraitIdentifier
) -> CheckResult<()>

pub fn get_trait(
    &self,
    trait_name: &str
) -> Option<&BTreeMap<ClarityName, FunctionSignature>>

pub fn get_map_type(
    &self,
    map_name: &str
) -> Option<&(TypeSignature, TypeSignature)>

pub fn get_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_persisted_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_function_type(&self, name: &str) -> Option<&FunctionType>

pub fn into_contract_analysis(self, contract_analysis: &mut ContractAnalysis)

This function consumes the ContractContext, and puts the relevant information into the provided ContractAnalysis