protected override bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var stringLiteral = element as IJavaScriptLiteralExpression;
if (stringLiteral == null)
{
return(false);
}
var file = element.GetContainingFile();
if (file == null)
{
return(false);
}
// TODO: We can't use this, due to losing data when we reparse for code completion
// When we start code completion, the tree node is reparsed with new text inserted,
// so that references have something to attach to. Reparsing works with IChameleon
// blocks that allow for resync-ing in-place. Our AngularJs nodes don't have any
// chameleon blocks (for JS, it's the Block class - anything with braces) so we end
// up re-parsing the file. This creates a new IFile, (in a sandbox that allows access
// to the original file's reference provider) but it doesn't copy the user data. We
// could theoretically look for a containing sandbox, get the context node and try
// and get the user data there, but that just makes it feel like this is the wrong
// solution. I think maybe this should be a reference provider for HTML, not AngularJs.
// It would have the context of the attribute name, but should really work with the
// injected AngularJs language, if only to see that it's a string literal
//var originalAttributeType = file.UserData.GetData(AngularJsFileData.OriginalAttributeType);
//if (originalAttributeType != elementTypes.AngularJsUrlType.Name)
// return false;
return(true);
}
protected override bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var stringLiteral = element as IJavaScriptLiteralExpression;
if (stringLiteral == null)
return false;
var file = element.GetContainingFile();
if (file == null)
return false;
// TODO: We can't use this, due to losing data when we reparse for code completion
// When we start code completion, the tree node is reparsed with new text inserted,
// so that references have something to attach to. Reparsing works with IChameleon
// blocks that allow for resync-ing in-place. Our AngularJs nodes don't have any
// chameleon blocks (for JS, it's the Block class - anything with braces) so we end
// up re-parsing the file. This creates a new IFile, (in a sandbox that allows access
// to the original file's reference provider) but it doesn't copy the user data. We
// could theoretically look for a containing sandbox, get the context node and try
// and get the user data there, but that just makes it feel like this is the wrong
// solution. I think maybe this should be a reference provider for HTML, not AngularJs.
// It would have the context of the attribute name, but should really work with the
// injected AngularJs language, if only to see that it's a string literal
//var originalAttributeType = file.UserData.GetData(AngularJsFileData.OriginalAttributeType);
//if (originalAttributeType != elementTypes.AngularJsUrlType.Name)
// return false;
return true;
}
protected NamedThingsSearchSourceFileProcessorWorkaround(ITreeNode root, ICollection <string> wordsInText,
ICollection <string> referenceNames, IDeclaredElementsSet elements)
{
myRoot = root;
myReferenceProvider = GetReferenceProvider2((TreeElement)root);
myElements = elements;
var languageService = root.Language.LanguageService();
if (languageService != null)
{
myCaseSensitive = languageService.IsCaseSensitive;
}
myCaseSensitive = myCaseSensitive && elements.CaseSensitive;
if (wordsInText != null && wordsInText.Count > 0)
{
myStringSearchers = wordsInText.Where(word => !string.IsNullOrEmpty(word))
.Select(word => new StringSearcher(word, myCaseSensitive)).ToArray();
}
if (referenceNames != null && referenceNames.Count > 0)
{
myReferenceNameContainer = new ReferenceNameContainer(referenceNames, myCaseSensitive);
}
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var literal = element as ILiteralExpression;
if (literal != null && literal.ConstantValue.IsString())
return names.Contains((string) literal.ConstantValue.Value);
return false;
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is IJavaScriptLiteralExpression literal && literal.IsStringLiteral())
{
return(names.Contains(literal.GetStringValue() ?? string.Empty));
}
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is IPlainScalarNode methodNameValue && CanHaveReference(methodNameValue))
{
return(names.Contains(methodNameValue.Text.GetText()));
}
return(false);
}
public virtual bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is ILiteralExpression literal && literal.ConstantValue.IsString())
{
return(names.Contains((string)literal.ConstantValue.Value));
}
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is IJsonNewLiteralExpression literal && literal.ConstantValueType == ConstantValueTypes.String)
{
return(names.Contains(literal.GetStringValue() ?? string.Empty));
}
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (!(element is VarNode && element.Parent is FDecl))
{
return(false);
}
return(names.Contains(((VarNode)element).GetText()));
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var literalExpression = element as ILiteralExpression;
if (literalExpression == null)
return false;
var referenceName = literalExpression.ConstantValue.Value as string;
return referenceName != null && names.Contains(referenceName);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (!(element is SpringNodeIdentifier variable))
{
return(false);
}
var name = variable.GetText();
return(names.Contains(name));
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is SpringVariableReferenceElement refElem)
{
string name = refElem.GetText();
return(names.Contains(name));
}
return(false);
}
// Names is likely to contain the name of the class. All we have in the file is the guid
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var guidValue = element as IPlainScalarNode;
var guidEntry = FlowMapEntryNavigator.GetByValue(guidValue);
var flowIDMap = FlowMappingNodeNavigator.GetByEntrie(guidEntry);
var blockMappingEntry = BlockMappingEntryNavigator.GetByValue(flowIDMap);
return(guidEntry?.Key.MatchesPlainScalarText("guid") == true &&
blockMappingEntry?.Key.MatchesPlainScalarText("m_Script") == true);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is PascalVariable variable)
{
var name = variable.GetText();
return(names.Contains(name));
}
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var literal = element as ILiteralExpression;
if (literal != null && literal.ConstantValue.IsString())
{
return(names.Contains((string)literal.ConstantValue.Value));
}
return(false);
}
public override bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
if (element is ILiteralExpression literal && literal.ConstantValue.IsString())
{
// Note that this is case insensitive. I don't think it really matters, as resolving will handle case
// insensitivity correctly
return(names.HasAnyNameIn((string)literal.ConstantValue.Value));
}
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
var literalExpression = element as ILiteralExpression;
if (literalExpression == null)
{
return(false);
}
var referenceName = literalExpression.ConstantValue.Value as string;
return(referenceName != null && names.Contains(referenceName));
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
return(element is SpringReferenceNodeElement reference && names.Contains(reference.GetText()));
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names)
{
return(false);
}
public bool HasReference(ITreeNode element, IReferenceNameContainer names) => !GetReferences(element, ReferenceCollection.Empty).IsEmpty;
