/// <summary>
/// </summary>
/// <param name="node"></param>
/// <param name="crossEdgeFiller"></param>
public static void CreateMethodCallEdgeFromIdentifier(IdentifierNameSyntax node,
CrossEdgeFiller crossEdgeFiller)
{
CreateMethodCallFromExpression(node.GetParent <BinaryExpressionSyntax>( ), ExpressionKind.BinaryExpression,
crossEdgeFiller);
CreateMethodCallFromExpression(node.GetParent <PostfixUnaryExpressionSyntax>( ),
ExpressionKind.PostfixUnaryExpression, crossEdgeFiller);
CreateMethodCallFromExpression(node.GetParent <PrefixUnaryExpressionSyntax>( ),
ExpressionKind.PrefixUnaryExpression, crossEdgeFiller);
CreateMethodCallFromExpression(node.GetParent <AssignmentExpressionSyntax>( ),
ExpressionKind.AssigmentExpression, crossEdgeFiller);
}
/// <summary>
/// In this section it'll be create:
/// - MethodCall edge from identifier
/// - AttributeAccess edge from identifier
/// - Uses edge from identifier
/// These edges add to the acutal method from the MethodStack
/// </summary>
/// <param name="node"></param>
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
if (MainDeclaration.Instance.MethodStack.Count <= 0)
{
return;
}
if (node.IsParent <ParameterSyntax>( ))
{
return;
}
if (node.Identifier.Text != Constants.VAR && node.Identifier.Text != Constants.DYNAMIC)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetSymbolInfo(node).Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
if (symbol != null)
{
switch (symbol.Kind)
{
case SymbolKind.Method:
if (!symbol.IsInMetadata( ) &&
(node.IsParent <InvocationExpressionSyntax, AssignmentExpressionSyntax>( ) ||
node.IsParent <InvocationExpressionSyntax, ArgumentSyntax>( )))
{
SyntaxNode dec;
var methodDef = symbol.GetDefinition(out dec);
_crossEdgeFiller.DeclarationFiller(( CSharpSyntaxNode )dec, node);
if (methodDef != null && methodDef.Kind == symbol.Kind)
{
MainDeclaration.Instance.UsesStack.Peek( )
.Add(methodDef.ContainingType.GetLimType( ).Id);
}
}
break;
case SymbolKind.Field:
EdgeBuilder.CreateAttributeAccessEdge(node, symbol);
break;
case SymbolKind.Local:
case SymbolKind.Parameter:
if (node.IsParent <ParameterListSyntax>( ))
{
return;
}
if (node.Identifier.Text == Constants.VALUE)
{
return;
}
if (!symbol.IsInMetadata( ))
{
MainDeclaration.Instance.RoslynWatch.Start( );
var iConversaitonOpOverLoad = MainDeclaration.Instance.Model.GetConversion(node);
MainDeclaration.Instance.RoslynWatch.Stop( );
if (iConversaitonOpOverLoad.MethodSymbol != null)
{
if (iConversaitonOpOverLoad.MethodSymbol.IsInMetadata( ))
{
EdgeBuilder.CreateMethodCallEdge(symbol.ContainingSymbol,
iConversaitonOpOverLoad.MethodSymbol,
MainDeclaration.Instance.LimFactory.setFiltered);
}
else
{
SyntaxNode _tmp;
var calledSymbol = iConversaitonOpOverLoad.MethodSymbol.GetDefinition(
out _tmp, true);
EdgeBuilder.CreateMethodCallEdge(symbol.ContainingSymbol, calledSymbol);
}
}
var declaration = symbol.DeclaringSyntaxReferences[0].GetSyntax( );
_crossEdgeFiller.DeclarationFiller(( CSharpSyntaxNode )declaration, node);
}
break;
case SymbolKind.NamedType:
EdgeBuilder.CreateUsesEdge(node, symbol, _crossEdgeFiller);
break;
case SymbolKind.Property:
var parent = node.GetParent <AnonymousObjectMemberDeclaratorSyntax>( );
var needToRun = true;
if (parent != null)
{
needToRun =
parent.Expression.IsEquivalentTo(node.GetParent <ExpressionStatementSyntax>( ));
}
if (needToRun)
{
EdgeBuilder.CreateMethodCallFromProperty(node, symbol, _crossEdgeFiller);
}
break;
default:
break;
}
}
EdgeBuilder.CreateMethodCallEdgeFromIdentifier(node, _crossEdgeFiller);
}
base.VisitIdentifierName(node);
}
