public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var file = this.TreeNode.GetContainingFile() as NTriplesFile;
if (file == null)
{
return(EmptySymbolTable.INSTANCE);
}
var uriString = (UriString)this.myOwner;
var @namespace = uriString.GetNamespace();
if (string.IsNullOrEmpty(@namespace))
{
var cache = this.myOwner.GetSolution().GetComponent <NTriplesCache>();
var psiServices = this.myOwner.GetPsiServices();
var elements = cache.GetAllUriIdentifiersInNamespace(@namespace)
.Select(
x => new UriIdentifierDeclaredElement(file, x.Namespace, x.LocalName, x.Info, psiServices));
var symbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
return(symbolTable);
}
return(EmptySymbolTable.INSTANCE);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
if (myQualifier == null && myIsFinalPart)
{
var name = GetName();
var symbolScope = mySymbolCache.GetSymbolScope(LibrarySymbolScope.FULL, true);
var declaredElements = symbolScope.GetElementsByShortName(name);
var symbolTable = ResolveUtil.CreateSymbolTable(declaredElements, 0);
// GetElementsByShortName is case insensitive, so filter by exact name, which is case sensitive.
// Then filter out any forwarded types. Unity has a lot of these, with types forwarded from
// UnityEngine.dll to UnityEngine.*Module.dll
// Note that filtering here means that filtered values are not treated as candidates and the errors
// are not shown. Use GetSymbolFilters for that
return(symbolTable.Filter(new ExactNameFilter(name), myForwardedTypesFilter));
}
// Use the global namespace if there's no qualifier. The base implementation would create a scope based on
// local using statements
if (myQualifier == null)
{
var symbolTable = GetGlobalNamespaceSymbolTable();
return(useReferenceName ? symbolTable.Filter(new ExactNameFilter(GetName())) : symbolTable);
}
return(base.GetReferenceSymbolTable(useReferenceName));
}
private void AddTokensToSymbolTable(ITreeNode tokenTypeClassFQNameNode)
{
myTokenTypeClassFqName = tokenTypeClassFQNameNode.GetText();
myTokenTypeClassFqName = myTokenTypeClassFqName.Substring(1, myTokenTypeClassFqName.Length - 2);
ICollection <ITypeElement> classes =
GetPsiServices().Symbols.GetSymbolScope(GetPsiModule(), this.GetResolveContext(), false, true).GetTypeElementsByCLRName(
myTokenTypeClassFqName);
IEnumerator <ITypeElement> enumerator = classes.GetEnumerator();
if (enumerator.MoveNext())
{
var tokenTypeClass = enumerator.Current as IClass;
if (tokenTypeClass != null)
{
IList <IDeclaredElement> elements = new List <IDeclaredElement>();
AddTokenElements(tokenTypeClass, elements);
while ((tokenTypeClass != null) && (tokenTypeClass.GetBaseClassType() != null) && (tokenTypeClass.GetBaseClassType().GetTypeElement() as IClass != null))
{
tokenTypeClass = tokenTypeClass.GetBaseClassType().GetTypeElement() as IClass;
AddTokenElements(tokenTypeClass, elements);
}
ISymbolTable tokenSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
myRuleSymbolTable = myRuleSymbolTable.Merge(tokenSymbolTable);
}
}
}
public ISymbolTable CreateOptionSymbolTable(bool ifFileReal)
{
if (ifFileReal)
{
IList <IDeclaredElement> optionDeclaredElements = new List <IDeclaredElement>();
foreach (string name in OptionDeclaredElements.FileOptionNames)
{
IDeclaredElement element = new OptionPropertyDeclaredElement(GetSourceFile(), name,
GetSourceFile().GetPsiServices());
optionDeclaredElements.Add(element);
}
if (optionDeclaredElements.Count > 0)
{
myOptionSymbolTable = ResolveUtil.CreateSymbolTable(optionDeclaredElements, 0);
}
optionDeclaredElements = new List <IDeclaredElement>();
foreach (string name in OptionDeclaredElements.RuleOptionNames)
{
IDeclaredElement element = new OptionPropertyDeclaredElement(GetSourceFile(), name,
GetSourceFile().GetPsiServices());
optionDeclaredElements.Add(element);
}
if (optionDeclaredElements.Count > 0)
{
myOptionSymbolTable = myOptionSymbolTable.Merge(ResolveUtil.CreateSymbolTable(optionDeclaredElements, 0));
}
return(myOptionSymbolTable);
}
return(EmptySymbolTable.INSTANCE);
}
private ISymbolTable CreateTokenSymbolTable()
{
CollectTokenDeclarations();
var cache = GetPsiServices().Solution.GetComponent <LexCache>();
IList <ILexSymbol> symbols = new List <ILexSymbol>();
if (GetSourceFile() != null)
{
CollectTokensInRelatedFiles(cache, symbols);
IList <IDeclaredElement> elements = myTokenDeclarations.Values.ToList();
foreach (var lexSymbol in symbols)
{
if (lexSymbol.SourceFile != GetSourceFile())
{
ITreeNode element =
lexSymbol.SourceFile.GetPsiFile <LexLanguage>(new DocumentRange(lexSymbol.SourceFile.Document, 0)).FindNodeAt(new TreeTextRange(new TreeOffset(lexSymbol.Offset), 1));
var tokenDeclaration = element.GetContainingNode <ITokenDeclaration>();
if (tokenDeclaration != null)
{
var declareedElement = tokenDeclaration.DeclaredElement;
elements.Add(declareedElement);
}
}
}
myTokenSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
}
else
{
myTokenSymbolTable = null;
}
return(myTokenSymbolTable);
}
private void AddTokensToSymbolTable(ITreeNode tokenTypeClassFQNameNode)
{
myTokenTypeClassFqName = tokenTypeClassFQNameNode.GetText();
myTokenTypeClassFqName = myTokenTypeClassFqName.Substring(1, myTokenTypeClassFqName.Length - 2);
ICollection <ITypeElement> classes =
GetPsiServices().CacheManager.GetDeclarationsCache(GetPsiModule(), false, true).GetTypeElementsByCLRName(
myTokenTypeClassFqName);
IEnumerator <ITypeElement> enumerator = classes.GetEnumerator();
if (enumerator.MoveNext())
{
var tokenTypeClass = enumerator.Current as IClass;
if (tokenTypeClass != null)
{
IEnumerable <IField> fields = tokenTypeClass.Fields;
IList <IDeclaredElement> elements = new List <IDeclaredElement>();
foreach (IField field in fields)
{
if (field.IsReadonly && field.IsStatic)
{
elements.Add(field);
}
}
ISymbolTable tokenSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
myRuleSymbolTable = myRuleSymbolTable.Merge(tokenSymbolTable);
}
}
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var declaredElements = GetPropertyDeclaredElements(useReferenceName);
if (declaredElements.Count == 0)
{
return(EmptySymbolTable.INSTANCE);
}
return(ResolveUtil.CreateSymbolTable(declaredElements, 0));
}
private ISymbolTable CreateRoleSymbolTable()
{
IList <IDeclaredElement> roleDeclaredElements = new List <IDeclaredElement>();
IList <string> roles = new List <string>();
ITreeNode child = FirstChild;
while (child != null)
{
var ruleDeclaration = child as IRuleDeclaration;
if (ruleDeclaration != null)
{
IExtrasDefinition extras = (ruleDeclaration).Extras;
if (extras != null)
{
ITreeNode extrasChild = extras.FirstChild;
while (extrasChild != null)
{
extrasChild = extrasChild.NextSibling;
var extraDefinition = extrasChild as IExtraDefinition;
if (extraDefinition != null)
{
IPathValue pathValue = (extraDefinition).PathValue;
if (pathValue != null)
{
ITreeNode pathElement = pathValue.FirstChild;
while (pathElement != null)
{
var element = pathElement as IPathElement;
if (element != null)
{
IRoleName roleName = (element).RoleName;
if ((roleName != null) && (!roles.Contains(roleName.GetText())))
{
roles.Add(roleName.GetText());
}
}
pathElement = pathElement.NextSibling;
}
}
}
}
}
}
child = child.NextSibling;
}
foreach (string role in roles)
{
IDeclaredElement element = new RoleDeclaredElement(this, role, GetPsiServices());
roleDeclaredElements.Add(element);
}
myRoleSymbolTable = ResolveUtil.CreateSymbolTable(roleDeclaredElements, 0);
return(myRoleSymbolTable);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var file = this.TreeNode.GetContainingFile() as NTriplesFile;
if (file == null)
{
return(EmptySymbolTable.INSTANCE);
}
var psiServices = file.GetPsiServices();
var cache = this.TreeNode.GetSolution().GetComponent <NTriplesCache>();
var uriList = cache.GetAllPrefixDeclarationSymbols().Select(s => s.Uri).Distinct().ToArray();
var elements = uriList.Select(u => new PrefixUriDeclaredElement(file, u, psiServices));
return(ResolveUtil.CreateSymbolTable(elements, 0));
}
public ISymbolTable CreateUriIdentifiersSymbolTable()
{
this.CollectUriIdentifiers();
if (this.GetSourceFile() != null)
{
var elements = this.myUriIdentifiers.Values.SelectMany(x => x);
this.myUriIdentifiersSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
}
else
{
this.myUriIdentifiersSymbolTable = null;
}
return(this.myUriIdentifiersSymbolTable);
}
public ISymbolTable CreatePrefixesSymbolTable()
{
this.CollectPrefixes();
if (this.GetSourceFile() != null)
{
Dictionary <string, IDeclaredElement> .ValueCollection elements = this.myPrefixes.Values;
this.myPrefixesSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
}
else
{
this.myPrefixesSymbolTable = null;
}
return(this.myPrefixesSymbolTable);
}
private ISymbolTable CreatePathSymbolTable()
{
IList <IDeclaredElement> pathDeclaredElements = new List <IDeclaredElement>();
var child = Paths as ITreeNode;
if (child != null)
{
child = child.FirstChild;
while (child != null)
{
var pathDeclaration = child as PathDeclaration;
if (pathDeclaration != null)
{
pathDeclaredElements.Add(pathDeclaration);
}
child = child.NextSibling;
}
}
myPathSymbolTable = ResolveUtil.CreateSymbolTable(pathDeclaredElements, 0);
myPathSymbolTable = myPathSymbolTable.Merge(FileRuleSymbolTable);
return(myPathSymbolTable);
}
public ISymbolTable CreateRulesSymbolTable()
{
CollectDeclarations();
if (GetSourceFile() != null)
{
Dictionary <string, IDeclaredElement> .ValueCollection elements = myDeclarations.Values;
myRuleSymbolTable = ResolveUtil.CreateSymbolTable(elements, 0);
}
else
{
myRuleSymbolTable = null;
}
var optionsDefinition = FirstChild as IOptionsDefinition;
if (optionsDefinition != null)
{
ITreeNode child = optionsDefinition.FirstChild;
ITreeNode tokenTypeClassFQNNode = null;
ITreeNode parserClassNameNode = null;
ITreeNode parserPackageNode = null;
ITreeNode treeInterfacesPackageNode = null;
ITreeNode treeClassesPackageNode = null;
ITreeNode visitorClassNameNode = null;
ITreeNode interfacePrefixNode = null;
ITreeNode visitorMethodSuffixNode = null;
ITreeNode visitorMethodPrefixNode = null;
while (child != null)
{
var optionDefinition = child as IOptionDefinition;
if (optionDefinition != null)
{
IOptionName optionName = optionDefinition.OptionName;
var token = (optionName.FirstChild as PsiTokenBase);
if (token.NodeType.Equals(PsiTokenType.STRING_LITERAL))
{
if ("\"tokenTypeClassFQName\"".Equals(token.GetText()))
{
tokenTypeClassFQNNode = optionDefinition.OptionStringValue;
}
if ("\"visitMethodPrefix\"".Equals(token.GetText()))
{
visitorMethodPrefixNode = optionDefinition.OptionStringValue;
}
}
if ("parserClassName".Equals(optionName.GetText()))
{
parserClassNameNode = optionDefinition.OptionStringValue;
}
if ("parserPackage".Equals(optionName.GetText()))
{
parserPackageNode = optionDefinition.OptionStringValue;
}
if ("psiInterfacePackageName".Equals(optionName.GetText()))
{
treeInterfacesPackageNode = optionDefinition.OptionStringValue;
}
if ("psiStubsPackageName".Equals(optionName.GetText()))
{
treeClassesPackageNode = optionDefinition.OptionStringValue;
}
if ("visitorClassName".Equals(optionName.GetText()))
{
visitorClassNameNode = optionDefinition.OptionStringValue;
}
if ("visitorMethodSuffix".Equals(optionName.GetText()))
{
visitorMethodSuffixNode = optionDefinition.OptionStringValue;
}
if ("\"interfaceNamePrefix\"".Equals(optionName.GetText()))
{
interfacePrefixNode = optionDefinition.OptionStringValue;
}
}
child = child.NextSibling;
}
if (tokenTypeClassFQNNode != null)
{
AddTokensToSymbolTable(tokenTypeClassFQNNode);
}
if ((parserPackageNode != null) && (parserClassNameNode != null))
{
AddDerivedElementsToSymbolTable(visitorMethodSuffixNode, treeInterfacesPackageNode, parserPackageNode, parserClassNameNode, treeClassesPackageNode, interfacePrefixNode, visitorMethodPrefixNode, visitorClassNameNode);
}
}
return(myRuleSymbolTable);
}
