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