public FunctionDefinition GetFunctionBySignature(ContractDefinition contract, string signature)
{
foreach (FunctionDefinition funcDef in ContractToFunctionsMap[contract])
{
if (TransUtils.ComputeFunctionSignature(funcDef).Equals(signature))
{
return(funcDef);
}
}
Debug.Assert(false, $"Cannot find function signature: {signature}");
return(null);
}
private void ResolveFunctions()
{
ResolutionHelper resolutionHelper = new ResolutionHelper(context);
List <ContractDefinition> sortedContracts = resolutionHelper.TopologicalSortByDependency(context.ContractDefinitions);
foreach (ContractDefinition contract in sortedContracts)
{
// create a deep copy
List <int> linearizedBaseContractIds = new List <int>(contract.LinearizedBaseContracts);
linearizedBaseContractIds.Reverse();
foreach (int id in linearizedBaseContractIds)
{
ContractDefinition baseContract = context.GetASTNodeById(id) as ContractDefinition;
Debug.Assert(baseContract != null);
if (baseContract == contract)
{
HashSet <FunctionDefinition> functions = context.GetFuncDefintionsInContract(contract);
foreach (FunctionDefinition function in functions)
{
string signature = TransUtils.ComputeFunctionSignature(function);
context.AddFunctionToDynamicType(signature, contract, function);
}
}
else
{
HashSet <FunctionDefinition> functions = context.GetFuncDefintionsInContract(baseContract);
foreach (FunctionDefinition function in functions)
{
if (function.Visibility == EnumVisibility.PRIVATE)
{
continue;
}
string signature = TransUtils.ComputeFunctionSignature(function);
context.AddFunctionToDynamicType(signature, contract, function);
}
// Events
// TODO: Do we need to lookup by signature?
HashSet <EventDefinition> events = context.GetEventDefintionsInContract(baseContract);
foreach (var evt in events)
{
context.AddEventToContract(contract, evt);
}
}
}
}
// PrintFunctionResolutionMap();
}
public void AddFunctionToContract(ContractDefinition contract, FunctionDefinition funcDef)
{
if (!ContractToFunctionsMap.ContainsKey(contract))
{
Debug.Assert(!ContractToFuncSigsMap.ContainsKey(contract));
ContractToFunctionsMap[contract] = new HashSet <FunctionDefinition>();
ContractToFuncSigsMap[contract] = new HashSet <string>();
}
Debug.Assert(!ContractToFunctionsMap[contract].Contains(funcDef), $"Duplicated function definition: {funcDef.Name}");
ContractToFunctionsMap[contract].Add(funcDef);
string signature = TransUtils.ComputeFunctionSignature(funcDef);
Debug.Assert(!ContractToFuncSigsMap[contract].Contains(signature), $"Duplicated function signature: {signature}");
ContractToFuncSigsMap[contract].Add(signature);
Debug.Assert(!FunctionToContractMap.ContainsKey(funcDef), $"Duplicated function: {funcDef.Name}");
FunctionToContractMap[funcDef] = contract;
}
