public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
MainDeclaration.Instance.RoslynWatch.Start();
INamespaceSymbol namescpaceSymbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop();
INamespaceSymbol actualNamespaceFromMergedNamespace = GetActualNamespaceFromMergedNamespace(namescpaceSymbol, node);
Package limNode = SymbolBuilder.BuildDispatch <Package, INamespaceSymbol>(actualNamespaceFromMergedNamespace);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(actualNamespaceFromMergedNamespace);
node.CreateCommentForCU();
base.VisitNamespaceDeclaration(node);
if (MainDeclaration.Instance.NamespaceStack.Peek() > 0 && MainDeclaration.Instance.UsesStack.Count > 0)
{
Package package = (Package)MainDeclaration.Instance.LimFactory.getRef(
MainDeclaration.Instance.NamespaceStack.Peek()
);
Commons.Common.AddUses(package);
MainDeclaration.Instance.UsesStack.Pop();
}
limNode.SetCLOC(node);
var location = node.GetLocation();
location.CalculateFileLevelCommentLines();
location.CalculateFileLevelNumberOfBranches();
}
private void VisitField(BaseFieldDeclarationSyntax baseNode)
{
foreach (var variable in baseNode.Declaration.Variables)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(variable);
variable.CreateCommentNode(symbol);
MainDeclaration.Instance.RoslynWatch.Stop( );
if (symbol is IEventSymbol)
{
var type = symbol.GetType( );
var property = type.GetProperty("AssociatedField", BindingFlags.NonPublic |
BindingFlags.Instance);
symbol = ( IFieldSymbol )property.GetValue(symbol, null);
}
if (symbol != null)
{
var limNode = SymbolBuilder.BuildDispatch <Attribute, IFieldSymbol>(symbol as IFieldSymbol);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(
MainDeclaration.Instance.Component.Id, _map[variable], limNode.Id);
MainDeclaration.Instance.UsesStack.Pop( );
}
}
}
public void BuildAnonymousMethod <T>(T node, VisitNode <T> visit)
where T : AnonymousFunctionExpressionSyntax
{
MainDeclaration.Instance.RoslynWatch.Start();
IMethodSymbol symbol = MainDeclaration.Instance.Model.GetSymbolInfo(node).Symbol as IMethodSymbol;
MainDeclaration.Instance.RoslynWatch.Stop();
Method limNode = null;
if (symbol != null)
{
var anonymousObjectMemberDeclaration = node.GetParent <AnonymousObjectMemberDeclaratorSyntax>();
limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol, anonymousObjectMemberDeclaration == null);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(symbol);
limNode.Name = _crossEdgeFiller.GetOrCreateNode <Csharp.Asg.Nodes.Expression.AnonymousFunctionExpressionSyntax>(node).Identifier;
var temp = MainDeclaration.Instance.MethodStack.Pop();
Scope parent = (Scope)MainDeclaration.Instance.LimFactory.getRef(MainDeclaration.Instance.MethodStack.Peek().Id);
MainDeclaration.Instance.MethodStack.Push(temp);
limNode.MangledName = parent.MangledName + "." + limNode.Name;
if (anonymousObjectMemberDeclaration != null)
{
Commons.Common.Safe_Edge(parent, "HasMember", limNode.Id);
}
limNode.DemangledName = limNode.MangledName;
limNode.IsCompilerGenerated = true;
}
else
{
//TODO write warning/error
return;
}
visit(node as T);
if (MainDeclaration.Instance.MethodStack.Count > 1)
{
Utils.Info.MethodInfo mi = MainDeclaration.Instance.MethodStack.Pop();
if (node.Body.Kind() == SyntaxKind.Block)
{
mi = Commons.Common.FillMethodMetrics(node.Body, mi);
}
else
{
mi.NOB = 1;
mi.NOS = 1;
}
Commons.Common.FillFromMethodStack(mi);
}
limNode.SetCLOC(node);
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
if (node.Parent.Kind( ) != SyntaxKind.PropertyDeclaration ||
node.Parent.Kind( ) != SyntaxKind.IndexerDeclaration)
{
return;
}
MainDeclaration.Instance.RoslynWatch.Start( );
var propertySymbol = ( IPropertySymbol )MainDeclaration.Instance.Model.GetDeclaredSymbol(node.Parent);
MainDeclaration.Instance.RoslynWatch.Stop( );
var limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(propertySymbol.GetMethod);
if (propertySymbol.GetMethod.OverriddenMethod != null)
{
if (propertySymbol.GetMethod.OverriddenMethod.IsInMetadata( ))
{
MainDeclaration.Instance
.OverrideRelations.AddOverride(
( Method )propertySymbol.GetMethod.OverriddenMethod.ConvertToLimNode( ),
limNode
);
}
else
{
SyntaxNode dummyNode;
var overriddenMethodDefinition =
propertySymbol.GetMethod.OverriddenMethod.GetDefinition(out dummyNode);
if (overriddenMethodDefinition != null &&
overriddenMethodDefinition.Kind == propertySymbol.GetMethod.OverriddenMethod.Kind)
{
var overriddenMethodSymbol = ( Method )overriddenMethodDefinition.ConvertToLimNode( );
MainDeclaration.Instance
.OverrideRelations.AddOverride(
overriddenMethodSymbol,
limNode
);
}
}
}
limNode.SetCLOC(node);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
_map[node], limNode.Id);
node.CreateCommentNode(propertySymbol.GetMethod);
base.VisitArrowExpressionClause(node);
if (MainDeclaration.Instance.MethodStack.Count > 0)
{
Commons.Common.SetMetrics(node);
}
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop( );
node.CreateCommentNode(symbol);
var limNode = SymbolBuilder.BuildDispatch <Attribute, IFieldSymbol>(symbol);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
_map[node], limNode.Id);
MainDeclaration.Instance.UsesStack.Pop( );
}
/// <summary>
/// </summary>
/// <param name="symbol"></param>
/// <param name="calledSymbol"></param>
/// <param name="nodeFilter"></param>
public static void CreateMethodCallEdge(ISymbol symbol, ISymbol calledSymbol, NodeFilter nodeFilter = null)
{
var isNeedToFilter = nodeFilter != null;
var methodSymbol = symbol as IMethodSymbol;
Base node;
if (methodSymbol != null && methodSymbol.IsGenericMethod)
{
node = methodSymbol.GetMGI(calledSymbol as IMethodSymbol);
var id = MainDeclaration.Instance.LimFactory.createTypeFormerType(node.Id).Id;
MainDeclaration.Instance.LimFactory.addTypeFormer(id);
var type = MainDeclaration.Instance.LimFactory.endType( );
if (isNeedToFilter)
{
nodeFilter(id);
nodeFilter(type.Id);
}
}
else
{
if (isNeedToFilter)
{
node = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(( IMethodSymbol )calledSymbol);
(( Member )node).IsCompilerGenerated = true;
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
}
else
{
node = calledSymbol.ConvertToLimNode( );
}
}
if (isNeedToFilter)
{
nodeFilter(node.Id);
}
var methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(node.Id);
if (isNeedToFilter)
{
nodeFilter(methodCall.Id);
}
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, isNeedToFilter));
}
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node)
{
MainDeclaration.Instance.RoslynWatch.Start();
INamedTypeSymbol symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop();
Class limNode = SymbolBuilder.BuildDispatch <Class, INamedTypeSymbol>(symbol);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(symbol);
base.VisitDelegateDeclaration(node);
if (MainDeclaration.Instance.ClassStack.Count > 0)
{
Commons.Common.FillFromClassStack();
}
limNode.SetCLOC(node);
}
private void VisitNamedType <T>(BaseTypeDeclarationSyntax node, VisitNode <T> visitor)
where T : CSharpSyntaxNode
{
MainDeclaration.Instance.RoslynWatch.Start();
INamedTypeSymbol symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop();
Class limNode = SymbolBuilder.BuildDispatch <Class, INamedTypeSymbol>(symbol);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(symbol);
visitor(node as T);
if (MainDeclaration.Instance.ClassStack.Count > 0)
{
Commons.Common.FillFromClassStack();
}
limNode.SetCLOC(node);
}
/// <summary>
/// LIM ASG building phase
/// </summary>
/// <param name="map">Roslyn node and C# ASG ids map</param>
/// <param name="crossEdgeFiller">C# ASG cross edge filler object</param>
private static void BuildLIMASG(Dictionary <Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode, uint> map, CrossEdgeFiller crossEdgeFiller)
{
if (!MainDeclaration.Instance.LocalMap.ContainsKey(MainDeclaration.Instance.Model.Compilation.Assembly.GlobalNamespace))
{
MainDeclaration.Instance.LocalMap.Add(MainDeclaration.Instance.Model.Compilation.Assembly.GlobalNamespace, MainDeclaration.Instance.LimFactory.Root);
MainDeclaration.Instance.Root = MainDeclaration.Instance.LimFactory.getRef(MainDeclaration.Instance.LimFactory.Root) as Lim.Asg.Nodes.Logical.Package;
SymbolBuilder.BuildDispatch <Lim.Asg.Nodes.Logical.Package, INamespaceSymbol>(MainDeclaration.Instance.Model.Compilation.Assembly.GlobalNamespace);
MainDeclaration.Instance.UsesStack.Pop();
}
Commons.Common.Safe_Edge(MainDeclaration.Instance.Root, "BelongsTo", MainDeclaration.Instance.Component.Id);
if (!GetAlreadyContain(MainDeclaration.Instance.Component))
{
MainDeclaration.Instance.LimFactory.ComponentRootRef.addContains(MainDeclaration.Instance.Component);
}
MainDeclaration.Instance.RoslynWatch.Start();
var root = MainDeclaration.Instance.Model.SyntaxTree.GetRoot();
MainDeclaration.Instance.RoslynWatch.Stop();
//Visitor.Visit(root, ref map, crossEdgeFiller);
RoslynVisitor.GetInstance(map, crossEdgeFiller).Visit(root);
}
private void visitMethod <T>(BaseMethodDeclarationSyntax node, VisitNode <T> visitor)
where T : CSharpSyntaxNode
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop( );
HalsteadAnalyzer halsteadAnalyzer = new HalsteadAnalyzer();
var halstedMetrics = halsteadAnalyzer.Calculate(node);
var limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol);
limNode.TotalOperands = halstedMetrics.TotalOperands;
limNode.TotalOperators = halstedMetrics.TotalOperators;
limNode.DistinctOperands = halstedMetrics.DistinctOperands;
limNode.DistinctOperators = halstedMetrics.DistinctOperators;
if (symbol.OverriddenMethod != null)
{
if (symbol.OverriddenMethod.IsInMetadata( ))
{
MainDeclaration.Instance
.OverrideRelations.AddOverride(
( Method )symbol.OverriddenMethod.ConvertToLimNode( ),
limNode
);
}
else
{
SyntaxNode dummyNode;
var asd = symbol.OverriddenMethod.GetDefinition(out dummyNode);
if (asd != null && asd.Kind == symbol.OverriddenMethod.Kind)
{
var overriddenMethodSymbol = ( Method )asd.ConvertToLimNode( );
MainDeclaration.Instance
.OverrideRelations.AddOverride(
overriddenMethodSymbol,
limNode
);
}
}
}
if (symbol.ContainingType.TypeKind == TypeKind.Interface)
{
Commons.Common.ChangeRealizationLevel(limNode);
}
if (symbol.PartialImplementationPart != null)
{
Commons.Common.ChangeRealizationLevel(limNode);
var method = symbol.PartialImplementationPart.IsGenericMethod
? SymbolBuilder.BuildDispatch <MethodGeneric, IMethodSymbol>(symbol.PartialImplementationPart)
: SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol.PartialImplementationPart);
method.NumberOfBranches = 0;
limNode.setDeclares(method.Id);
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
}
if (node.Kind( ) == SyntaxKind.ConstructorDeclaration)
{
var init = (( ConstructorDeclarationSyntax )node).Initializer;
if (init != null)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var calleeSymbol = MainDeclaration.Instance.Model.GetSymbolInfo(init).Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
if (calleeSymbol != null)
{
SyntaxNode calledCtor;
calleeSymbol.GetDefinition(out calledCtor);
EdgeBuilder.CreateMethodCallEdge(symbol, calleeSymbol);
if (calledCtor != null && calledCtor.Kind( ) == SyntaxKind.ConstructorDeclaration)
{
// if the called constructor doesn't exist in the code e.x.: default constructor
_crossEdgeFiller.ConstructorCallFiller(( ConstructorDeclarationSyntax )calledCtor, init);
}
}
}
}
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
_map[node], limNode.Id);
node.CreateCommentNode(symbol);
visitor(node as T);
if (MainDeclaration.Instance.MethodStack.Count > 0)
{
Commons.Common.SetMetrics(node);
}
limNode.SetCLOC(node);
}
/// <summary>
/// In this section it'll be create:
/// - Instantiate edge from object creation expression
/// - MethodCall edge from object creation expression
/// These edges add to the acutal method from the MethodStack
/// </summary>
/// <param name="node"></param>
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
base.VisitObjectCreationExpression(node);
//if (node.IsParent<AnonymousObjectMemberDeclaratorSyntax>()) return;
MainDeclaration.Instance.RoslynWatch.Start( );
ISymbol symbol = null;
if (node.Type.Kind( ) != SyntaxKind.NullableType)
{
MainDeclaration.Instance.RoslynWatch.Start( );
symbol = MainDeclaration.Instance.Model.GetSymbolInfo(node.Type).Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
}
else
{
MainDeclaration.Instance.RoslynWatch.Start( );
symbol =
MainDeclaration.Instance.Model.GetSymbolInfo((node.Type as NullableTypeSyntax)?.ElementType)
.Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
}
MainDeclaration.Instance.RoslynWatch.Stop( );
SyntaxNode synNode = null;
if (symbol != null && MainDeclaration.Instance.MethodStack.Count > 0)
{
var calledSymbol = symbol.GetDefinition(out synNode);
if (calledSymbol != null && calledSymbol.Kind == symbol.Kind)
{
uint id = 0;
if (calledSymbol.Kind == SymbolKind.NamedType && (calledSymbol as INamedTypeSymbol).IsGenericType)
{
id = symbol.GetLimType(calledSymbol).Id;
}
else
{
id = calledSymbol.GetLimType( ).Id;
}
var pair = new KeyValuePair <uint, bool>(id, false);
if (!MainDeclaration.Instance.MethodStack.Peek( ).CanThrow.Contains(pair))
{
MainDeclaration.Instance.MethodStack.Peek( ).Instantiates.Add(pair);
}
if (symbol.Kind == SymbolKind.NamedType && synNode.Kind( ) != SyntaxKind.DelegateDeclaration)
{
_crossEdgeFiller.OriginalDefinitionFiller(synNode as MemberDeclarationSyntax, node.Type);
}
}
else if (symbol.IsInMetadata( ))
{
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
var id = namedTypeSymbol.GetLimType( ).Id;
MainDeclaration.Instance.LimFactory.setFiltered(id);
var pair = new KeyValuePair <uint, bool>(id, true);
if (!MainDeclaration.Instance.MethodStack.Peek( ).CanThrow.Contains(pair))
{
MainDeclaration.Instance.MethodStack.Peek( ).Instantiates.Add(pair);
}
}
}
}
MainDeclaration.Instance.RoslynWatch.Start( );
symbol = MainDeclaration.Instance.Model.GetSymbolInfo(node).Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
if (symbol != null && MainDeclaration.Instance.MethodStack.Count > 0)
{
var calledSymbol = symbol.GetDefinition(out synNode);
if (calledSymbol != null && calledSymbol.Kind == symbol.Kind)
{
if (calledSymbol.Kind == SymbolKind.Method)
{
var methodCall =
MainDeclaration.Instance.LimFactory.createMethodCall(calledSymbol.ConvertToLimNode( ).Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, false));
_crossEdgeFiller.ConstructorCallFiller(( ConstructorDeclarationSyntax )synNode, node);
}
}
else if (symbol.IsInMetadata( ))
{
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol != null)
{
Method method = null;
if (methodSymbol.IsGenericMethod)
{
method = SymbolBuilder.BuildDispatch <MethodGeneric, IMethodSymbol>(methodSymbol);
}
else
{
method = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(methodSymbol);
}
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
MainDeclaration.Instance.LimFactory.setFiltered(method.Id);
var methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(method.Id);
MainDeclaration.Instance.LimFactory.setFiltered(methodCall.Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, true));
}
}
}
}
public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop( );
HalsteadAnalyzer halsteadAnalyzer = new HalsteadAnalyzer( );
var halstedMetrics = halsteadAnalyzer.Calculate(node);
var nodeParent = node.GetParent <BasePropertyDeclarationSyntax>( );
_isAutoProperty = nodeParent.Kind( ) == SyntaxKind.PropertyDeclaration &&
IsAutoProperty(nodeParent as PropertyDeclarationSyntax,
symbol.AssociatedSymbol as IPropertySymbol);
var limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol);
limNode.TotalOperands = halstedMetrics.TotalOperands;
limNode.TotalOperators = halstedMetrics.TotalOperators;
limNode.DistinctOperands = halstedMetrics.DistinctOperands;
limNode.DistinctOperators = halstedMetrics.DistinctOperators;
if (symbol.OverriddenMethod != null)
{
if (symbol.OverriddenMethod.IsInMetadata( ))
{
MainDeclaration.Instance
.OverrideRelations.AddOverride(
( Method )symbol.OverriddenMethod.ConvertToLimNode( ),
limNode
);
}
else
{
SyntaxNode dummyNode;
var overriddenMethodDefinition = symbol.OverriddenMethod.GetDefinition(out dummyNode);
if (overriddenMethodDefinition != null &&
overriddenMethodDefinition.Kind == symbol.OverriddenMethod.Kind)
{
var overriddenMethodSymbol = ( Method )overriddenMethodDefinition.ConvertToLimNode( );
MainDeclaration.Instance
.OverrideRelations.AddOverride(
overriddenMethodSymbol,
limNode
);
}
}
}
limNode.SetCLOC(node);
limNode.SetCLOC(node.Parent.Parent);
if (_isAutoProperty)
{
CreateAttributeWithAccessEdge(nodeParent, symbol.AssociatedSymbol, limNode);
}
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
_map[node], limNode.Id);
node.CreateCommentNode(symbol);
node.Parent.Parent.CreateCommentNode(symbol);
base.VisitAccessorDeclaration(node);
if (MainDeclaration.Instance.MethodStack.Count > 0)
{
Commons.Common.SetMetrics(node);
}
}
/// <summary>
/// Create cross edge for Method through the MethodCall edge
/// </summary>
/// <param name="node"></param>
/// <param name="symbol"></param>
/// <param name="crossEdgeFiller"></param>
public static void CreateMethodCallFromProperty(CSharpSyntaxNode node, ISymbol symbol,
CrossEdgeFiller crossEdgeFiller)
{
SyntaxNode accessor;
SyntaxNode property;
var propertySymbol = symbol.GetDefinition(out property) as IPropertySymbol;
bool needAllAccessor;
var method = GetCalledAccessor(node, symbol, out needAllAccessor);
if (needAllAccessor)
{
if (propertySymbol != null && propertySymbol.Kind == symbol.Kind)
{
var calledGetAccessor = propertySymbol.GetMethod;
if (calledGetAccessor != null)
{
calledGetAccessor = ( IMethodSymbol )calledGetAccessor.GetDefinition(out accessor);
var methodCall =
MainDeclaration.Instance.LimFactory.createMethodCall(
calledGetAccessor.ConvertToLimNode( ).Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, false));
if (node.Kind( ) == SyntaxKind.IdentifierName)
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( IdentifierNameSyntax )node);
}
else
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( ElementAccessExpressionSyntax )node);
}
}
var calledSetAccessor = propertySymbol.SetMethod;
if (calledSetAccessor != null)
{
calledSetAccessor = ( IMethodSymbol )calledSetAccessor.GetDefinition(out accessor);
var methodCall =
MainDeclaration.Instance.LimFactory.createMethodCall(
calledSetAccessor.ConvertToLimNode( ).Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, false));
if (node.Kind( ) == SyntaxKind.IdentifierName)
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( IdentifierNameSyntax )node);
}
else
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( ElementAccessExpressionSyntax )node);
}
}
}
else if (symbol.IsInMetadata( ) && MainDeclaration.Instance.MethodStack.Count > 0)
{
var prop = symbol as IPropertySymbol;
Method getMethod = null;
if (prop != null && prop.GetMethod != null)
{
getMethod = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(prop.GetMethod);
}
if (getMethod != null)
{
MainDeclaration.Instance.LimFactory.setFiltered(getMethod.Id);
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
var methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(getMethod.Id);
MainDeclaration.Instance.LimFactory.setFiltered(methodCall.Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, true));
Method setMethod = null;
if (prop.SetMethod != null)
{
setMethod = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(prop.SetMethod);
}
if (setMethod != null)
{
MainDeclaration.Instance.LimFactory.setFiltered(setMethod.Id);
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(setMethod.Id);
}
MainDeclaration.Instance.LimFactory.setFiltered(methodCall.Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, true));
}
}
}
else if (method != null)
{
var calledPropertyAccessor = method.GetDefinition(out accessor);
if (calledPropertyAccessor != null && calledPropertyAccessor.Kind == method.Kind)
{
var methodCall =
MainDeclaration.Instance.LimFactory.createMethodCall(
calledPropertyAccessor.ConvertToLimNode( ).Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, false));
if (node.Kind( ) == SyntaxKind.IdentifierName)
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( IdentifierNameSyntax )node);
}
else
{
crossEdgeFiller.AccessorCallFiller(( AccessorDeclarationSyntax )accessor,
( ElementAccessExpressionSyntax )node);
}
}
else if (method.IsInMetadata( ) && MainDeclaration.Instance.MethodStack.Count > 0)
{
var mth = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(method);
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
mth.IsCompilerGenerated = true;
MainDeclaration.Instance.LimFactory.setFiltered(mth.Id);
var methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(mth.Id);
MainDeclaration.Instance.LimFactory.setFiltered(methodCall.Id);
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, true));
}
}
}
/// <summary>
/// TODO separate
/// </summary>
/// <param name="node"></param>
/// <param name="possibleDelegateSymbol"></param>
/// <param name="map"></param>
/// <param name="nodeFilter"></param>
public static void CreateMethodCallEdgeFromDelegatePointer(InvocationExpressionSyntax node,
INamedTypeSymbol possibleDelegateSymbol, Dictionary <CSharpSyntaxNode, uint> map,
NodeFilter nodeFilter = null)
{
//var isNeedToFilter = false;
Scope @class;
if (possibleDelegateSymbol.IsGenericType)
{
@class = SymbolBuilder.BuildDispatch <ClassGeneric, INamedTypeSymbol>(possibleDelegateSymbol);
}
else
{
@class = SymbolBuilder.BuildDispatch <Class, INamedTypeSymbol>(possibleDelegateSymbol);
}
@class.IsCompilerGenerated = true;
Commons.Common.ChangeRealizationLevel(@class);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
map[node], @class.Id);
var member = possibleDelegateSymbol.DelegateInvokeMethod;
Member calledMethod;
if (member.IsGenericMethod)
{
calledMethod = SymbolBuilder.BuildDispatch <MethodGeneric, IMethodSymbol>(member);
}
else
{
calledMethod = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(member);
}
calledMethod.IsCompilerGenerated = true;
Commons.Common.ChangeRealizationLevel(( Scope )calledMethod);
Commons.Common.Safe_Edge(@class, "HasMember", calledMethod.Id);
possibleDelegateSymbol.DeclaringSyntaxReferences[0].GetSyntax( )
.CreateCommentNode(possibleDelegateSymbol);
possibleDelegateSymbol.DeclaringSyntaxReferences[0].GetSyntax( )
.CreateCommentNode(possibleDelegateSymbol.DelegateInvokeMethod);
if (MainDeclaration.Instance.MethodStack.Count > 1)
{
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
}
if (MainDeclaration.Instance.ClassStack.Count > 1)
{
Commons.Common.FillFromClassStack( );
}
(( Method )calledMethod).NumberOfBranches = 0;
//if ( isNeedToFilter ) nodeFilter( calledMethod.Id );
var methodCall = MainDeclaration.Instance.LimFactory.createMethodCall(calledMethod.Id);
//if ( isNeedToFilter ) nodeFilter( methodCall.Id );
MainDeclaration.Instance.MethodStack.Peek( )
.Calls.Add(new KeyValuePair <uint, bool>(methodCall.Id, false));
var id = possibleDelegateSymbol.GetLimType( ).Id;
//if ( isNeedToFilter ) nodeFilter( id );
MainDeclaration.Instance.MethodStack.Peek( )
.Instantiates.Add(new KeyValuePair <uint, bool>(id, false));
}
