/// <summary>
/// Analyzes the ownership of the given-up symbol in the candidate callee.
/// </summary>
protected override void AnalyzeOwnershipInCandidateCallee(GivenUpOwnershipSymbol givenUpSymbol, MethodSummary calleeSummary,
ExpressionSyntax call, Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
ArgumentListSyntax argumentList = AnalysisContext.GetArgumentList(call);
if (argumentList is null)
{
return;
}
for (int idx = 0; idx < argumentList.Arguments.Count; idx++)
{
var argIdentifier = AnalysisContext.GetRootIdentifier(argumentList.Arguments[idx].Expression);
if (argIdentifier is null)
{
continue;
}
ISymbol argSymbol = model.GetSymbolInfo(argIdentifier).Symbol;
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(argSymbol, givenUpSymbol.ContainingSymbol, statement, givenUpSymbol.Statement))
{
if (calleeSummary.SideEffectsInfo.FieldFlowParamIndexes.Any(v => v.Value.Contains(idx) &&
this.IsFieldAccessedInSuccessor(v.Key, statement.Summary, machine)))
{
this.ErrorReporter.ReportGivenUpFieldOwnershipError(trace, argSymbol);
}
}
}
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the expression.
/// </summary>
private void AnalyzeOwnershipInExpression(GivenUpOwnershipSymbol givenUpSymbol, ExpressionSyntax expr,
Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
if (expr is IdentifierNameSyntax ||
expr is MemberAccessExpressionSyntax)
{
IdentifierNameSyntax rightIdentifier = AnalysisContext.GetRootIdentifier(expr);
if (rightIdentifier != null)
{
var rightSymbol = model.GetSymbolInfo(rightIdentifier).Symbol;
this.AnalyzeGivingUpFieldOwnership(givenUpSymbol, rightSymbol, statement, machine, trace);
}
}
else if (expr is InvocationExpressionSyntax ||
expr is ObjectCreationExpressionSyntax)
{
trace.InsertCall(statement.Summary.Method, expr);
HashSet <ISymbol> returnSymbols = this.AnalyzeOwnershipInCall(givenUpSymbol, expr, statement, machine, model, trace);
foreach (var returnSymbol in returnSymbols)
{
this.AnalyzeGivingUpFieldOwnership(givenUpSymbol, returnSymbol, statement, machine, trace);
}
}
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the assignment expression.
/// </summary>
protected override void AnalyzeOwnershipInAssignment(GivenUpOwnershipSymbol givenUpSymbol, AssignmentExpressionSyntax assignment,
Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
IdentifierNameSyntax leftIdentifier = AnalysisContext.GetRootIdentifier(assignment.Left);
ISymbol leftSymbol = model.GetSymbolInfo(leftIdentifier).Symbol;
this.AnalyzeGivingUpFieldOwnership(givenUpSymbol, leftSymbol, statement, machine, trace);
this.AnalyzeOwnershipInExpression(givenUpSymbol, assignment.Right,
statement, machine, model, trace);
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the assignment expression.
/// </summary>
protected override void AnalyzeOwnershipInAssignment(GivenUpOwnershipSymbol givenUpSymbol, AssignmentExpressionSyntax assignment,
Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
var leftIdentifier = AnalysisContext.GetRootIdentifier(assignment.Left);
ISymbol leftSymbol = model.GetSymbolInfo(leftIdentifier).Symbol;
if (assignment.Right is IdentifierNameSyntax)
{
var rightIdentifier = AnalysisContext.GetRootIdentifier(assignment.Right);
ISymbol rightSymbol = model.GetSymbolInfo(rightIdentifier).Symbol;
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(rightSymbol, givenUpSymbol.ContainingSymbol, statement, givenUpSymbol.Statement))
{
var type = model.GetTypeInfo(assignment.Right).Type;
if (leftSymbol != null && leftSymbol.Kind == SymbolKind.Field &&
this.IsFieldAccessedInSuccessor(leftSymbol as IFieldSymbol, statement.Summary, machine) &&
!this.AnalysisContext.IsTypePassedByValueOrImmutable(type))
{
TraceInfo newTrace = new TraceInfo();
newTrace.Merge(trace);
newTrace.AddErrorTrace(statement.SyntaxNode);
this.ErrorReporter.ReportGivenUpOwnershipFieldAssignment(newTrace, leftSymbol);
}
return;
}
}
else if (assignment.Right is MemberAccessExpressionSyntax)
{
this.AnalyzeOwnershipInExpression(givenUpSymbol, assignment.Right, statement, model, trace);
}
else if (assignment.Right is InvocationExpressionSyntax ||
assignment.Right is ObjectCreationExpressionSyntax)
{
trace.InsertCall(statement.Summary.Method, assignment.Right);
this.AnalyzeOwnershipInCall(givenUpSymbol, assignment.Right, statement,
machine, model, trace);
}
if (assignment.Left is MemberAccessExpressionSyntax)
{
ISymbol outerLeftMemberSymbol = model.GetSymbolInfo(assignment.Left).Symbol;
if (!outerLeftMemberSymbol.Equals(leftSymbol) &&
statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(givenUpSymbol.ContainingSymbol, leftSymbol, givenUpSymbol.Statement, statement))
{
TraceInfo newTrace = new TraceInfo();
newTrace.Merge(trace);
newTrace.AddErrorTrace(statement.SyntaxNode);
this.ErrorReporter.ReportGivenUpOwnershipAccess(newTrace);
}
}
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the expression.
/// </summary>
private void AnalyzeOwnershipInExpression(GivenUpOwnershipSymbol givenUpSymbol, ExpressionSyntax expr,
Statement statement, SemanticModel model, TraceInfo trace)
{
if (expr is MemberAccessExpressionSyntax)
{
var identifier = AnalysisContext.GetRootIdentifier(expr);
ISymbol symbol = model.GetSymbolInfo(identifier).Symbol;
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(symbol, givenUpSymbol.ContainingSymbol,
statement, givenUpSymbol.Statement))
{
TraceInfo newTrace = new TraceInfo();
newTrace.Merge(trace);
newTrace.AddErrorTrace(statement.SyntaxNode);
this.ErrorReporter.ReportGivenUpOwnershipAccess(newTrace);
}
}
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the gives-up operation.
/// </summary>
protected override void AnalyzeOwnershipInGivesUpCall(GivenUpOwnershipSymbol givenUpSymbol, InvocationExpressionSyntax call,
Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
if (statement.Equals(givenUpSymbol.Statement) &&
!statement.ControlFlowNode.IsSuccessorOf(
givenUpSymbol.Statement.ControlFlowNode))
{
return;
}
var opSymbol = model.GetSymbolInfo(call).Symbol;
if ((!opSymbol.Name.Equals("Send") &&
!opSymbol.Name.Equals("CreateMachine")) ||
(opSymbol.Name.Equals("CreateMachine") &&
call.ArgumentList.Arguments.Count != 2))
{
return;
}
ExpressionSyntax argExpr = call.ArgumentList.Arguments[1].Expression;
var arguments = new List <ExpressionSyntax>();
if (argExpr is ObjectCreationExpressionSyntax)
{
var objCreation = argExpr as ObjectCreationExpressionSyntax;
foreach (var arg in objCreation.ArgumentList.Arguments)
{
arguments.Add(arg.Expression);
}
}
else if (argExpr is BinaryExpressionSyntax &&
argExpr.IsKind(SyntaxKind.AsExpression))
{
var binExpr = argExpr as BinaryExpressionSyntax;
if (binExpr.Left is IdentifierNameSyntax ||
binExpr.Left is MemberAccessExpressionSyntax)
{
arguments.Add(binExpr.Left);
}
else if (binExpr.Left is InvocationExpressionSyntax)
{
var invocation = binExpr.Left as InvocationExpressionSyntax;
for (int i = 1; i < invocation.ArgumentList.Arguments.Count; i++)
{
arguments.Add(invocation.ArgumentList.Arguments[i].Expression);
}
}
}
else if (argExpr is IdentifierNameSyntax ||
argExpr is MemberAccessExpressionSyntax)
{
arguments.Add(argExpr);
}
var extractedArgs = this.ExtractArguments(arguments);
foreach (var arg in extractedArgs)
{
IdentifierNameSyntax argIdentifier = AnalysisContext.GetRootIdentifier(arg);
ITypeSymbol argType = model.GetTypeInfo(argIdentifier).Type;
if (this.AnalysisContext.IsTypePassedByValueOrImmutable(argType))
{
continue;
}
ISymbol argSymbol = model.GetSymbolInfo(argIdentifier).Symbol;
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(argSymbol, givenUpSymbol.ContainingSymbol,
statement, givenUpSymbol.Statement))
{
this.ErrorReporter.ReportGivenUpOwnershipSending(trace, argSymbol);
return;
}
}
}
/// <summary>
/// Analyzes the ownership of the given-up symbol in the candidate callee.
/// </summary>
protected override void AnalyzeOwnershipInCandidateCallee(GivenUpOwnershipSymbol givenUpSymbol, MethodSummary calleeSummary,
ExpressionSyntax call, Statement statement, StateMachine machine, SemanticModel model, TraceInfo trace)
{
if (statement.Equals(givenUpSymbol.Statement) &&
!statement.ControlFlowNode.IsSuccessorOf(givenUpSymbol.Statement.ControlFlowNode))
{
return;
}
if (call is InvocationExpressionSyntax invocation)
{
this.AnalyzeOwnershipInExpression(givenUpSymbol, invocation.Expression, statement, model, trace);
}
ArgumentListSyntax argumentList = AnalysisContext.GetArgumentList(call);
if (argumentList != null)
{
for (int idx = 0; idx < argumentList.Arguments.Count; idx++)
{
var argType = model.GetTypeInfo(argumentList.Arguments[idx].Expression).Type;
if (this.AnalysisContext.IsTypePassedByValueOrImmutable(argType))
{
continue;
}
var argIdentifier = AnalysisContext.GetRootIdentifier(
argumentList.Arguments[idx].Expression);
ISymbol argSymbol = model.GetSymbolInfo(argIdentifier).Symbol;
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(argSymbol, givenUpSymbol.ContainingSymbol,
statement, givenUpSymbol.Statement))
{
if (calleeSummary.SideEffectsInfo.ParameterAccesses.ContainsKey(idx))
{
foreach (var access in calleeSummary.SideEffectsInfo.ParameterAccesses[idx])
{
TraceInfo newTrace = new TraceInfo();
newTrace.Merge(trace);
newTrace.AddErrorTrace(access.SyntaxNode);
this.ErrorReporter.ReportGivenUpOwnershipAccess(newTrace);
}
}
var fieldSymbols = calleeSummary.SideEffectsInfo.FieldFlowParamIndexes.Where(
v => v.Value.Contains(idx)).Select(v => v.Key);
foreach (var fieldSymbol in fieldSymbols)
{
if (this.IsFieldAccessedInSuccessor(fieldSymbol, statement.Summary, machine))
{
this.ErrorReporter.ReportGivenUpOwnershipFieldAssignment(trace, fieldSymbol);
}
}
if (calleeSummary.SideEffectsInfo.GivesUpOwnershipParamIndexes.Contains(idx))
{
this.ErrorReporter.ReportGivenUpOwnershipSending(trace, argSymbol);
}
}
}
}
foreach (var fieldAccess in calleeSummary.SideEffectsInfo.FieldAccesses)
{
foreach (var access in fieldAccess.Value)
{
if (statement.Summary.DataFlowAnalysis.FlowsIntoSymbol(givenUpSymbol.ContainingSymbol, fieldAccess.Key,
givenUpSymbol.Statement, statement))
{
TraceInfo newTrace = new TraceInfo();
newTrace.Merge(trace);
newTrace.AddErrorTrace(access.SyntaxNode);
this.ErrorReporter.ReportGivenUpOwnershipFieldAccess(newTrace, fieldAccess.Key);
}
}
}
}
