public static RoslynVisitor GetInstance(Dictionary <CSharpSyntaxNode, uint> csmap, CrossEdgeFiller crossEdgeFiller)
 {
     if (Instance == null)
     {
         Instance = new RoslynVisitor();
     }
     _map             = csmap;
     _crossEdgeFiller = crossEdgeFiller;
     return(Instance);
 }
 /// <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>
        ///     Create crose edge for the Class through the Using edge
        /// </summary>
        /// <param name="node"></param>
        /// <param name="symbol"></param>
        /// <param name="crossEdgeFiller"></param>
        public static void CreateUsesEdge(TypeSyntax node, ISymbol symbol, CrossEdgeFiller crossEdgeFiller)
        {
            SyntaxNode tmpNode;
            var        reference = symbol.GetDefinition(out tmpNode);

            if (reference != null && reference.Kind == symbol.Kind)
            {
                MainDeclaration.Instance.UsesStack.Peek( ).Add(reference.GetLimType( ).Id);
            }
            else if (symbol.IsInMetadata( ))
            {
                var type = symbol.GetLimType( );
                MainDeclaration.Instance.LimFactory.setFiltered(type.Id);
                MainDeclaration.Instance.UsesStack.Peek( ).Add(type.Id);
            }
            var baseType = tmpNode as BaseTypeDeclarationSyntax;

            if (baseType != null)
            {
                crossEdgeFiller.OriginalDefinitionFiller(baseType, node);
            }
        }
Exemple #4
0
 public static void Visit(SyntaxNode node, Dictionary <Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode, uint> map, CrossEdgeFiller crossEdgeFiller)
 {
     RoslynVisitor.GetInstance(map, crossEdgeFiller).Visit(node);
 }
        /// <summary>
        ///     TODO separte
        /// </summary>
        /// <param name="expressionSyntax"></param>
        /// <param name="expressionKind"></param>
        /// <param name="crossEdgeFiller"></param>
        private static void CreateMethodCallFromExpression(ExpressionSyntax expressionSyntax,
                                                           ExpressionKind expressionKind, CrossEdgeFiller crossEdgeFiller)
        {
            if (expressionSyntax != null)
            {
                MainDeclaration.Instance.RoslynWatch.Start( );
                var symbol = MainDeclaration.Instance.Model.GetSymbolInfo(expressionSyntax).Symbol;
                MainDeclaration.Instance.RoslynWatch.Stop( );
                if (symbol != null)
                {
                    if (symbol.IsInMetadata( ))
                    {
                        CreateMethodCallEdge(symbol, symbol, MainDeclaration.Instance.LimFactory.setFiltered);
                    }
                    else
                    {
                        SyntaxNode method;
                        var        calledSymbol = symbol.GetDefinition(out method);
                        if (method != null && calledSymbol == null)
                        {
                            calledSymbol =
                                MainDeclaration.Instance.Solution.GetDocument(method.SyntaxTree)
                                .GetSemanticModelAsync( )
                                .Result.GetDeclaredSymbol(method.Parent);
                            method = method.Parent;
                            // conversation operator overloading has been handled another places
                            if (method.Kind( ) == SyntaxKind.ConversionOperatorDeclaration)
                            {
                                return;
                            }
                        }
                        CreateMethodCallEdge(symbol, calledSymbol);
                        switch (expressionKind)
                        {
                        case ExpressionKind.BinaryExpression:
                            crossEdgeFiller.OverloadedOperatorCallFiller(( OperatorDeclarationSyntax )method,
                                                                         ( BinaryExpressionSyntax )expressionSyntax);
                            break;

                        case ExpressionKind.PrefixUnaryExpression:
                            crossEdgeFiller.OverloadedOperatorCallFiller(( OperatorDeclarationSyntax )method,
                                                                         ( PrefixUnaryExpressionSyntax )expressionSyntax);
                            break;

                        case ExpressionKind.PostfixUnaryExpression:
                            crossEdgeFiller.OverloadedOperatorCallFiller(( OperatorDeclarationSyntax )method,
                                                                         ( PostfixUnaryExpressionSyntax )expressionSyntax);
                            break;

                        case ExpressionKind.AssigmentExpression:
                            if (method != null && method.Parent.Kind( ) == SyntaxKind.AccessorList)
                            {
                                crossEdgeFiller.EventAccessorCallFiller(( AccessorDeclarationSyntax )method,
                                                                        ( AssignmentExpressionSyntax )expressionSyntax);
                            }
                            else
                            {
                                crossEdgeFiller.OverloadedOperatorCallFiller(( OperatorDeclarationSyntax )method,
                                                                             ( AssignmentExpressionSyntax )expressionSyntax);
                            }
                            break;
                        }
                    }
                }
            }
        }
        /// <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));
                }
            }
        }