/// <summary>
 /// Returns all cached method summaries for the specified invocation.
 /// </summary>
 /// <param name="invocation">InvocationExpressionSyntax</param>
 /// <param name="node">IDataFlowNode</param>
 /// <returns>MethodSummarys</returns>
 internal static ISet <MethodSummary> ResolveMethodSummaries(
     InvocationExpressionSyntax invocation, IDataFlowNode node)
 {
     return(MethodSummaryResolver.ResolveMethodSummaries(invocation as ExpressionSyntax, node));
 }
 /// <summary>
 /// Returns all cached method summaries for the specified object creation.
 /// </summary>
 /// <param name="objCreation">ObjectCreationExpressionSyntax</param>
 /// <param name="node">IDataFlowNode</param>
 /// <returns>MethodSummarys</returns>
 internal static ISet <MethodSummary> ResolveMethodSummaries(
     ObjectCreationExpressionSyntax objCreation, IDataFlowNode node)
 {
     return(MethodSummaryResolver.ResolveMethodSummaries(objCreation as ExpressionSyntax, node));
 }
Beispiel #3
0
        /// <summary>
        /// Analyzes the data-flow in the method call.
        /// </summary>
        /// <param name="call">ExpressionSyntax</param>
        /// <param name="node">IDataFlowNode</param>
        /// <param name="returnSymbols">Return symbols</param>
        /// <param name="returnTypes">Return types</param>
        private void AnalyzeMethodCall(ExpressionSyntax call, IDataFlowNode node,
                                       out ISet <ISymbol> returnSymbols, out ISet <ITypeSymbol> returnTypes)
        {
            returnSymbols = new HashSet <ISymbol>();
            returnTypes   = new HashSet <ITypeSymbol>();

            var callSymbol = this.SemanticModel.GetSymbolInfo(call).Symbol;

            if (callSymbol == null)
            {
                return;
            }

            var invocation  = call as InvocationExpressionSyntax;
            var objCreation = call as ObjectCreationExpressionSyntax;

            ISet <MethodSummary> candidateCalleeSummaries;

            if (invocation != null)
            {
                candidateCalleeSummaries = MethodSummaryResolver.ResolveMethodSummaries(invocation, node);
            }
            else
            {
                candidateCalleeSummaries = MethodSummaryResolver.ResolveMethodSummaries(objCreation, node);
            }

            ArgumentListSyntax argumentList;

            if (invocation != null)
            {
                argumentList = invocation.ArgumentList;
            }
            else
            {
                argumentList = objCreation.ArgumentList;
            }

            this.ResolveGivesUpOwnershipInCall(callSymbol, argumentList, node);

            foreach (var candidateCalleeSummary in candidateCalleeSummaries)
            {
                this.MapCalleeSummaryToCallSymbol(candidateCalleeSummary, callSymbol, node);
                this.ResolveGivesUpOwnershipInCall(callSymbol, candidateCalleeSummary,
                                                   argumentList, node);
                this.ResolveSideEffectsInCall(call, candidateCalleeSummary, node);

                if (invocation != null)
                {
                    returnSymbols.UnionWith(candidateCalleeSummary.GetResolvedReturnSymbols(
                                                invocation, this.SemanticModel));
                }

                returnTypes.UnionWith(candidateCalleeSummary.SideEffectsInfo.ReturnTypes);
            }

            if (objCreation != null)
            {
                returnTypes.Add(this.SemanticModel.GetTypeInfo(call).Type);
            }

            if (invocation != null)
            {
                this.ResolveSideEffectsInExpression(invocation.Expression, node);
            }
        }