/// <summary>
/// Called when a PSI element changes.
/// </summary>
/// <param name="treeNode">The tree node that changed.</param>
/// <param name="psiChangedElementType">The type of the PSI change.</param>
private void OnPsiChanged(ITreeNode treeNode, PsiChangedElementType psiChangedElementType)
{
if (treeNode != null && psiChangedElementType == PsiChangedElementType.SourceContentsChanged)
{
OnPsiFileChanged(treeNode.GetContainingFile());
}
}
/// <summary>
/// Called when a PSI file changes.
/// </summary>
/// <param name="treeNode">The tree node that changed.</param>
/// <param name="psiChangedElementType">The type of the PSI change.</param>
private void OnPhysicalPsiChanged(ITreeNode treeNode, PsiChangedElementType psiChangedElementType)
{
if (treeNode != null && psiChangedElementType == PsiChangedElementType.CONTENTS_CHANGED)
{
OnPsiFileChanged(treeNode.GetContainingFile());
}
}
protected override void InvalidateOnPhysicalChange(PsiChangedElementType elementType)
{
if (elementType == PsiChangedElementType.InvalidateCached)
{
return;
}
_predefinedTypes.Clear();
}
public void OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
var sourceFile = elementContainingChanges?.GetSourceFile();
if (sourceFile != null)
{
AddToProcess(sourceFile);
}
}
protected override void InvalidateOnPhysicalChange(PsiChangedElementType elementType)
{
// Note that this method gets also called on settings changes.
// Here we clear the complete cache ony _any_ change. This strategy makes cache invalidation easy (least error prone) and
// is absolutely sufficient for the overall performance of ImplicitNullabilityConfigurationEvaluator as the calculation
// itself is not the problem, only the vast amount of accesses (per module).
_dict.Clear();
}
public void OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges != null)
{
var sourceFile = elementContainingChanges.GetSourceFile();
if (sourceFile != null)
{
MarkAsDirty(sourceFile);
}
}
}
/// <summary>Called when a PSI element changes.</summary>
/// <param name="treeNode">The tree node that changed.</param>
/// <param name="psiChangedElementType">The type of the PSI change.</param>
private void OnPsiChanged([CanBeNull] ITreeNode treeNode, PsiChangedElementType psiChangedElementType)
{
if (treeNode == null)
{
return;
}
if (psiChangedElementType != PsiChangedElementType.SourceContentsChanged)
{
return;
}
OnPsiFileChanged(treeNode.GetContainingFile());
}
public void OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges != null)
{
myShellLocks.AssertWriteAccessAllowed();
IPsiSourceFile projectFile = elementContainingChanges.GetSourceFile();
if (projectFile != null && Accepts(projectFile))
{
myDirtyFiles.Add(projectFile);
}
}
}
public void OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges == null)
{
return;
}
var sourceFile = elementContainingChanges.GetSourceFile();
Assertion.Assert(sourceFile != null, "sourceFile != null");
MarkAsDirty(sourceFile);
}
void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges == null)
{
return;
}
var sourceFile = elementContainingChanges.GetSourceFile();
if ((sourceFile != null) && sourceFile.PrimaryPsiLanguage.Is <JavaScriptLanguage>())
{
lock (_lock)
{
_dirtyFiles.Add(sourceFile);
}
}
}
void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (type == PsiChangedElementType.Whitespaces)
{
return;
}
if (elementContainingChanges == null)
{
return;
}
var sourceFile = elementContainingChanges.GetSourceFile();
if (sourceFile == null)
{
return;
}
lock (lockObject)
{
dirtyFiles.Add(sourceFile);
}
}
/// <summary>
/// Called when a PSI element changes.
/// </summary>
/// <param name="treeNode">The tree node that changed.</param>
/// <param name="psiChangedElementType">The type of the PSI change.</param>
private void OnPsiChanged(ITreeNode treeNode, PsiChangedElementType psiChangedElementType) {
if (treeNode != null && psiChangedElementType == PsiChangedElementType.ContentsChanged)
OnPsiFileChanged(treeNode.GetContainingFile());
}
public void OnPsiChange(JetBrains.ReSharper.Psi.Tree.ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges != null)
{
}
}
void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges == null) return;
var sourceFile = elementContainingChanges.GetSourceFile();
if ((sourceFile != null) && sourceFile.PrimaryPsiLanguage.Is<JavaScriptLanguage>())
{
lock (_lock)
{
_dirtyFiles.Add(sourceFile);
}
}
}
void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
}
/// <summary>
/// Called when a PSI file changes.
/// </summary>
/// <param name="treeNode">The tree node that changed.</param>
/// <param name="psiChangedElementType">The type of the PSI change.</param>
private void OnPhysicalPsiChanged(ITreeNode treeNode, PsiChangedElementType psiChangedElementType)
{
if (treeNode != null && psiChangedElementType == PsiChangedElementType.CONTENTS_CHANGED)
OnPsiFileChanged(treeNode.GetContainingFile());
}
///<summary>
///
/// Check if the PSI caches should be invalidated on this change
///
///</summary>
///
public override bool ShouldInvalidatePsiCache(IElement element, PsiChangedElementType elementType)
{
// return base.ShouldInvalidatePsiCache(element, elementType);
return true;
}
public void OnPsiChange(JetBrains.ReSharper.Psi.Tree.ITreeNode elementContainingChanges, PsiChangedElementType type)
{
if (elementContainingChanges != null)
{
}
}
public bool NeedCacheUpdate(ITreeNode elementContainingChanges, PsiChangedElementType type) => true;
void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
{
}
