private static bool MattersToShowVar([NotNull] PrefixExpressionContext 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 IsEnumerable([NotNull] PrefixExpressionContext 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)
{
var typeElement = declaredType.GetTypeElement();
if (typeElement != null && typeElement.IsForeachEnumeratorPatternType())
{
return(true);
}
}
return(false);
}
public bool MatchesByRangeAndType([NotNull] PrefixExpressionContext context)
{
var startOffset = myExpressionRange.TextRange.StartOffset;
return(context.Expression.GetType() == myExpressionType &&
context.ExpressionRange.TextRange.StartOffset == startOffset);
}
public ForEachExpressionItem([NotNull] PrefixExpressionContext context) : base("forEach", context)
{
var postfixContext = context.PostfixContext;
var settingsStore = postfixContext.Reference.GetSettingsStore();
myTemplatesManager = postfixContext.ExecutionContext.LiveTemplatesManager;
myUseBraces = settingsStore.GetValue(PostfixSettingsAccessor.BracesForStatements);
}
public ThrowByTypeItem([NotNull] PrefixExpressionContext context, bool hasRequiredArguments)
: base("throw", context)
{
var executionContext = context.PostfixContext.ExecutionContext;
myLookupItemsOwner = executionContext.LookupItemsOwner;
myHasRequiredArguments = hasRequiredArguments;
}
private static bool IsAlreadyAwaited([NotNull] PrefixExpressionContext context)
{
var outerExpression = context.PostfixContext.GetOuterExpression(context.Expression);
var expression = outerExpression.GetContainingParenthesizedExpression();
var task = AwaitExpressionNavigator.GetByTask(expression as IUnaryExpression);
return(task != null);
}
protected override IPostfixLookupItem CreateBooleanItem(PrefixExpressionContext expression)
{
if (expression.CanBeStatement)
{
return(new IfItem(expression));
}
return(null);
}
protected StatementPostfixLookupItem([NotNull] string shortcut, [NotNull] PrefixExpressionContext context)
: base(shortcut, context)
{
Assertion.Assert(context.CanBeStatement, "context.CanBeStatement");
var settingsStore = context.PostfixContext.Reference.GetSettingsStore();
myUseBraces = settingsStore.GetValue(PostfixSettingsAccessor.BracesForStatements);
}
protected ForLookupItemBase([NotNull] string shortcut,
[NotNull] PrefixExpressionContext context,
[CanBeNull] string lengthName)
: base(shortcut, context)
{
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myLengthName = lengthName;
}
public ParseItem([NotNull] string shortcut, [NotNull] PrefixExpressionContext context, bool isTryParse)
: base(shortcut, context)
{
myIsTryParse = isTryParse;
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myLookupItemsOwner = executionContext.LookupItemsOwner;
}
public VarByTypeItem([NotNull] PrefixExpressionContext context, [NotNull] IDeclaredType referencedType)
: base("var", context)
{
myReferencedType = referencedType;
myLookupItemsOwner = context.PostfixContext.ExecutionContext.LookupItemsOwner;
var canInstantiate = TypeUtils.CanInstantiateType(referencedType, context.Expression);
myHasRequiredArguments = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0;
}
private static bool IsNotUnderUnaryNegation([NotNull] PrefixExpressionContext context)
{
var unaryExpression = context.ExpressionWithReference as IUnaryExpression;
var operatorExpression = UnaryOperatorExpressionNavigator.GetByOperand(unaryExpression);
if (operatorExpression == null)
{
return(true);
}
return(operatorExpression.UnaryOperatorType != UnaryOperatorType.EXCL);
}
protected IntroduceMemberLookupItem([NotNull] string shortcut,
[NotNull] PrefixExpressionContext context,
[NotNull] IType expressionType, bool isStatic)
: base(shortcut, context)
{
IsStatic = isStatic;
ExpressionType = expressionType;
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myMemberNames = EmptyList <string> .InstanceList;
}
private static string PresentExpression(
[NotNull] PrefixExpressionContext context, [NotNull] string postfixText, out TextRange range)
{
var text = context.Expression.GetText();
range = context.ExpressionRange.TextRange;
if (context.Expression.Contains(context.PostfixContext.Reference))
{
var originalSize = text.Length;
// "x > 0.par" => "x > 0"
if (text.EndsWith(postfixText, StringComparison.OrdinalIgnoreCase))
{
text = text.Substring(0, text.Length - postfixText.Length).TrimEnd();
}
var delta = originalSize - text.Length;
if (delta >= 0)
{
range = range.ExtendRight(-delta);
}
}
text = text.ReplaceNewLines().TrimStart();
while (true) // "aa\n && bb" => "aa && bb"
{
var reduced = text.Replace(" ", " ");
if (reduced.Length < text.Length)
{
text = reduced;
}
else
{
break;
}
}
const int textLength = 50;
if (text.Length > textLength)
{
text = text.Substring(0, textLength) + "…";
}
return(text);
}
protected override TExpression ExpandPostfix(PrefixExpressionContext context)
{
var psiModule = context.PostfixContext.PsiModule;
var expandedExpression = psiModule.GetPsiServices().DoTransaction(ExpandCommandName, () =>
{
var factory = CSharpElementFactory.GetInstance(psiModule);
var expression = context.Expression;
var operand = expression.GetOperandThroughParenthesis().NotNull("operand != null");
var newExpression = CreateExpression(factory, operand);
return(expression.ReplaceBy(newExpression));
});
return(expandedExpression);
}
protected static bool MakeSenseToCheckInAuto(PrefixExpressionContext 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] PrefixExpressionContext 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 || !CommonUtils.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] PrefixExpressionContext 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
}
public UsingItem([NotNull] PrefixExpressionContext context, bool shouldCreateVariable)
: base("using", context)
{
myTemplatesManager = context.PostfixContext.ExecutionContext.LiveTemplatesManager;
myShouldCreateVariable = shouldCreateVariable;
}
public SwitchItem([NotNull] PrefixExpressionContext context) : base("switch", context)
{
}
public AwaitItem([NotNull] PrefixExpressionContext context) : base("await", context)
{
}
protected ExpressionPostfixLookupItem([NotNull] string shortcut, [NotNull] PrefixExpressionContext context)
: base(shortcut, context)
{
}
public LockItem([NotNull] PrefixExpressionContext context) : base("lock", context)
{
}
protected override IntroduceMemberLookupItem CreateLookupItem(
PrefixExpressionContext expression, IType expressionType, bool isStatic)
{
return new IntroducePropertyLookupItem(expression, isStatic);
}
protected abstract IPostfixLookupItem CreateBooleanItem([NotNull] PrefixExpressionContext expression);
protected override IntroduceMemberLookupItem CreateItem(PrefixExpressionContext expression, IType expressionType, bool isStatic)
{
return(new IntroduceFieldLookupItem(expression, expressionType, isStatic));
}
public VarStatementItem([NotNull] PrefixExpressionContext context, bool isConstructorCall)
: base("var", context)
{
myIsConstructorCall = isConstructorCall;
}
protected abstract IntroduceMemberLookupItem CreateItem([NotNull] PrefixExpressionContext expression, [NotNull] IType expressionType, bool isStatic);
public IntroduceFieldLookupItem([NotNull] PrefixExpressionContext context, [NotNull] IType expressionType, bool isStatic)
: base("field", context, expressionType, isStatic)
{
}
public NewExpressionItem([NotNull] PrefixExpressionContext context)
: base("new", context)
{
}
public NewTypeItem([NotNull] PrefixExpressionContext context, bool hasRequiredArguments)
: base("new", context)
{
myHasRequiredArguments = hasRequiredArguments;
myLookupItemsOwner = context.PostfixContext.ExecutionContext.LookupItemsOwner;
}
