private CasesAndOr GetCases(SemanticModel model, ExpressionSyntax casesExpression, ExpressionSyntax caseExpression)
{
if (caseExpression is BinaryExpressionSyntax binaryExpression)
{
var left = GetCases(model, casesExpression, binaryExpression.Left);
if (left == null)
{
return(null);
}
var right = GetCases(model, casesExpression, binaryExpression.Right);
if (right == null)
{
return(null);
}
left.CombineAnd(right);
return(left);
}
var argumentInvocation = (InvocationExpressionSyntax)caseExpression;
var caseMethod = model.FindMethodSymbol(argumentInvocation, _CaseMethods);
var isError = false;
if (caseMethod == null)
{
caseMethod = model.FindMethodSymbol(argumentInvocation, _ErrorCaseMethods);
if (caseMethod != null) // Logical, even if it does not do anything in case caseMethod == null
{
isError = true;
}
}
if (caseMethod == null)
{
return(null);
}
ExpressionSyntax criteria;
ExpressionSyntax parameterNameExpression;
if (caseMethod.Parameters.Length == 1)
{
parameterNameExpression = null;
criteria = argumentInvocation.GetArgument(0)?.Expression;
}
else
{
parameterNameExpression = argumentInvocation.GetArgument(0)?.Expression;
if (parameterNameExpression != null &&
caseMethod.Parameters[1].RefKind == RefKind.Out)
{
var visitor = new TypeHelperVisitor(model, isError, _ReportDiagnostic);
return(visitor.GetCase(parameterNameExpression));
}
criteria = argumentInvocation.GetArgument(1)?.Expression;
}
return(criteria?.Accept(new CriteriaVisitor(model, casesExpression, parameterNameExpression, _ReportDiagnostic)));
}
private ISymbol AnalyzeMember(SemanticModel model, ExpressionSyntax expression)
{
var lambda = expression as ParenthesizedLambdaExpressionSyntax;
if (lambda != null)
{
return(model.GetSymbol(lambda.Body));
}
var ctxLambda = expression as SimpleLambdaExpressionSyntax;
if (ctxLambda != null)
{
return(model.GetSymbol(ctxLambda.Body));
}
var invocation = expression as InvocationExpressionSyntax;
if (invocation != null)
{
// Can be Assign method
var invoked = model.FindMethodSymbol(invocation, _AssignMethods);
if (invoked != null)
{
return(AnalyzeMember(model, invocation.ArgumentList.Arguments[0].Expression));
}
}
return(null);
}
private TestedMember CreateTestedMember(SemanticModel model, ISymbol testedMember, ExpressionSyntax actExpression)
{
switch (testedMember.Kind)
{
case SymbolKind.Field:
return(new TestedMember(testedMember, TestedMemberKind.Field));
case SymbolKind.Method:
return(new TestedMember(testedMember, TestedMemberKind.Method));
case SymbolKind.Property:
var isIndexer = ((IPropertySymbol)testedMember).IsIndexer;
var isAssignment = model.FindMethodSymbol(actExpression, _AssignMethods) != null;
return(new TestedMember(testedMember,
isIndexer
? isAssignment
? TestedMemberKind.IndexerSet
: TestedMemberKind.IndexerGet
: isAssignment
? TestedMemberKind.PropertySet
: TestedMemberKind.PropertyGet));
default:
throw new NotImplementedException();
}
}
private CasesAndOr GetCases(SemanticModel model, ExpressionSyntax casesExpression, ExpressionSyntax caseExpression)
{
var binaryExpression = caseExpression as BinaryExpressionSyntax;
if (binaryExpression != null)
{
var left = GetCases(model, casesExpression, binaryExpression.Left);
if (left == null)
{
return(null);
}
var right = GetCases(model, casesExpression, binaryExpression.Right);
if (right == null)
{
return(null);
}
left.CombineAnd(right);
return(left);
}
var argumentInvocation = (InvocationExpressionSyntax)caseExpression;
var caseMethod = model.FindMethodSymbol(argumentInvocation, _CaseMethods);
if (caseMethod == null)
{
return(null);
}
ExpressionSyntax criterias;
ExpressionSyntax parameterNameExpression;
if (caseMethod.Parameters.Length == 1)
{
parameterNameExpression = null;
criterias = argumentInvocation.GetArgument(0)?.Expression;
}
else
{
parameterNameExpression = argumentInvocation.GetArgument(0)?.Expression;
criterias = argumentInvocation.GetArgument(1)?.Expression;
}
return(criterias?.Accept(new CriteriaVisitor(model, casesExpression, parameterNameExpression, _ReportDiagnostic)));
}
private ISymbol AnalyzeMember(SemanticModel model, ExpressionSyntax expression)
{
switch (expression)
{
case ParenthesizedLambdaExpressionSyntax lambda:
return(model.GetSymbol(lambda.Body));
case SimpleLambdaExpressionSyntax ctxLambda:
return(model.GetSymbol(ctxLambda.Body));
case InvocationExpressionSyntax invocation:
{
// Can be Assign method
var invoked = model.FindMethodSymbol(invocation, _AssignMethods);
if (invoked != null)
{
return(AnalyzeMember(model, invocation.ArgumentList.Arguments[0].Expression));
}
break;
}
}
return(null);
}
public static bool HasMethod(this SemanticModel @this, SyntaxNode node, params IMethodSymbol[] methods) => @this.FindMethodSymbol(node, methods) != null;
