private static bool IsWorthShowingInPreciseMode([NotNull] CSharpPostfixExpressionContext expressionContext)
{
var declaration = expressionContext.PostfixContext.ContainingFunction;
if (declaration == null)
{
return(false);
}
var function = declaration.DeclaredElement;
if (function == null)
{
return(false);
}
var returnType = GetMethodReturnValueType(function, declaration);
if (returnType == null)
{
return(false);
}
var conversionRule = expressionContext.Expression.GetTypeConversionRule();
return(expressionContext.ExpressionType.IsImplicitlyConvertibleTo(returnType, conversionRule));
}
private static bool IsItMattersToShowVar([NotNull] CSharpPostfixExpressionContext context)
{
if (context.CanBeStatement)
{
return(true);
}
var withReference = context.ExpressionWithReference;
if (withReference != null)
{
// return SomeLong().var.Expression;
var outerReference = ReferenceExpressionNavigator.GetByQualifierExpression(withReference);
if (outerReference != null)
{
return(true);
}
// SomeCall(withComplex.Arguments().var, 42);
var argument = CSharpArgumentNavigator.GetByValue(withReference);
if (argument != null)
{
return(true);
}
}
// note: what about F(arg.var)?
return(false);
}
private static bool IsWorthShowingInPreciseMode([NotNull] CSharpPostfixExpressionContext expressionContext)
{
var declaration = expressionContext.PostfixContext.ContainingFunction;
if (declaration == null)
{
return(false);
}
var function = declaration.DeclaredElement;
if (function == null)
{
return(false);
}
var returnType = function.ReturnType;
if (returnType.IsVoid())
{
return(false);
}
if (!IsAlreadyOrCanBecameIterator(declaration, returnType))
{
return(false);
}
var elementType = GetIteratorElementType(returnType, declaration);
// todo: allow if type is unknown?
var conversionRule = expressionContext.Expression.GetTypeConversionRule();
return(expressionContext.ExpressionType.IsImplicitlyConvertibleTo(elementType, conversionRule));
}
private static bool IsEnumerable([NotNull] CSharpPostfixExpressionContext context)
{
if (!context.Type.IsResolved)
{
return(false);
}
var predefined = context.Expression.GetPredefinedType();
var conversionRule = context.Expression.GetTypeConversionRule();
if (conversionRule.IsImplicitlyConvertibleTo(context.Type, predefined.IEnumerable))
{
return(true);
}
var declaredType = context.Type as IDeclaredType;
if (declaredType == null || declaredType.IsUnknown)
{
return(false);
}
var typeElement = declaredType.GetTypeElement();
return(typeElement != null && typeElement.IsForeachEnumeratorPatternType());
}
private static bool IsAlreadyAwaited([NotNull] CSharpPostfixExpressionContext context)
{
var outerExpression = context.PostfixContext.GetOuterExpression(context.Expression);
var expression = outerExpression.GetContainingParenthesizedExpression();
var task = AwaitExpressionNavigator.GetByTask(expression as IUnaryExpression);
return(task != null);
}
protected override PostfixTemplateInfo TryCreateBooleanInfo(CSharpPostfixExpressionContext expression)
{
if (expression.CanBeStatement)
{
return(new PostfixTemplateInfo("while", expression));
}
return(null);
}
private static bool IsNotUnderUnaryNegation([NotNull] CSharpPostfixExpressionContext context)
{
var unaryExpression = context.ExpressionWithReference as IUnaryExpression;
var operatorExpression = UnaryOperatorExpressionNavigator.GetByOperand(unaryExpression);
if (operatorExpression == null)
{
return(true);
}
return(operatorExpression.UnaryOperatorType != UnaryOperatorType.EXCL);
}
protected static bool MakeSenseToCheckInPreciseMode(CSharpPostfixExpressionContext expressionContext)
{
var expression = expressionContext.Expression.GetOperandThroughParenthesis();
if (expression is IAssignmentExpression)
{
return(false);
}
// .notnull/.null over 'as T' expressions looks annoying
if (expression is IAsExpression)
{
return(false);
}
return(true);
}
private static bool CheckExpressionType([NotNull] CSharpPostfixExpressionContext expressionContext, out bool needFixWithNew)
{
needFixWithNew = false;
// 'new Exception().throw' case
var expressionType = expressionContext.ExpressionType;
if (expressionType.IsResolved)
{
var predefinedType = expressionContext.Expression.GetPredefinedType();
var conversionRule = expressionContext.Expression.GetTypeConversionRule();
return(expressionType.IsImplicitlyConvertibleTo(predefinedType.Exception, conversionRule));
}
// 'Exception(message).new' case
var invocationExpression = expressionContext.Expression as IInvocationExpression;
if (invocationExpression != null)
{
var reference = invocationExpression.InvokedExpression as IReferenceExpression;
if (reference == null || !CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
return(false);
}
var resolveResult = reference.Reference.Resolve().Result;
var typeElement = resolveResult.DeclaredElement as ITypeElement;
if (typeElement == null)
{
return(false);
}
var declaredType = TypeFactory.CreateType(typeElement, resolveResult.Substitution);
if (IsInstantiableExceptionType(declaredType, expressionContext.Expression))
{
needFixWithNew = true;
return(true);
}
}
return(false);
}
protected static bool IsNullable([CanBeNull] CSharpPostfixExpressionContext expressionContext)
{
if (expressionContext == null)
{
return(false);
}
var expression = expressionContext.Expression;
if (expression is INullCoalescingExpression)
{
return(true);
}
if (expression is IThisExpression ||
expression is IBaseExpression ||
expression is ICSharpLiteralExpression ||
expression is IObjectCreationExpression ||
expression is IUnaryOperatorExpression ||
expression is IBinaryExpression ||
expression is IAnonymousMethodExpression ||
expression is IAnonymousObjectCreationExpression ||
expression is IArrayCreationExpression ||
expression is IDefaultExpression ||
expression is ITypeofExpression)
{
return(false);
}
var typeClassification = expressionContext.Type.Classify;
if (typeClassification == TypeClassification.VALUE_TYPE)
{
return(expressionContext.Type.IsNullable());
}
return(true); // unknown or ref-type
}
protected override PostfixTemplateInfo TryCreateBooleanInfo(CSharpPostfixExpressionContext expression)
{
throw new InvalidOperationException("Should not be called");
}
protected abstract PostfixTemplateInfo TryCreateBooleanInfo([NotNull] CSharpPostfixExpressionContext expression);
