protected CSharpPostfixTemplateContext(
[NotNull] ITreeNode reference, [NotNull] ICSharpExpression expression, [NotNull] PostfixTemplateExecutionContext executionContext)
: base(reference, executionContext)
{
myInnerExpression = expression;
myExpressions = BuildExpressions(Reference, out myTypeExpression);
}
private static PostfixTemplateContext TryReparseWith([NotNull] ISolution solution, [NotNull] ITextControl textControl, [NotNull] string reparseString)
{
var offset = textControl.Caret.Offset();
var document = textControl.Document;
try
{
document.InsertText(offset, reparseString);
solution.GetPsiServices().Files.CommitAllDocuments();
foreach (var position in TextControlToPsi.GetElements <ITreeNode>(solution, document, offset))
{
var templateContextFactory = LanguageManager.Instance.TryGetService <IPostfixTemplateContextFactory>(position.Language);
if (templateContextFactory != null)
{
var executionContext = new PostfixTemplateExecutionContext(
solution, textControl, position.GetSettingsStore(), reparseString, false);
return(templateContextFactory.TryCreate(position, executionContext));
}
}
return(null);
}
finally
{
var reparseRange = TextRange.FromLength(offset, reparseString.Length);
document.DeleteText(reparseRange);
}
}
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;
}
public PostfixTemplateContext TryCreate(ITreeNode position, PostfixTemplateExecutionContext executionContext)
{
if (!(position is ICSharpIdentifier))
{
return(null);
}
// expr.__
var referenceExpression = position.Parent as IReferenceExpression;
if (referenceExpression != null && referenceExpression.Delimiter != null)
{
var qualifierExpression = referenceExpression.QualifierExpression;
if (qualifierExpression != null)
{
return(TryCreateFromReferenceExpression(executionContext, qualifierExpression, referenceExpression));
}
}
// String.__
var referenceName = position.Parent as IReferenceName;
if (referenceName != null && referenceName.Qualifier != null && referenceName.Delimiter != null)
{
var typeUsage = referenceName.Parent as ITypeUsage;
if (typeUsage != null)
{
var expression = typeUsage.Parent as ICSharpExpression;
if (expression != null)
{
return(new CSharpReferenceNamePostfixTemplateContext(referenceName, expression, executionContext));
}
}
}
// string.__
var brokenStatement = FindBrokenStatement(position);
if (brokenStatement != null)
{
var expressionStatement = brokenStatement.PrevSibling as IExpressionStatement;
if (expressionStatement != null)
{
var expression = FindExpressionBrokenByKeyword(expressionStatement);
if (expression != null)
{
return(new CSharpBrokenStatementPostfixTemplateContext(brokenStatement, expression, executionContext));
}
}
}
return(null);
}
private static PostfixTemplateContext TryCreateFromReferenceExpression(
[NotNull] PostfixTemplateExecutionContext executionContext, [NotNull] ICSharpExpression qualifierExpression, [NotNull] IReferenceExpression referenceExpression)
{
// protect from 'o.M(.var)'
var invocation = qualifierExpression as IInvocationExpression;
if (invocation != null && invocation.LPar != null && invocation.RPar == null)
{
var argument = invocation.Arguments.LastOrDefault();
if (argument != null && argument.Expression == null)
{
return(null);
}
}
// protect from 'smth.var\n(someCode).InBraces()'
invocation = referenceExpression.Parent as IInvocationExpression;
if (invocation != null)
{
for (ITokenNode lpar = invocation.LPar,
token = invocation.InvokedExpression.NextSibling as ITokenNode;
token != null && token != lpar && token.IsFiltered();
token = token.NextSibling as ITokenNode)
{
if (token.GetTokenType() == CSharpTokenType.NEW_LINE)
{
return(null);
}
}
}
// protect from 'doubleDot..var'
var qualifierReference = qualifierExpression as IReferenceExpression;
if (qualifierReference != null && qualifierReference.NameIdentifier == null)
{
return(null);
}
return(new CSharpReferenceExpressionPostfixTemplateContext(referenceExpression, qualifierExpression, executionContext));
}
public PostfixTemplateInfo(
[NotNull] string text, [NotNull] IEnumerable <PostfixExpressionContext> expressions,
PostfixTemplateTarget target = PostfixTemplateTarget.Expression)
{
Multiplier = 0;
myText = text.ToLowerInvariant();
myShortcut = text;
myTarget = target;
myImages = new List <PostfixExpressionContextImage>();
foreach (var expressionContext in expressions)
{
myImages.Add(new PostfixExpressionContextImage(expressionContext));
myExecutionContext = expressionContext.PostfixContext.ExecutionContext;
}
if (myExecutionContext == null)
{
throw new ArgumentException("Expecting non-empty sequence of expressions", "expressions");
}
}
public CSharpReferenceExpressionPostfixTemplateContext(
[NotNull] IReferenceExpression reference, [NotNull] ICSharpExpression expression, [NotNull] PostfixTemplateExecutionContext executionContext)
: base(reference, expression, executionContext)
{
}
public void Accept(ITextControl textControl, TextRange nameRange, LookupItemInsertType insertType,
Suffix suffix, ISolution solution, bool keepCaretStill)
{
// todo: carefully review and document all of this :\
var reparseString = Info.ReparseString;
// so we inserted '.__' and get '2 + 2.__' just like in code completion reparse
textControl.Document.InsertText(nameRange.EndOffset, reparseString, TextModificationSide.RightSide);
solution.GetPsiServices().Files.CommitAllDocuments();
var executionContext = new PostfixTemplateExecutionContext(
solution, textControl, Info.ExecutionContext.SettingsStore, Info.ReparseString, Info.ExecutionContext.IsPreciseMode);
PostfixTemplateContext postfixContext = null;
foreach (var element in TextControlToPsi.GetElements <ITreeNode>(solution, textControl.Document, nameRange.EndOffset))
{
var contextFactory = LanguageManager.Instance.TryGetService <IPostfixTemplateContextFactory>(element.Language);
if (contextFactory == null)
{
continue;
}
postfixContext = contextFactory.TryCreate(element, executionContext);
if (postfixContext != null)
{
break;
}
}
// todo: [R#] good feature id, looks at source templates 'Accept()'
TipsManager.Instance.FeatureIsUsed(
"Plugin.ControlFlow.PostfixTemplates." + Info.Text, textControl.Document, solution);
Assertion.AssertNotNull(postfixContext, "postfixContext != null");
var expressions = FindOriginalContexts(postfixContext);
Assertion.Assert(expressions.Count > 0, "expressions.Count > 0");
if (expressions.Count > 1 && myExpressionIndex == -1)
{
// rollback document changes to hide reparse string from user
var chooser = solution.GetComponent <ExpressionChooser>();
var postfixRange = GetPostfixRange(textControl, nameRange);
var postfixText = textControl.Document.GetText(postfixRange);
textControl.Document.ReplaceText(postfixRange, string.Empty);
chooser.Execute(
EternalLifetime.Instance, textControl, expressions, postfixText,
ExpressionSelectTitle, continuation: index =>
{
myExpressionIndex = index;
// yep, run accept recursively, now with selected item index
var locks = solution.GetComponent <IShellLocks>();
const string commandName = "PostfixTemplates.Accept";
locks.ReentrancyGuard.ExecuteOrQueue(commandName, () =>
{
locks.ExecuteWithReadLock(() =>
{
var processor = solution.GetComponent <ICommandProcessor>();
using (processor.UsingCommand(commandName))
{
var text = postfixText.Substring(0, postfixText.Length - reparseString.Length);
// todo: don't like it very much, is there a better way to solve this?
textControl.Document.InsertText( // bring back ".name__"
postfixRange.StartOffset, text, TextModificationSide.RightSide);
// argh!
Accept(textControl, nameRange, insertType, suffix, solution, keepCaretStill);
}
});
});
});
return;
}
Assertion.Assert(myExpressionIndex >= 0, "myExpressionIndex >= 0");
Assertion.Assert(myExpressionIndex < expressions.Count, "myExpressionIndex < expressions.Count");
var expressionContext = expressions[myExpressionIndex];
ITreeNode newNode;
using (WriteLockCookie.Create())
{
var fixedContext = postfixContext.FixExpression(expressionContext);
var expression = fixedContext.Expression;
Assertion.Assert(expression.IsPhysical(), "expression.IsPhysical()");
newNode = ExpandPostfix(fixedContext);
Assertion.AssertNotNull(newNode, "newNode != null");
Assertion.Assert(newNode.IsPhysical(), "newNode.IsPhysical()");
}
AfterComplete(textControl, newNode);
}
public CSharpBrokenStatementPostfixTemplateContext(
[NotNull] ITreeNode reference, [NotNull] ICSharpExpression expression, [NotNull] PostfixTemplateExecutionContext executionContext)
: base(reference, expression, executionContext)
{
}
