public override CSharpPostfixExpressionContext FixExpression(CSharpPostfixExpressionContext context)
{
var psiServices = Reference.GetPsiServices();
var expressionRange = ExecutionContext.GetDocumentRange(context.Expression);
var referenceRange = ExecutionContext.GetDocumentRange(Reference);
var textWithReference = expressionRange.SetEndTo(referenceRange.TextRange.EndOffset).GetText();
var indexOfReferenceDot = textWithReference.LastIndexOf('.');
if (indexOfReferenceDot <= 0)
{
return(context);
}
var realReferenceRange = referenceRange.SetStartTo(expressionRange.TextRange.StartOffset + indexOfReferenceDot);
var transactionManager = psiServices.Transactions.DocumentTransactionManager;
var document = expressionRange.Document;
// todo: make sure this is not in undo stack!
using (transactionManager.CreateTransactionCookie(DefaultAction.Commit, FixCommandName))
{
document.ReplaceText(realReferenceRange.TextRange, ")");
document.InsertText(expressionRange.TextRange.StartOffset, "unchecked(");
}
//using (psiServices.Solution.CreateTransactionCookie(DefaultAction.Commit, FixCommandName, NullProgressIndicator.Instance))
//{
//
//}
psiServices.Files.CommitAllDocuments();
var uncheckedExpression = TextControlToPsi.GetElement <IUncheckedExpression>(psiServices.Solution, document, expressionRange.TextRange.StartOffset + 1);
if (uncheckedExpression == null)
{
return(context);
}
var operand = uncheckedExpression.Operand;
psiServices.Transactions.Execute(FixCommandName, () =>
{
LowLevelModificationUtil.DeleteChild(operand);
LowLevelModificationUtil.ReplaceChildRange(uncheckedExpression, uncheckedExpression, operand);
});
Assertion.Assert(operand.IsPhysical(), "operand.IsPhysical()");
return(new CSharpPostfixExpressionContext(this, operand));
}
public override CSharpPostfixExpressionContext FixExpression(CSharpPostfixExpressionContext context)
{
var expression = context.Expression;
if (expression.Contains(Reference)) // x is T.bar => x is T
{
var psiServices = expression.GetPsiServices();
psiServices.Transactions.Execute(FixCommandName, () =>
{
var referenceName = (IReferenceName)Reference;
var qualifier = referenceName.Qualifier;
LowLevelModificationUtil.DeleteChild(qualifier); // remove first
LowLevelModificationUtil.ReplaceChildRange(referenceName, referenceName, qualifier);
});
}
return(context);
}
public override CSharpPostfixExpressionContext FixExpression(CSharpPostfixExpressionContext context)
{
var referenceExpression = (IReferenceExpression)Reference;
var expression = context.Expression;
if (expression.Parent == referenceExpression) // foo.bar => foo
{
var psiServices = expression.GetPsiServices();
psiServices.Transactions.Execute(FixCommandName, () =>
{
LowLevelModificationUtil.DeleteChild(expression);
LowLevelModificationUtil.ReplaceChildRange(referenceExpression, referenceExpression, expression);
});
Assertion.Assert(expression.IsPhysical(), "expression.IsPhysical()");
return(new CSharpPostfixExpressionContext(this, expression));
}
if (expression.Contains(referenceExpression)) // boo > foo.bar => boo > foo
{
var qualifier = referenceExpression.QualifierExpression;
var psiServices = expression.GetPsiServices();
psiServices.Transactions.Execute(FixCommandName, () =>
{
LowLevelModificationUtil.DeleteChild(qualifier);
LowLevelModificationUtil.ReplaceChildRange(referenceExpression, referenceExpression, qualifier);
});
Assertion.AssertNotNull(qualifier, "qualifier != null");
Assertion.Assert(qualifier.IsPhysical(), "qualifier.IsPhysical()");
}
return(context);
}
private IList <CSharpPostfixExpressionContext> BuildExpressions(
[NotNull] ITreeNode reference, [CanBeNull] out CSharpPostfixExpressionContext typeContext)
{
// build expression contexts
var expressionContexts = new List <CSharpPostfixExpressionContext>();
var endOffset = ToDocumentRange(reference).TextRange.EndOffset;
var previousStartOffset = -1;
for (ITreeNode node = myInnerExpression; node != null; node = node.Parent)
{
if (node is ICSharpStatement)
{
break;
}
var expression = node as ICSharpExpression;
if (expression == null || expression == reference)
{
continue;
}
var expressionRange = ExecutionContext.GetDocumentRange(expression);
if (!expressionRange.IsValid())
{
break; // stop when out of generated
}
if (expressionRange.TextRange.EndOffset > endOffset)
{
break; // stop when 'a.var + b'
}
if (expressionRange.TextRange.StartOffset == previousStartOffset)
{
break; // track start offset is changes when we are going up
}
previousStartOffset = expressionRange.TextRange.StartOffset;
// skip relational expressions like this: 'List<int.{here}>'
if (CSharpPostfixUtis.IsRelationalExpressionWithTypeOperand(expression))
{
continue;
}
var expressionContext = new CSharpPostfixExpressionContext(this, expression);
if (expressionContext.ReferencedElement is ITypeElement)
{
// skip types that are parts of 'List<T.>'-like expressions
if (!CSharpPostfixUtis.CanTypeBecameExpression(myInnerExpression))
{
continue;
}
if (myTypeExpression != null)
{
break; // should never happens
}
typeContext = expressionContext; // yeah, time to stop
return(EmptyList <CSharpPostfixExpressionContext> .InstanceList);
}
expressionContexts.Add(expressionContext);
if (expressionContext.CanBeStatement)
{
break;
}
}
typeContext = null;
return(expressionContexts.AsReadOnly());
}
public virtual CSharpPostfixExpressionContext FixExpression([NotNull] CSharpPostfixExpressionContext context)
{
return(context);
}
