private IIntellisenseResult Finalize(IIntellisenseContext context, IntellisenseData.IntellisenseData intellisenseData)
{
Contracts.AssertValue(context);
Contracts.AssertValue(intellisenseData);
DType expectedType = intellisenseData.ExpectedType;
TypeMatchPriority(expectedType, intellisenseData.Suggestions);
TypeMatchPriority(expectedType, intellisenseData.SubstringSuggestions);
intellisenseData.Suggestions.Sort();
intellisenseData.SubstringSuggestions.Sort();
List <IntellisenseSuggestion> resultSuggestions = intellisenseData.Suggestions.Distinct().ToList();
IEnumerable <IntellisenseSuggestion> resultSubstringSuggestions = intellisenseData.SubstringSuggestions.Distinct();
resultSuggestions.AddRange(resultSubstringSuggestions);
TypeFilter(expectedType, intellisenseData.MatchingStr, ref resultSuggestions);
foreach (var handler in intellisenseData.CleanupHandlers)
{
handler.Run(context, intellisenseData, resultSuggestions);
}
return(new IntellisenseResult(intellisenseData, resultSuggestions));
}
private void GetFunctionAndTypeInformation(IIntellisenseContext context, TexlNode curNode, TexlBinding binding, out TexlFunction curFunc, out int argIndex, out int argCount, out DType expectedType, out IsValidSuggestion isValidSuggestionFunc)
{
Contracts.AssertValue(context);
Contracts.AssertValue(curNode);
Contracts.AssertValue(binding);
if (!FindCurFuncAndArgs(curNode, context.CursorPosition, binding, out curFunc, out argIndex, out argCount, out expectedType))
{
curFunc = null;
argIndex = 0;
argCount = 0;
expectedType = DType.Unknown;
}
DType binaryOpExpectedType;
if (TryGetExpectedTypeForBinaryOp(binding, curNode, context.CursorPosition, out binaryOpExpectedType))
{
expectedType = binaryOpExpectedType;
}
if (curFunc != null)
{
isValidSuggestionFunc = (intellisenseData, suggestion) => intellisenseData.CurFunc.IsSuggestionTypeValid(intellisenseData.ArgIndex, suggestion.Type);
}
else
{
isValidSuggestionFunc = Helper.DefaultIsValidSuggestionFunc;
}
}
public IntellisenseData(IIntellisenseContext context, DType expectedType, TexlBinding binding, TexlFunction curFunc, TexlNode curNode, int argIndex, int argCount, IsValidSuggestion isValidSuggestionFunc, IList <DType> missingTypes, List <CommentToken> comments)
{
Contracts.AssertValue(context);
Contracts.AssertValid(expectedType);
Contracts.AssertValue(binding);
Contracts.AssertValue(curNode);
Contracts.Assert(0 <= context.CursorPosition && context.CursorPosition <= context.InputText.Length);
Contracts.AssertValue(isValidSuggestionFunc);
Contracts.AssertValueOrNull(missingTypes);
Contracts.AssertValueOrNull(comments);
_expectedType = expectedType;
_suggestions = new IntellisenseSuggestionList();
_substringSuggestions = new IntellisenseSuggestionList();
_binding = binding;
_comments = comments;
_curFunc = curFunc;
_curNode = curNode;
_script = context.InputText;
_cursorPos = context.CursorPosition;
_argIndex = argIndex;
_argCount = argCount;
_isValidSuggestionFunc = isValidSuggestionFunc;
_matchingStr = string.Empty;
_matchingLength = 0;
_replacementStartIndex = context.CursorPosition;
_missingTypes = missingTypes;
BoundTo = string.Empty;
_cleanupHandlers = new List <ISpecialCaseHandler>();
}
private bool TryInitializeIntellisenseContext(IIntellisenseContext context, TexlBinding binding, Formula formula, out IntellisenseData.IntellisenseData data)
{
Contracts.AssertValue(context);
TexlNode currentNode = TexlNode.FindNode(formula.ParseTree, context.CursorPosition);
TexlFunction curFunc;
int argIndex, argCount;
DType expectedType;
IsValidSuggestion isValidSuggestionFunc;
GetFunctionAndTypeInformation(context, currentNode, binding, out curFunc, out argIndex, out argCount, out expectedType, out isValidSuggestionFunc);
data = CreateData(context, expectedType, binding, curFunc, currentNode, argIndex, argCount, isValidSuggestionFunc, binding.GetExpandEntitiesMissingMetadata(), formula.Comments);
return(true);
}
protected internal virtual IntellisenseData.IntellisenseData CreateData(IIntellisenseContext context, DType expectedType, TexlBinding binding, TexlFunction curFunc, TexlNode curNode, int argIndex, int argCount, IsValidSuggestion isValidSuggestionFunc, IList <DType> missingTypes, List <CommentToken> comments)
{
return(new IntellisenseData.IntellisenseData(context, expectedType, binding, curFunc, curNode, argIndex, argCount, isValidSuggestionFunc, missingTypes, comments));
}
public bool Run(IIntellisenseContext context, IntellisenseData.IntellisenseData intellisenseData, List <IntellisenseSuggestion> suggestions)
{
Contracts.AssertValue(context);
Contracts.AssertValue(context.InputText);
Contracts.AssertValue(intellisenseData);
Contracts.AssertValue(suggestions);
string script = context.InputText;
Contracts.Assert(_tokenStartIndex < script.Length);
if (_requireTokenStartWithQuote && script[_tokenStartIndex] != '"')
{
return(false);
}
int matchEndIndex = -1;
bool foundAny = false;
var iterateSuggestions = suggestions.ToArray();
foreach (var suggestion in iterateSuggestions)
{
int i, j;
bool found = false;
for (i = _tokenStartIndex, j = 0; i < script.Length; i++, j++)
{
if (j >= suggestion.Text.Length)
{
// The input text for this parameter has exceeded the suggestion and we should filter it out
found = false;
break;
}
if (script[i] != suggestion.Text[j])
{
string curChar = script.Substring(i, 1);
if (curChar != TexlLexer.PunctuatorParenClose && curChar != TexlLexer.LocalizedInstance.LocalizedPunctuatorListSeparator)
{
found = false;
}
break;
}
found = true;
}
foundAny |= found;
if (found && matchEndIndex < i)
{
matchEndIndex = i;
}
if (!found && i != script.Length)
{
suggestions.Remove(suggestion);
}
}
if (!foundAny || matchEndIndex <= _tokenStartIndex)
{
return(false);
}
intellisenseData.Suggestions.Clear();
intellisenseData.SubstringSuggestions.Clear();
intellisenseData.SetMatchArea(_tokenStartIndex, matchEndIndex);
return(true);
}
