public ValidEvents AnalyzeAssignmentExprSyntax(IEnumerable <CryptoSignature> cryptoMethods, CryslJsonModel cryslModel, SyntaxNodeAnalysisContext context, ISymbol leftExprSymbol)
{
ValidEvents validEvents = new ValidEvents();
MethodSignatureModel methodSignatureModel = new MethodSignatureModel
{
MethodName = leftExprSymbol.Name.ToString()
};
List <MethodSignatureModel> methodSignatureModelsList = new List <MethodSignatureModel>();
methodSignatureModelsList.Add(methodSignatureModel);
//Iterate through all the satisfied crypto signatures
foreach (var cryptoMethod in cryptoMethods)
{
Dictionary <string, List <MethodSignatureModel> > validEventsDict = new Dictionary <string, List <MethodSignatureModel> >();
validEventsDict.Add(cryptoMethod.Event_Var_Name, methodSignatureModelsList);
validEvents.IsValidEvent = true;
validEvents.AggregatorName = cryptoMethod.Event_Var_Name;
validEvents.ValidEventsDict = validEventsDict;
if (cryptoMethod.Is_property)
{
validEvents.IsProperty = true;
validEvents.PropertyName = cryptoMethod.Object_variable;
}
}
return(validEvents);
}
/// <summary>
/// Analyze thr MemberAcessExpressionSyntax Nodes
/// </summary>
/// <param name="memberAccessExpressions"></param>
/// <param name="cryslData"></param>
/// <param name="context"></param>
/// <returns></returns>
public ValidEvents AnalyzeMemAccessExprSyntax(IdentifierNameSyntax identifier, IEnumerable <CryptoSignature> cryptoMethods, Methods methods, CryslJsonModel cryslData, SyntaxNodeAnalysisContext context, IMethodSymbol identifierSymbolInfo, TextSpan nodeSPan)
{
ValidEvents validEvents = new ValidEvents();
// Check for valid event only if Identifier is of Spec type in Crysl.
if (identifierSymbolInfo.ReturnType.ToString().Equals(cryslData.Spec_Section.Class_Name))
{
List <MethodSignatureModel> methodSignatureModelsList = new List <MethodSignatureModel>();
foreach (var method in cryptoMethods)
{
ICommonUtilities commonUtilities = serviceProvider.GetService <ICommonUtilities>();
//Check if the Event is Valid
bool isValidEvent = commonUtilities.IsMethodInEvents(method, identifierSymbolInfo, cryslData.Object_Section.Objects_Declaration);
if (isValidEvent)
{
MethodSignatureModel currentValidEvent = new MethodSignatureModel
{
MethodName = identifierSymbolInfo.Name,
Parameters = method.Argument_types,
};
methodSignatureModelsList.Add(currentValidEvent);
//Go to the Containing Method Declaration Node
var containingMethodDeclarationNode = identifier.FirstAncestorOrSelf <MethodDeclarationSyntax>();
var invExprSyntaxWalker = new InvocationExpressionSyntaxWalker(cryslData, context, nodeSPan);
//Walk through the current method to find all invocations of the given type
invExprSyntaxWalker.Visit(containingMethodDeclarationNode);
Dictionary <string, List <MethodSignatureModel> > validEventsDict = invExprSyntaxWalker.GetMethodsList();
if (!validEventsDict.ContainsKey(method.Event_Var_Name))
{
validEventsDict.Add(method.Event_Var_Name, methodSignatureModelsList);
}
//If there are two events of same type
else if (validEventsDict.ContainsKey(method.Event_Var_Name))
{
foreach (var methodSig in validEventsDict.Values)
{
methodSignatureModelsList.AddRange(methodSig);
}
validEventsDict[method.Event_Var_Name] = methodSignatureModelsList;
}
//Check if the Aggregator Condition Satisfies
bool isAggregatorCondition = commonUtilities.CheckAggregator(validEventsDict, methods.Aggregator.Aggregators);
if (isAggregatorCondition)
{
validEvents.IsValidEvent = true;
validEvents.ValidEventsDict = validEventsDict;
validEvents.AggregatorName = methods.Aggregator.Aggregator_Name;
}
else
{
validEvents.IsValidEvent = false;
}
return(validEvents);
}
}
}
validEvents.IsValidEvent = false;
return(validEvents);
}
/// <summary>
/// Visit InvocationExpressions for a Given MethodDeclarationSyntax Node.
/// </summary>
/// <param name="invocationExpressionNode"></param>
/// <returns></returns>
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (!node.Span.Equals(nodeLocation))
{
var identifierNode = node.ChildNodes().OfType <IdentifierNameSyntax>();
foreach (var identifier in identifierNode)
{
var result = _cryslSpecificationModel.Event_Section.Methods.Select(x => x.Crypto_Signature
.Where(y => y.Method_Name.ToString().Equals(identifier.Identifier.Value.ToString())));
foreach (var methods in _cryslSpecificationModel.Event_Section.Methods)
{
// Check if method signature matches with the method signature defined in events section of the Crysl.
var cryptoMethods = methods.Crypto_Signature.Select(y => y).Where(x => x.Method_Name.ToString().Equals(identifier.Identifier.Value.ToString()));
if (cryptoMethods.Count() > 0)
{
if (_context.SemanticModel.GetSymbolInfo(identifier).Symbol.Kind.Equals(SymbolKind.Method))
{
var identifierSymbolInfo = (IMethodSymbol)_context.SemanticModel.GetSymbolInfo(identifier).Symbol;
// Check for valid event only if Identifier is of Spec type in Crysl.
if (identifierSymbolInfo.ReturnType.ToString().Equals(_cryslSpecificationModel.Spec_Section.Class_Name))
{
List <MethodSignatureModel> methodSignatureModelsList = new List <MethodSignatureModel>();
foreach (var method in cryptoMethods)
{
ICommonUtilities commonUtilities = serviceProvider.GetService <ICommonUtilities>();
bool isValidEvent = commonUtilities.IsMethodInEvents(method, identifierSymbolInfo, _cryslSpecificationModel.Object_Section.Objects_Declaration);
if (isValidEvent)
{
MethodSignatureModel methodSignatureModel = new MethodSignatureModel
{
MethodName = identifierSymbolInfo.Name,
Parameters = method.Argument_types
};
methodSignatureModelsList.Add(methodSignatureModel);
if (!methodSignatureDict.ContainsKey(method.Event_Var_Name))
{
methodSignatureDict.Add(method.Event_Var_Name, methodSignatureModelsList);
}
else
{
methodSignatureDict[method.Event_Var_Name] = methodSignatureModelsList;
}
/*methodSignatureList.Add(method.Event_Var_Name, new MethodSignatureModel
* {
* MethodName = identifierSymbolInfo.Name,
* Parameters = method.Argument_types
* });*/
}
}
}
}
}
}
}
}
}
