public IDeclaredElement GetDeclaredElement()
{
var typeElement = GetTypeElement();
if (typeElement == null)
{
return(null);
}
using (CompilationContextCookie.GetOrCreate(myProject.GetResolveContext()))
{
foreach (var member in typeElement.EnumerateMembers(myMethodName, typeElement.CaseSensitiveName))
{
var method = member as IMethod;
if (method == null)
{
continue;
}
if (method.IsAbstract)
{
continue;
}
if (method.TypeParameters.Count > 0)
{
continue;
}
return(member);
}
return(null);
}
}
public override RdUsageGroup CreateModel(IOccurrence occurrence, IOccurrenceBrowserDescriptor descriptor)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
if (occurrence is ReferenceOccurrence referenceOccurrence &&
referenceOccurrence.PrimaryReference is IUnityYamlReference reference)
{
var document = reference.ComponentDocument;
var sourceFile = document.GetSourceFile();
if (sourceFile == null || !sourceFile.IsValid())
{
return(EmptyModel());
}
var anchor = UnitySceneDataUtil.GetAnchorFromBuffer(document.GetTextAsBuffer());
if (anchor == null)
{
return(EmptyModel());
}
return(CreateModel(UnityObjectPsiUtil.GetGameObjectPathFromComponent(myUnitySceneDataLocalCache, sourceFile, anchor)));
}
}
return(EmptyModel());
}
private List <IGenerator> GetApplicableGeneratorsFromProvider()
{
var result = new List <IGenerator>();
foreach (IGenerator generator in _generatorsProvider.GetAllGenerators())
{
if (generator.Visible)
{
generator.DataProvider = _generatorDataProvider;
using (CompilationContextCookie.GetOrCreate(generator.DataProvider.PsiFile.GetResolveContext()))
{
bool generatorAvailable = false;
try
{
generatorAvailable = generator.IsAvailable();
}
catch (Exception e)
{
// Pass to exceptions.
}
if (generatorAvailable)
{
result.Add(generator);
}
}
}
}
return(result);
}
public override RdUsageGroup CreateModel(IOccurrence occurrence, IOccurrenceBrowserDescriptor descriptor)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
if (occurrence is UnityAssetOccurrence assetOccurrence && !assetOccurrence.SourceFile.GetLocation().IsAsset())
{
using (ReadLockCookie.Create())
{
var solution = occurrence.GetSolution();
var processor = solution.GetComponent <AssetHierarchyProcessor>();
var consumer = new UnityScenePathGameObjectConsumer();
processor.ProcessSceneHierarchyFromComponentToRoot(assetOccurrence.OwningElementLocation, consumer, true, true);
string name = "...";
if (consumer.NameParts.Count > 0)
{
name = string.Join("\\", consumer.NameParts);
}
return(CreateModel(name));
}
}
}
return(EmptyModel());
}
private List <HandlerCompletionItem> DetermineHandlers(ISolution solution)
{
var handlers = new List <HandlerCompletionItem>();
using (ReadLockCookie.Create())
{
var projects = solution.GetAllProjects();
foreach (var project in projects)
{
if (!LambdaFinder.IsLambdaProjectType(project))
{
continue;
}
var psiModules = project.GetPsiModules();
foreach (var psiModule in psiModules)
{
using (CompilationContextCookie.OverrideOrCreate(psiModule.GetContextFromModule()))
{
var scope = _symbolCache.GetSymbolScope(psiModule, false, true);
var namespaces = scope.GlobalNamespace.GetNestedNamespaces(scope);
foreach (var @namespace in namespaces)
{
ProcessNamespace(@namespace, scope, handlers);
}
}
}
}
}
return(handlers);
}
public override string ToString()
{
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var de = DeclaredElementPointer.FindDeclaredElement();
if (de == null)
{
return("INVALID");
}
if (IsRelatedToScriptableObject())
{
var value = InspectorVariableUsage.Value.GetFullPresentation(GetSolution(), DeclaredElementPointer.FindDeclaredElement(), true);
return($"{de.ShortName} = {value}");
}
else
{
var value = InspectorVariableUsage.Value.GetPresentation(GetSolution(), DeclaredElementPointer.FindDeclaredElement(), true);
return($"{de.ShortName} = {value}");
}
}
}
}
private IEnumerable <UnityType> GetBaseUnityTypes(UnityTypes types, ITypeElement type, Version normalisedVersion)
{
return(types.Types.Where(t =>
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
return t.SupportsVersion(normalisedVersion) && type.IsDescendantOf(t.GetTypeElement(type.Module));
}));
}
public ITypeElement GetTypeElement([NotNull] IPsiModule module)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var type = TypeFactory.CreateTypeByCLRName(myTypeName, module);
return(type.GetTypeElement());
}
}
public ITypeElement GetTypeElement(KnownTypesCache knownTypesCache, [NotNull] IPsiModule module)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var type = knownTypesCache.GetByClrTypeName(myTypeName, module);
return(type.GetTypeElement());
}
}
private static ITypeElement GetTypeElement(IClrTypeName typeName, KnownTypesCache knownTypesCache,
IPsiModule module)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var type = knownTypesCache.GetByClrTypeName(typeName, module);
return(type.GetTypeElement());
}
}
public override string ToString()
{
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var value = InspectorVariableUsage.Value.GetPresentation(GetSolution(), DeclaredElementPointer.FindDeclaredElement(), true);
return($"{InspectorVariableUsage.Name} = {value}");
}
}
}
public void NavigateToMethod(MethodReference methodReference)
{
var declaredElement = MethodDeclaredElement(methodReference);
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetOrCreate(UniversalModuleReferenceContext.Instance))
{
declaredElement.Navigate(true);
}
}
}
private void OnChanged(IReadOnlyCollection <ITypeElement> changedTypes)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var linkedTypes = changedTypes.SelectMany(LinkedTypesUtil.GetLinkedTypes).ToList();
var relevantTests = linkedTypes.Select(x => _unitTestElementStuff.GetElement(x)).WhereNotNull();
foreach (var relevantTest in relevantTests)
{
_unitTestResultManager.MarkOutdated(relevantTest);
}
}
}
public override RdUsageGroup CreateModel(IOccurrence occurrence, IOccurrenceBrowserDescriptor descriptor)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
if (occurrence is ReferenceOccurrence referenceOccurrence &&
referenceOccurrence.PrimaryReference is IUnityYamlReference reference)
{
return(CreateModel(UnityObjectPsiUtil.GetComponentName(reference.ComponentDocument)));
}
}
return(EmptyModel());
}
private void InvalidateReferencingModules(IPsiModule psiModule)
{
using (CompilationContextCookie.GetOrCreate(psiModule.GetContextFromModule()))
{
var resolveContext = CompilationContextCookie.GetContext();
foreach (var psiModuleReference in PsiModules.GetReverseModuleReferences(psiModule, resolveContext))
{
if (myPsiModules.TryGetValue(psiModuleReference.Module, out var moduleSymbols))
{
moduleSymbols.Invalidate();
}
}
}
}
// NOTE: This method assumes that the type is not a descendant of UnityEngine.Object!
private bool IsSerializableType([CanBeNull] ITypeElement type, [NotNull] IProject project, bool isTypeUsage,
bool hasSerializeReference = false)
{
if (!(type is IStruct || type is IClass))
{
return(false);
}
if (isTypeUsage)
{
// Type usage (e.g. field declaration) is stricter. Means it must be a concrete type with no type
// parameters, unless the type usage is for [SerializeReference], which allows abstract types
if (type is IModifiersOwner modifiersOwner && modifiersOwner.IsAbstract && !hasSerializeReference)
{
return(false);
}
// Unity 2020.1 allows fields to have generic types. It's currently undocumented, but there are no
// limitations on the number of type parameters, or even nested type parameters. The base type needs to
// be serializable, but type parameters don't (if a non-serializable type parameter is used as a field,
// it just isn't serialised).
// https://blogs.unity3d.com/2020/03/17/unity-2020-1-beta-is-now-available-for-feedback/
var unityVersion = myUnityVersion.GetActualVersion(project);
if (unityVersion < new Version(2020, 1) && type is ITypeParametersOwner typeParametersOwner &&
typeParametersOwner.TypeParameters.Count > 0)
{
return(false);
}
}
if (type is IClass @class && @class.IsStaticClass())
{
return(false);
}
// System.Dictionary is special cased and excluded. We can see this in UnitySerializationLogic.cs in the
// reference source repo. It also excludes anything with a full name beginning "System.", which includes
// "System.Version" (which is marked [Serializable]). However, it doesn't exclude string, int, etc.
// TODO: Rewrite this whole section to properly mimic UnitySerializationLogic.cs
var name = type.GetClrName();
if (Equals(name, KnownTypes.SystemVersion) || Equals(name, PredefinedType.GENERIC_DICTIONARY_FQN))
{
return(false);
}
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
return(type.HasAttributeInstance(PredefinedType.SERIALIZABLE_ATTRIBUTE_CLASS, true));
}
public override string ToString()
{
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var declaredElement = DeclaredElementPointer.FindDeclaredElement();
if (declaredElement == null)
{
return("Invalid");
}
return(DeclaredElementMenuItemFormatter.FormatText(declaredElement, declaredElement.PresentationLanguage, out _).Text);
}
}
}
protected override void DoTest(Lifetime lifetime, IProject testProject)
{
var position = GetCaretPosition();
IProjectFile item;
if (position == null)
{
item = testProject.GetSubItemsRecursively().OfType <IProjectFile>().First("No project file");
}
else
{
item = (IProjectFile)testProject.FindProjectItemsByLocation(position.FileName)
.Single("No project file", "More than one project file");
}
var swea = SolutionAnalysisService.GetInstance(Solution);
Assert.IsTrue(item.Kind == ProjectItemKind.PHYSICAL_FILE);
using (TestPresentationMap.Cookie())
using (swea.RunAnalysisCookie())
{
using (var definition = Lifetime.Define(lifetime))
{
var boundstore = ChangeSettingsTemporarily(definition.Lifetime).BoundStore;
boundstore.SetValue(HighlightingSettingsAccessor.CalculateUnusedTypeMembers, InplaceUsageAnalysis);
ITextControl textControl = position != null
? OpenTextControl(definition.Lifetime, position)
: OpenTextControl(definition.Lifetime, item);
{
swea.ReanalyzeFile(item.ToSourceFile());
using (CompilationContextCookie.GetOrCreate(textControl.GetContext(Solution)))
{
ExecuteWithGold(item, writer =>
{
var highlightings = GetHighlightings(textControl);
DumpQuickFixesAvailability(writer, highlightings, textControl, Solution);
});
}
}
}
}
}
public override RdUsageGroup CreateModel(IOccurrence occurrence, IOccurrenceBrowserDescriptor descriptor)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
if (occurrence is UnityAssetOccurrence assetOccurrence)
{
var hierarchyContainer = assetOccurrence.GetSolution()?.GetComponent <AssetDocumentHierarchyElementContainer>();
var element = hierarchyContainer?.GetHierarchyElement(assetOccurrence.OwningElementLocation, true);
if (element is IComponentHierarchy componentHierarchyElement)
{
return(CreateModel(AssetUtils.GetComponentName(myMetaFileGuidCache, componentHierarchyElement)));
}
}
}
return(EmptyModel());
}
public void NavigateToClass(UClass uClass)
{
var classSymbol = GetClassSymbol(uClass.Name.Data);
if (classSymbol == null)
{
return;
}
var declaredElement = new CppParserSymbolDeclaredElement(_psiServices, classSymbol);
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetOrCreate(UniversalModuleReferenceContext.Instance))
{
declaredElement.Navigate(true);
}
}
}
public IEnumerable <IProject> GetProjectDependencies(IT4File file)
{
file.AssertContainsNoIncludeContext();
var sourceFile = file.LogicalPsiSourceFile.NotNull();
var projectFile = sourceFile.ToProjectFile().NotNull();
var psiModule = sourceFile.PsiModule;
var resolveContext = projectFile.SelectResolveContext();
using (CompilationContextCookie.GetOrCreate(resolveContext))
{
return(PsiModules
.GetModuleReferences(psiModule)
.Select(it => it.Module)
.OfType <IProjectPsiModule>()
.Select(it => it.Project)
.AsList());
}
}
private bool IsHandlerExists(Lifetime lifetime, int projectId, string className, string methodName)
{
var indicator = NullProgressIndicator.CreateCancellable(lifetime);
using (TryReadLockCookie.Create(indicator, _locks,
() => !lifetime.IsAlive || _locks.ContentModelLocks.IsWriteLockRequested))
{
var project = _projectModelViewHost.GetItemById <IProject>(projectId);
Assertion.AssertNotNull(project, "project instance should not be null");
_logger.Verbose($"Searching handler with name '{className}.{methodName}' in the project {project}...");
var psiModules = project.GetPsiModules();
foreach (var psiModule in psiModules)
{
using (CompilationContextCookie.OverrideOrCreate(psiModule.GetContextFromModule()))
{
var scope = _symbolCache.GetSymbolScope(psiModule, false, true);
var typeElements = scope.GetElementsByQualifiedName(className).OfType <IClass>();
foreach (var typeElement in typeElements)
{
InterruptableActivityCookie.CheckAndThrow(indicator);
foreach (var method in typeElement.Methods)
{
if (method.ShortName != methodName)
{
continue;
}
if (!LambdaFinder.IsSuitableLambdaMethod(method))
{
continue;
}
return(true);
}
}
}
}
}
return(false);
}
private void InvalidateReferencingModules(IPsiModule psiModule)
{
if (PsiModulesCaches.IsEmpty())
{
return;
}
// todo: reuse FcsProjectProvider references
using (CompilationContextCookie.GetOrCreate(psiModule.GetContextFromModule()))
{
var resolveContext = CompilationContextCookie.GetContext();
foreach (var psiModuleReference in PsiModules.GetReverseModuleReferences(psiModule, resolveContext))
{
if (PsiModulesCaches.TryGetValue(psiModuleReference.Module, out var moduleSymbols))
{
moduleSymbols.Invalidate();
}
}
}
}
public override IDeclaredElement?GetDeclaredElement()
{
if (Specification.BehaviorType == null)
{
return(null);
}
using (CompilationContextCookie.OverrideOrCreate(Project.GetResolveContext(TargetFrameworkId)))
{
var behaviorType = UT.Facade.TypeCache.GetTypeElement(
Project,
TargetFrameworkId,
new ClrTypeName(Specification.BehaviorType),
false,
true);
return(behaviorType?
.EnumerateMembers <IField>(FieldName, behaviorType.CaseSensitiveName)
.FirstOrDefault());
}
}
public static bool TryExecuteGenerator(IGenerator generator, Action executeAction)
{
using (CompilationContextCookie.GetOrCreate(generator.DataProvider.PsiFile.GetResolveContext()))
{
try
{
executeAction();
return(true);
}
catch (GeneratorErrorException e)
{
MessageBox.ShowError(e.Message);
}
catch (Exception e)
{
MessageBox.ShowError(e.ToString());
}
}
return(false);
}
public override IEnumerable <BulbMenuItem> GetBulbMenuItems(IHighlighter highlighter)
{
var solution = Shell.Instance.GetComponent <SolutionsManager>().Solution;
if (solution == null)
{
return(EmptyList <BulbMenuItem> .InstanceList);
}
var textControlManager = solution.GetComponent <ITextControlManager>();
var textControl = textControlManager.FocusedTextControl.Value;
var daemon = solution.GetComponent <IDaemon>();
if (daemon.GetHighlighting(highlighter) is NukeMarkOnGutter highlighting)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
return(highlighting.GetBulbMenuItems(solution, textControl, (InvisibleAnchor)Anchor.NotNull()));
}
return(EmptyList <BulbMenuItem> .InstanceList);
}
public override IEnumerable <BulbMenuItem> GetBulbMenuItems(IHighlighter highlighter)
{
var solution = Shell.Instance.GetComponent <SolutionsManager>().Solution;
if (solution == null)
{
return(EmptyList <BulbMenuItem> .InstanceList);
}
var unityImplicitUsageHighlightingContributor = solution.GetComponent <UnityHighlightingContributor>();
var daemon = solution.GetComponent <IDaemon>();
if (daemon.GetHighlighting(highlighter) is UnityGutterMarkInfo highlighting)
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
return(unityImplicitUsageHighlightingContributor.CreateBulbItemsForUnityDeclaration(highlighting
.Declaration));
}
return(EmptyList <BulbMenuItem> .InstanceList);
}
public override string ToString()
{
var pointer = DeclaredElementPointer;
if (pointer is null)
{
return("Invalid");
}
using (ReadLockCookie.Create())
{
using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet())
{
var element = pointer.FindDeclaredElement();
if (element == null)
{
return("Invalid");
}
var language = element.PresentationLanguage;
return(DeclaredElementMenuItemFormatter.FormatText(element, language, out _)?.Text ?? "Invalid");
}
}
}
public void Execute(IDataContext dataContext, DelegateExecute nextExecute)
{
using (ReadLockCookie.Create())
{
var solution = dataContext.GetData(ProjectModelDataConstants.SOLUTION);
if (solution == null)
{
nextExecute();
return;
}
using (CompilationContextCookie.Create(GetResolveContext(dataContext, solution)))
{
// The real code creates a modal loop here, so can use the data
// We use a modeless loop, so make sure the data context lasts
// for longer
var dataContextLifetimeDefinition = Lifetimes.Define(lifetime);
var extendedContext = dataContext.Prolongate(dataContextLifetimeDefinition.Lifetime);
var toExecute = GetWorkflowListToExecute(extendedContext);
if (toExecute == null || toExecute.Count == 0)
{
dataContextLifetimeDefinition.Terminate();
nextExecute();
return;
}
if (toExecute.HasMoreThan(1) || handler.ShowMenuWithOneItem)
{
ExecuteGroup(extendedContext, toExecute, dataContextLifetimeDefinition);
return;
}
handler.Execute(extendedContext, toExecute.Single().First);
dataContextLifetimeDefinition.Terminate();
}
}
}
protected override void AugmentQuickInfoSessionCore(
IQuickInfoSession session,
IList <object> quickInfoContent,
IDocumentMarkup documentMarkup,
TooltipFormattingProvider tooltipFormattingProvider,
out ITrackingSpan applicableToSpan)
{
applicableToSpan = null;
ITextSnapshot textSnapshot = TextBuffer.CurrentSnapshot;
TextRange textRange = GetCurrentTextRange(session, textSnapshot);
IShellLocks shellLocks = Shell.Instance.GetComponent <IShellLocks>();
Span? finalSpan = null;
void GetEnhancedTooltips()
{
using (shellLocks.UsingReadLock()) {
IDocument document = documentMarkup.Document;
var presenter = new MultipleTooltipContentPresenter(tooltipFormattingProvider.GetTooltipFormatting(), document);
IContextBoundSettingsStore settings = document.GetSettings();
ISolution solution = TryGetCurrentSolution();
bool hasIdentifierTooltipContent = false;
var resolveContext = solution != null?document.GetContext(solution) : UniversalModuleReferenceContext.Instance;
using (CompilationContextCookie.GetOrCreate(resolveContext)) {
if (solution != null)
{
DocumentRange documentRange = textRange.CreateDocumentRange(document);
IdentifierContentGroup contentGroup = GetIdentifierContentGroup(documentRange, solution, settings);
if (contentGroup != null)
{
foreach (IdentifierTooltipContent content in contentGroup.Identifiers)
{
presenter.AddIdentifierTooltipContent(content);
finalSpan = content.TrackingRange.ToSpan().Union(finalSpan);
hasIdentifierTooltipContent = true;
}
if (contentGroup.ArgumentRole != null)
{
presenter.AddArgumentRoleTooltipContent(contentGroup.ArgumentRole);
if (finalSpan == null)
{
// Only track the argument role if we have nothing else displayed.
// See https://github.com/MrJul/ReSharper.EnhancedTooltip/issues/70
finalSpan = contentGroup.ArgumentRole.TrackingRange.ToSpan();
}
}
}
}
List <Vs10Highlighter> highlighters = documentMarkup.GetHighlightersOver(textRange).OfType <Vs10Highlighter>().ToList();
foreach (Vs10Highlighter highlighter in highlighters)
{
IEnumerable <IReSharperTooltipContent> contents = GetTooltipContents(highlighter, highlighter.Range, documentMarkup, solution, hasIdentifierTooltipContent);
foreach (IReSharperTooltipContent content in contents)
{
if (presenter.TryAddReSharperContent(content))
{
finalSpan = content.TrackingRange.ToSpan().Union(finalSpan);
}
}
}
}
var vsSquiggleContents = session.RetrieveVsSquiggleContents()
.OfType <string>()
.ToSet();
bool ignoredFirstVsElement = false;
foreach (object content in quickInfoContent)
{
if (content == null)
{
continue;
}
// ignore existing R# elements
if (content is IQuickInfoContent)
{
continue;
}
var contentFullName = content.GetType().FullName;
// ignore the first VS element, as it's the identifier tooltip and we already have one
if (hasIdentifierTooltipContent && !ignoredFirstVsElement)
{
if (contentFullName == VsFullTypeNames.ContainerElement || /* VS 2017 >= 15.8 */
contentFullName == VsFullTypeNames.QuickInfoDisplayPanel || /* VS 2015 and VS 2017 < 15.8 */
content is ITextBuffer /* VS2012 and VS2013 */)
{
ignoredFirstVsElement = true;
continue;
}
}
// ignore Roslyn's bulb info placeholder (interactive tooltip "press ctrl+.")
if (contentFullName == VsFullTypeNames.LightBulbQuickInfoPlaceHolder)
{
continue;
}
if (contentFullName == VsFullTypeNames.QuickInfoDisplayPanel)
{
presenter.AddVsIdentifierContent(new VsIdentifierContent(content));
}
else if (content is string stringContent && vsSquiggleContents.Contains(stringContent))
{
presenter.AddVsSquiggleContent(new VsSquiggleContent(stringContent));
}
