public IntroduceMemberPostfixTemplateInfo( [NotNull] string text, [NotNull] PostfixExpressionContext expression, IType expressionType, bool isStatic) : base(text, expression) { ExpressionType = expressionType; IsStatic = isStatic; }
public PostfixTemplateInfo( [NotNull] string text, [NotNull] PostfixExpressionContext expression, PostfixTemplateTarget target = PostfixTemplateTarget.Expression) { Multiplier = 0; myText = text.ToLowerInvariant(); myShortcut = text; myTarget = target; myImages = new[] { new PostfixExpressionContextImage(expression) }; myExecutionContext = expression.PostfixContext.ExecutionContext; }
private static string PresentExpression( [NotNull] PostfixExpressionContext 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 ITreeNode ExpandPostfix(PostfixExpressionContext context) { var csharpContext = (CSharpPostfixExpressionContext)context; var psiModule = csharpContext.PostfixContext.PsiModule; var psiServices = psiModule.GetPsiServices(); var expandedExpression = psiServices.DoTransaction(ExpandCommandName, () => { var factory = CSharpElementFactory.GetInstance(psiModule); var expression = csharpContext.Expression; // todo: get rid of this xtra behavior? var operand = expression.GetOperandThroughParenthesis().NotNull("operand != null"); var newExpression = CreateExpression(factory, operand); return(expression.ReplaceBy(newExpression)); // todo: DecorateReplacedExpression()? }); return(expandedExpression); }
public override PostfixExpressionContext FixExpression(PostfixExpressionContext context) { return(FixExpression((CSharpPostfixExpressionContext)context)); }
public CheckForNullPostfixTemplateInfo( [NotNull] string text, [NotNull] PostfixExpressionContext expression, bool checkNotNull, PostfixTemplateTarget target) : base(text, expression, target) { CheckNotNull = checkNotNull; }
protected abstract ITreeNode ExpandPostfix([NotNull] PostfixExpressionContext context);
private bool postfixExpression_sempred(PostfixExpressionContext _localctx, int predIndex) { switch (predIndex) { case 0: return Precpred(Context, 6); case 1: return Precpred(Context, 5); case 2: return Precpred(Context, 4); case 3: return Precpred(Context, 3); case 4: return Precpred(Context, 2); case 5: return Precpred(Context, 1); } return true; }
private PostfixExpressionContext postfixExpression(int _p) { ParserRuleContext _parentctx = Context; int _parentState = State; PostfixExpressionContext _localctx = new PostfixExpressionContext(Context, _parentState); PostfixExpressionContext _prevctx = _localctx; int _startState = 14; EnterRecursionRule(_localctx, 14, RULE_postfixExpression, _p); int _la; try { int _alt; EnterOuterAlt(_localctx, 1); { { _localctx = new SimpleExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 115; primaryExpression(); } Context.Stop = TokenStream.Lt(-1); State = 140; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,10,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber ) { if ( _alt==1 ) { if ( ParseListeners!=null ) TriggerExitRuleEvent(); _prevctx = _localctx; { State = 138; switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: { _localctx = new IndexContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 117; if (!(Precpred(Context, 6))) throw new FailedPredicateException(this, "Precpred(Context, 6)"); State = 118; Match(LeftBracket); State = 119; argumentExpressionList(0); State = 120; Match(RightBracket); } break; case 2: { _localctx = new CallContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 122; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); State = 123; Match(LeftParen); State = 125; _la = TokenStream.La(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LeftParen) | (1L << Plus) | (1L << PlusPlus) | (1L << Minus) | (1L << MinusMinus) | (1L << Star) | (1L << And) | (1L << Not) | (1L << Tilde) | (1L << Identifier) | (1L << Constant) | (1L << StringLiteral))) != 0)) { { State = 124; argumentExpressionList(0); } } State = 127; Match(RightParen); } break; case 3: { _localctx = new MemberAccessContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 128; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); State = 129; Match(Dot); State = 130; Match(Identifier); } break; case 4: { _localctx = new MemberPointerAccessContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 131; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); State = 132; Match(Arrow); State = 133; Match(Identifier); } break; case 5: { _localctx = new PostfixIncrementContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 134; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); State = 135; Match(PlusPlus); } break; case 6: { _localctx = new PostfixDecrementContext(new PostfixExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); State = 136; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); State = 137; Match(MinusMinus); } break; } } } State = 142; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,10,Context); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { UnrollRecursionContexts(_parentctx); } return _localctx; }
public PostfixIncrementContext(PostfixExpressionContext context) { CopyFrom(context); }
public CallContext(PostfixExpressionContext context) { CopyFrom(context); }
public SimpleExpressionContext(PostfixExpressionContext context) { CopyFrom(context); }
public MemberPointerAccessContext(PostfixExpressionContext context) { CopyFrom(context); }
public IndexContext(PostfixExpressionContext context) { CopyFrom(context); }
public virtual void CopyFrom(PostfixExpressionContext context) { base.CopyFrom(context); }
protected override ITreeNode ExpandPostfix(PostfixExpressionContext context) { var csharpContext = (CSharpPostfixExpressionContext)context; var psiModule = csharpContext.PostfixContext.PsiModule; var psiServices = psiModule.GetPsiServices(); var factory = CSharpElementFactory.GetInstance(psiModule); var targetStatement = csharpContext.GetContainingStatement(); var expressionRange = csharpContext.Expression.GetDocumentRange(); // Razor issue - hard to convert expression to statement if (!targetStatement.GetDocumentRange().IsValid()) { var newStatement = psiServices.DoTransaction(ExpandCommandName, () => { // todo: pass original context? var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull(); return(CreateStatement(factory, expression)); }); var razorStatement = RazorUtil.FixExpressionToStatement(expressionRange, psiServices); if (razorStatement != null) { return(psiServices.DoTransaction(ExpandCommandName, () => { var statement = razorStatement.ReplaceBy(newStatement); // force Razor's bracing style var languageService = statement.Language.LanguageService().NotNull(); var formatter = languageService.CodeFormatter.NotNull(); formatter.Format(statement, CodeFormatProfile.SOFT, NullProgressIndicator.Instance); return statement; })); } Logger.Fail("Failed to resolve target statement to replace"); return(null); } return(psiServices.DoTransaction(ExpandCommandName, () => { var expression = csharpContext.Expression.GetOperandThroughParenthesis().NotNull(); var newStatement = CreateStatement(factory, expression); Assertion.AssertNotNull(targetStatement, "targetStatement != null"); Assertion.Assert(targetStatement.IsPhysical(), "targetStatement.IsPhysical()"); // Sometimes statements produced by templates are unfinished (for example, because of // parentheses insertion mode in R#), so the created statements has error element at and, // prefixed with single-characted whitespace. We remove this whitespace here: var errorElement = newStatement.LastChild as IErrorElement; if (errorElement != null) { var whitespaceNode = errorElement.PrevSibling as IWhitespaceNode; if (whitespaceNode != null && !whitespaceNode.IsNewLine && whitespaceNode.GetText() == " ") { using (WriteLockCookie.Create(newStatement.IsPhysical())) { LowLevelModificationUtil.DeleteChild(whitespaceNode); } } } return targetStatement.ReplaceBy(newStatement); })); }
public PostfixUsingTemplateInfo([NotNull] string text, [NotNull] PostfixExpressionContext expression, bool shouldCreateVariable) : base(text, expression) { ShouldCreateVariable = shouldCreateVariable; }
public ForLoopPostfixTemplateInfo( [NotNull] string text, [NotNull] PostfixExpressionContext expression, [CanBeNull] string lengthPropertyName) : base(text, expression) { LengthPropertyName = lengthPropertyName; }