private void HighlightDeclaration(IDeclaration declaration, HighlightingsConsumer consumer)
{
var nameDocumentRange = declaration.GetNameDocumentRange();
if (nameDocumentRange.IsValid())
{
consumer.ConsumeHighlighting(HIGHLIGHTING_ID, nameDocumentRange);
}
}
private void HighlightDeclarationsInFile(IDeclaredElement declaredElement, IPsiView psiView,
HighlightingsConsumer consumer)
{
foreach (var psiSourceFile in psiView.SortedSourceFiles)
{
foreach (var declaration in declaredElement.GetDeclarationsIn(psiSourceFile))
{
HighlightDeclaration(declaration, consumer);
}
}
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView,
HighlightingsConsumer consumer)
{
var psiView = psiDocumentRangeView.View <FSharpLanguage>();
var document = psiDocumentRangeView.DocumentRangeFromMainDocument.Document;
var token = psiView.GetSelectedTreeNode <FSharpIdentifierToken>();
if (token == null)
{
var wildPat = psiView.GetSelectedTreeNode <IWildPat>();
if (wildPat != null)
{
consumer.ConsumeHighlighting(HighlightingId, wildPat.GetDocumentRange());
}
return;
}
// todo: type parameters: t<$caret$type> or t<'$caret$ttype>
var fsFile = psiView.GetSelectedTreeNode <IFSharpFile>();
var sourceFile = fsFile?.GetSourceFile();
if (sourceFile == null)
{
return;
}
var symbol = fsFile.GetSymbol(token.GetTreeStartOffset().Offset);
if (symbol == null)
{
return;
}
var checkResults =
fsFile.CheckerService.TryGetStaleCheckResults(sourceFile, OpName)?.Value ??
fsFile.GetParseAndCheckResults(true, OpName)?.Value.CheckResults;
var ranges = new HashSet <DocumentRange>();
AddUsagesRanges(symbol, ranges, checkResults, document, fsFile);
if (symbol is FSharpMemberOrFunctionOrValue mfv && mfv.IsConstructor &&
mfv.DeclaringEntity?.Value is FSharpEntity entity)
{
AddUsagesRanges(entity, ranges, checkResults, document, fsFile);
}
foreach (var range in ranges)
{
consumer.ConsumeHighlighting(HighlightingId, range);
}
}
protected override void CollectHighlightings(
IPsiDocumentRangeView psiDocumentRangeView,
HighlightingsConsumer consumer)
{
var psiView = psiDocumentRangeView.View <CSharpLanguage>();
var selectedArgument = psiView.GetSelectedTreeNode <ICSharpArgument>();
if (selectedArgument == null)
{
return;
}
var invocationExpressions = psiView.ContainingNodes <IInvocationExpression>();
foreach (var invocationExpression in invocationExpressions)
{
var templateArgument = invocationExpression.GetTemplateArgument();
if (templateArgument == null)
{
continue;
}
if (templateArgument.IndexOf() > selectedArgument.IndexOf())
{
continue;
}
var templateString = templateArgument.TryGetTemplateText();
if (templateString == null)
{
continue;
}
var messageTemplate = _messageTemplate.Parse(templateString);
if (selectedArgument == templateArgument)
{
HighlightByNamedPlaceholder(
consumer,
psiView,
templateArgument,
messageTemplate,
invocationExpression.ArgumentList.Arguments);
}
else
{
HighlightByArgument(consumer, selectedArgument, templateArgument, messageTemplate);
}
}
}
protected override void CollectHighlightings(
IPsiDocumentRangeView psiDocumentRangeView,
HighlightingsConsumer consumer)
{
var psiView = psiDocumentRangeView.View <CSharpLanguage>();
var selectedArgument = psiView.GetSelectedTreeNode <ICSharpArgument>();
if (selectedArgument == null)
{
return;
}
var invocationExpression = psiView.GetSelectedTreeNode <IInvocationExpression>();
var templateArgument = invocationExpression?.GetTemplateArgument();
if (templateArgument == null)
{
return;
}
if (templateArgument.IndexOf() > selectedArgument.IndexOf())
{
return;
}
var templateString = StringLiteralAltererUtil.TryCreateStringLiteralByExpression(templateArgument.Value)
?.Expression.GetUnquotedText();
if (templateString == null)
{
return;
}
var messageTemplate = _messageTemplate.Parse(templateString);
if (selectedArgument == templateArgument)
{
HighlightByNamedPlaceholder(
consumer,
psiView,
templateArgument,
messageTemplate,
invocationExpression.ArgumentList.Arguments);
}
else
{
HighlightByArgument(consumer, selectedArgument, templateArgument, messageTemplate);
}
}
public override Action GetDataProcessAction(
HighlightingProlongedLifetime prolongedLifetime,
IPsiDocumentRangeView psiDocumentRangeView)
{
var consumer = new HighlightingsConsumer();
CollectHighlightings(psiDocumentRangeView, consumer);
return(() =>
{
foreach (var highlightInfo in consumer.HighlightInfos)
{
CaretDependentFeaturesUtil.HighlightForLifetime(prolongedLifetime.Lifetime, highlightInfo);
}
});
}
private static void HighlightByArgument(
HighlightingsConsumer consumer,
ICSharpArgument selectedArgument,
ICSharpArgument templateArgument,
MessageTemplate messageTemplate)
{
var argumentIndex = selectedArgument.IndexOf() - templateArgument.IndexOf() - 1;
var namedProperties = messageTemplate.NamedProperties;
var positionalProperties = messageTemplate.PositionalProperties;
if (namedProperties != null && argumentIndex < namedProperties.Length)
{
var property = namedProperties[argumentIndex];
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
templateArgument.GetTokenInformation(property).DocumentRange);
}
else if (positionalProperties != null)
{
foreach (var property in positionalProperties)
{
if (!property.TryGetPositionalValue(out int position))
{
continue;
}
if (position != argumentIndex)
{
continue;
}
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
templateArgument.GetTokenInformation(property).DocumentRange);
}
}
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
selectedArgument.GetDocumentRange());
}
private void HighlightReferencesInFile(IDeclaredElement declaredElement,
IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
{
var searchDomain = SearchDomainFactory.Instance.CreateSearchDomain(psiDocumentRangeView.SortedSourceFiles);
var elements = new[] { new DeclaredElementInstance(declaredElement) };
var searchRequest = new SearchSingleFileDeclaredElementRequest(elements, elements, searchDomain);
foreach (var occurrence in searchRequest.Search(NullProgressIndicator.Create()))
{
if (!(occurrence is ReferenceOccurrence referenceOccurrence))
{
continue;
}
var primaryReference = referenceOccurrence.PrimaryReference;
if (primaryReference == null)
{
continue;
}
var documentRange = primaryReference.GetDocumentRange();
consumer.ConsumeHighlighting(HIGHLIGHTING_ID, documentRange);
}
}
private static void HighlightByNamedPlaceholder(
HighlightingsConsumer consumer,
IPsiView psiView,
ICSharpArgument templateArgument,
MessageTemplate messageTemplate,
TreeNodeCollection <ICSharpArgument> arguments)
{
if (messageTemplate.NamedProperties != null)
{
var(selectedToken, index) = GetSelectedToken(psiView, templateArgument, messageTemplate.NamedProperties);
if (selectedToken == null)
{
return;
}
var argumentIndex = templateArgument.IndexOf() + index + 1;
if (arguments.Count <= argumentIndex)
{
return;
}
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
templateArgument.GetTokenInformation(selectedToken).DocumentRange);
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
arguments[argumentIndex].GetDocumentRange());
}
else if (messageTemplate.PositionalProperties != null)
{
var(selectedToken, _) = GetSelectedToken(psiView, templateArgument, messageTemplate.PositionalProperties);
if (selectedToken == null)
{
return;
}
if (!selectedToken.TryGetPositionalValue(out int position))
{
return;
}
foreach (var property in messageTemplate.PositionalProperties)
{
if (!property.TryGetPositionalValue(out int propertyPosition))
{
continue;
}
if (propertyPosition != position)
{
continue;
}
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
templateArgument.GetTokenInformation(property).DocumentRange);
}
var argumentIndex = templateArgument.IndexOf() + position + 1;
if (arguments.Count <= argumentIndex)
{
return;
}
consumer.ConsumeHighlighting(
GeneralHighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
arguments[argumentIndex].GetDocumentRange());
}
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
{
var view = psiDocumentRangeView.View <CSharpLanguage>();
var node = view.GetSelectedTreeNode <IFunctionDeclaration>();
if (node == null)
{
return;
}
var solution = psiDocumentRangeView.Solution;
var swa = solution.GetComponent <SolutionAnalysisService>();
if (!UnityCallGraphUtil.IsSweaCompleted(swa))
{
return;
}
var contextProvider = solution.GetComponent <PerformanceCriticalContextProvider>();
var settingsStore = psiDocumentRangeView.GetSettingsStore();
if (contextProvider.IsContextAvailable == false)
{
return;
}
if (settingsStore.GetValue((UnitySettings key) => key.PerformanceHighlightingMode) !=
PerformanceHighlightingMode.CurrentMethod)
{
return;
}
var kind = UnityCallGraphUtil.GetProcessKindForGraph(swa);
if (contextProvider.HasContext(node, kind))
{
consumer.ConsumeHighlighting(new UnityPerformanceContextHighlightInfo(node.GetDocumentRange()));
}
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
{
var settingsStore = psiDocumentRangeView.GetSettingsStore();
if (!settingsStore.GetValue((UnitySettings key) => key.EnablePerformanceCriticalCodeHighlighting))
{
return;
}
if (settingsStore.GetValue((UnitySettings key) => key.PerformanceHighlightingMode) != PerformanceHighlightingMode.CurrentMethod)
{
return;
}
var view = psiDocumentRangeView.View <CSharpLanguage>();
var node = view.GetSelectedTreeNode <IFunctionDeclaration>();
if (node != null)
{
var declaredElement = node.DeclaredElement;
if (declaredElement == null)
{
return;
}
var solution = psiDocumentRangeView.Solution;
var swa = solution.GetComponent <SolutionAnalysisService>();
var callGraphExtension = solution.GetComponent <CallGraphSwaExtensionProvider>();
var callGraphAnalyzer = solution.GetComponent <PerformanceCriticalCodeCallGraphMarksProvider>();
var elementIdProvider = solution.GetComponent <IElementIdProvider>();
var usageChecker = swa.UsageChecker;
if (usageChecker == null)
{
return;
}
var elementId = elementIdProvider.GetElementId(declaredElement);
if (!elementId.HasValue)
{
return;
}
if (callGraphExtension.IsMarkedByCallGraphRootMarksProvider(callGraphAnalyzer.Id, false, elementId.Value))
{
consumer.ConsumeHighlighting(new UnityPerformanceContextHighlightInfo(node.GetDocumentRange()));
}
}
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView,
HighlightingsConsumer consumer)
{
var psiView = psiDocumentRangeView.View <FSharpLanguage>();
var fsFile = psiView.GetSelectedTreeNode <IFSharpFile>();
if (fsFile == null)
{
return;
}
var document = psiDocumentRangeView.DocumentRangeFromMainDocument.Document;
var token = psiView.GetSelectedTreeNode <FSharpIdentifierToken>();
if (token == null)
{
return;
}
// todo: type parameters: t<$caret$type> or t<'$caret$ttype>
// todo: namespaces, use R# search?
var offset = token.GetTreeStartOffset().Offset;
var symbol = fsFile.GetSymbolDeclaration(offset) ?? fsFile.GetSymbolUse(offset);
if (symbol == null)
{
return;
}
var sourceFile = fsFile.GetSourceFile();
if (sourceFile == null)
{
return;
}
var checkResults =
fsFile.CheckerService.TryGetStaleCheckResults(sourceFile)?.Value ??
fsFile.GetParseAndCheckResults(true)?.Value.CheckResults;
var symbolUsages = checkResults?.GetUsesOfSymbolInFile(symbol).RunAsTask();
foreach (var symbolUse in symbolUsages ?? EmptyArray <FSharpSymbolUse> .Instance)
{
var treeOffset = document.GetTreeEndOffset(symbolUse.RangeAlternate);
var usageToken = fsFile.FindTokenAt(treeOffset - 1) as FSharpIdentifierToken;
if (usageToken == null)
{
continue;
}
var tokenType = usageToken.GetTokenType();
if ((tokenType == FSharpTokenType.GREATER || tokenType == FSharpTokenType.GREATER_RBRACK) &&
!(symbol is FSharpMemberOrFunctionOrValue mfv &&
mfv.CompiledName.Equals("op_GreaterThan", StringComparison.Ordinal)))
{
continue; // found usage of generic symbol with specified type parameter
}
consumer.ConsumeHighlighting(HighlightingId, usageToken.GetDocumentRange());
}
}
private void HighlightDeclarationsInFile(IDeclaredElement declaredElement, IPsiView psiView, HighlightingsConsumer consumer)
{
// There are no IDeclarations for this declared element, try and find the associated string literal expression
var asmdefNameDeclaredElement = declaredElement as AsmDefNameDeclaredElement;
if (asmdefNameDeclaredElement == null)
{
return;
}
foreach (var psiSourceFile in psiView.SortedSourceFiles)
{
if (psiSourceFile != asmdefNameDeclaredElement.SourceFile)
{
continue;
}
var primaryPsiFile = psiSourceFile.GetPrimaryPsiFile();
var node = primaryPsiFile?.FindNodeAt(TreeTextRange.FromLength(
new TreeOffset(asmdefNameDeclaredElement.DeclarationOffset),
asmdefNameDeclaredElement.ShortName.Length));
var literalExpression = node?.GetContainingNode <IJavaScriptLiteralExpression>();
if (literalExpression != null)
{
HighlightFoundDeclaration(literalExpression, consumer);
}
}
}
protected abstract void HighlightFoundDeclaration(TLiteralNode node, HighlightingsConsumer consumer);
protected override void HighlightFoundDeclaration(IJavaScriptLiteralExpression literalExpression, HighlightingsConsumer consumer)
{
var range = literalExpression.GetUnquotedDocumentRange();
if (range.IsValid())
{
consumer.ConsumeHighlighting(HIGHLIGHTING_ID, range);
}
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
{
if (myLiteralExpressionUnderCaret != null)
{
HighlightFoundDeclaration(myLiteralExpressionUnderCaret, consumer);
}
else
{
var psiView = psiDocumentRangeView.View <JsonLanguage>(PsiLanguageCategories.Dominant);
HighlightDeclarationsInFile(myDeclaredElement, psiView, consumer);
}
HighlightReferencesInFile(myDeclaredElement, psiDocumentRangeView, consumer);
}
protected override void CollectHighlightings(IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
{
var view = psiDocumentRangeView.View <CSharpLanguage>();
var node = view.GetSelectedTreeNode <IFunctionDeclaration>();
if (node == null)
{
return;
}
var solution = psiDocumentRangeView.Solution;
var settingsStore = psiDocumentRangeView.GetSettingsStore();
if (settingsStore.GetValue((UnitySettings key) => key.PerformanceHighlightingMode) !=
PerformanceHighlightingMode.CurrentMethod)
{
return;
}
var contextProvider = solution.GetComponent <PerformanceCriticalContextProvider>();
var swea = solution.GetComponent <SolutionAnalysisService>();
var declaredElement = node.DeclaredElement;
if (contextProvider.IsMarkedSweaDependent(declaredElement, swea))
{
consumer.ConsumeHighlighting(new UnityPerformanceContextHighlightInfo(node.GetDocumentRange()));
}
}
