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);