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)); }