public static DocumentRange ToDocumentRange([CanBeNull] this ReparsedCodeCompletionContext context, [NotNull] ITreeNode treeNode)
{
var documentRange = treeNode.GetDocumentRange();
if (context == null)
{
return(documentRange);
}
var reparsedTreeRange = treeNode.GetTreeTextRange();
var document = documentRange.Document;
if (document != null)
{
var originalDocRange = context.ToDocumentRange(reparsedTreeRange);
return(new DocumentRange(document, originalDocRange));
}
else
{
var originalGeneratedTreeRange = context.ToOriginalTreeRange(reparsedTreeRange);
var sandBox = treeNode.GetContainingNode <ISandBox>().NotNull("sandBox != null");
var contextNode = sandBox.ContextNode.NotNull("sandBox.ContextNode != null");
var containingFile = contextNode.GetContainingFile().NotNull("containingFile != null");
// todo: check for IFileImpl
var translator = containingFile.GetRangeTranslator();
var originalTreeRange = translator.GeneratedToOriginal(originalGeneratedTreeRange);
var originalDocRange = translator.OriginalFile.GetDocumentRange(originalTreeRange);
return(originalDocRange);
}
}
public static ISpecificCodeCompletionContext GetSpecificContext(
CodeCompletionContext context, ReparsedCodeCompletionContext unterminatedContext, PsiLanguageType customLanguageType = null)
{
var elementToComplete = unterminatedContext.TreeNode;
if (elementToComplete == null)
{
return(null);
}
var elementRange = elementToComplete.GetTreeTextRange();
var elementDocumentRange = unterminatedContext.ToDocumentRange(elementRange);
var referenceToComplete = unterminatedContext.Reference;
var referenceRange = referenceToComplete?.GetTreeTextRange() ?? elementRange;
var referenceDocumentRange = unterminatedContext.ToDocumentRange(referenceRange);
if (!referenceDocumentRange.IsValid())
{
return(null);
}
if (!referenceDocumentRange.Contains(context.EffectiveCaretDocumentOffset))
{
return(null);
}
if (!elementDocumentRange.Contains(context.EffectiveCaretDocumentOffset))
{
return(null);
}
var language = customLanguageType ?? PascalLanguage.Instance;
if (language == null)
{
return(null);
}
var referenceRanges = GetTextLookupRanges(context, referenceDocumentRange);
var elementRanges = GetTextLookupRanges(context, elementDocumentRange);
return(new PascalCodeCompletionContext(context, referenceRanges, elementRanges, unterminatedContext));
}
public PostfixTemplateAcceptanceContext([NotNull] ITreeNode reference,
[NotNull] ICSharpExpression expression, DocumentRange replaceRange,
bool forceMode, [NotNull] PostfixExecutionContext context)
{
myReparsedContext = context.ReparsedContext;
myMostInnerExpression = expression;
PostfixReferenceNode = reference;
ForceMode = forceMode;
PsiModule = context.PsiModule;
LookupItemsOwner = context.LookupItemsOwner;
MostInnerReplaceRange = replaceRange;
if (!replaceRange.IsValid())
{
var referenceExpression = reference as IReferenceExpression;
if (referenceExpression != null)
{
MostInnerReplaceRange =
ToDocumentRange(referenceExpression.QualifierExpression.NotNull()).SetEndTo(
ToDocumentRange(referenceExpression.Delimiter.NotNull()).TextRange.EndOffset);
}
var referenceName = reference as IReferenceName;
if (referenceName != null)
{
MostInnerReplaceRange =
ToDocumentRange(referenceName.Qualifier).SetEndTo(
ToDocumentRange(referenceName.Delimiter).TextRange.EndOffset);
}
}
// build expression contexts
var expressionContexts = new List<PrefixExpressionContext>();
var endOffset = Math.Max(
MostInnerReplaceRange.TextRange.EndOffset,
ToDocumentRange(reference).TextRange.EndOffset);
for (ITreeNode node = expression; node != null; node = node.Parent)
{
if (node is ICSharpStatement) break;
var expr = node as ICSharpExpression;
if (expr == null || expr == reference) continue;
var exprRange = myReparsedContext.ToDocumentRange(expr);
if (!exprRange.IsValid())
break; // stop when out of generated
if (exprRange.TextRange.EndOffset > endOffset)
break; // stop when 'a.var + b'
// skip relational expressions like this: 'List<int.{here}>'
if (CommonUtils.IsRelationalExpressionWithTypeOperand(expr)) continue;
var expressionContext = new PrefixExpressionContext(this, expr);
if (expressionContext.ReferencedElement is ITypeElement)
{
// skip types that are parts of 'List<T.>'-like expressions
if (!CommonUtils.CanTypeBecameExpression(expression)) continue;
}
expressionContexts.Add(expressionContext);
if (expressionContext.CanBeStatement) break;
}
Expressions = (expressionContexts.Count == 0)
? EmptyList<PrefixExpressionContext>.InstanceList
: expressionContexts.AsReadOnly();
}
public override DocumentRange GetDocumentRange(ITreeNode treeNode)
{
return(myReparsedContext.ToDocumentRange(treeNode));
}
private static TextRange GetTextRange(ITreeNode node, ReparsedCodeCompletionContext context = null)
{
if (context == null)
return node.GetDocumentRange().TextRange;
return context.ToDocumentRange(node.GetTreeTextRange());
}
