#525521701

Committed 08 Nov 2025 06:46AM UTC coverage: 75.91% (+0.003%) from 75.907%

Build # #525521701

Build Type

push

github

Committed by

hurricup

Commit Message

#CAMELCADE-30057 Added diagnostics for computation

Run Details

14752 of 22627 branches covered (65.2%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 1 file covered. (50.0%)

19 existing lines in 8 files now uncovered.

31078 of 37747 relevant lines covered (82.33%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.74

/plugin/backend/src/main/java/com/perl5/lang/perl/idea/project/PerlNamesBackendCache.java

/*
 * Copyright 2015-2025 Alexandr Evstigneev
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.perl5.lang.perl.idea.project;

import com.intellij.ide.lightEdit.LightEdit;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ReadAction;
import com.intellij.openapi.application.WriteAction;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.project.DumbService;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ModuleRootEvent;
import com.intellij.openapi.roots.ModuleRootListener;
import com.intellij.psi.PsiManager;
import com.intellij.psi.PsiTreeChangeAdapter;
import com.intellij.psi.PsiTreeChangeEvent;
import com.intellij.psi.impl.source.resolve.ResolveCache;
import com.intellij.util.messages.MessageBusConnection;
import com.intellij.util.ui.update.MergingUpdateQueue;
import com.intellij.util.ui.update.Update;
import com.perl5.lang.perl.psi.stubs.namespaces.PerlLightNamespaceIndex;
import com.perl5.lang.perl.psi.stubs.namespaces.PerlNamespaceIndex;
import com.perl5.lang.perl.psi.stubs.subsdeclarations.PerlSubDeclarationIndex;
import com.perl5.lang.perl.psi.stubs.subsdefinitions.PerlLightSubDefinitionsIndex;
import com.perl5.lang.perl.psi.stubs.subsdefinitions.PerlSubDefinitionsIndex;
import com.perl5.lang.perl.util.PerlPackageUtilCore;
import com.perl5.lang.perl.util.PerlTimeLogger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.TestOnly;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;


public class PerlNamesBackendCache implements PerlNamesCache {
  private static final Logger LOG = Logger.getInstance(PerlNamesBackendCache.class);
  private final MergingUpdateQueue myQueue = new MergingUpdateQueue("Perl names cache updater", 1000, true, null, this, null, false);
  private final Project myProject;
  private final AtomicBoolean myIsUpdating = new AtomicBoolean(false);
  private volatile Set<String> myKnownSubs = Collections.emptySet();
  private volatile Set<String> myKnownNamespaces = Collections.emptySet();
  private final AtomicBoolean myIsDisposed = new AtomicBoolean(false);

  public PerlNamesBackendCache(Project project) {
    myProject = project;
    if (LightEdit.owns(myProject) || project.isDefault()) {
      return;
    }
    MessageBusConnection connection = project.getMessageBus().connect(this);
    connection.subscribe(ModuleRootListener.TOPIC, new ModuleRootListener() {
      @Override
      public void rootsChanged(@NotNull ModuleRootEvent event) {
        queueUpdate();
      }
    });
    connection.subscribe(DumbService.DUMB_MODE, new DumbService.DumbModeListener() {
      @Override
      public void exitDumbMode() {
        queueUpdate();
      }
    });
    PsiManager.getInstance(myProject).addPsiTreeChangeListener(new PsiTreeChangeAdapter() {
      @Override
      public void childAdded(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }

      @Override
      public void childRemoved(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }

      @Override
      public void childReplaced(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }

      @Override
      public void childMoved(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }

      @Override
      public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }

      @Override
      public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
        queueUpdate();
      }
    }, this);
  }

  private void queueUpdate() {
    if (!myProject.isDefault()) {
      myQueue.queue(Update.create(this, this::doUpdateSingleThread));
    }
  }

  private void doUpdateSingleThread() {
    if (!DumbService.isDumb(myProject) && myIsUpdating.compareAndSet(false, true)) {
      try {
        doUpdateCache();
      }
      finally {
        myIsUpdating.set(false);
      }
    }
    else {
      queueUpdate();
    }
  }

  private void doUpdateCache() {
    if (LightEdit.owns(myProject)) {
      return;
    }
    ReadAction.nonBlocking(() -> {
      PerlTimeLogger logger = PerlTimeLogger.create(LOG);
      logger.debug("Starting to update names cache at");

      PerlSubDeclarationIndex subDeclarationIndex = PerlSubDeclarationIndex.getInstance();
      Collection<String> declarationsNames = subDeclarationIndex.getAllNames(myProject);
      Set<String> subsSet = new HashSet<>(declarationsNames);
      logger.debug("Got declarations names: ", declarationsNames.size());
      ProgressManager.checkCanceled();

      PerlSubDefinitionsIndex subDefinitionsIndex = PerlSubDefinitionsIndex.getInstance();
      Collection<String> definitionsNames = subDefinitionsIndex.getAllNames(myProject);
      subsSet.addAll(definitionsNames);
      logger.debug("Got definitions names: ", definitionsNames.size());
      ProgressManager.checkCanceled();

      PerlLightSubDefinitionsIndex lightSubDefinitionsIndex = PerlLightSubDefinitionsIndex.getInstance();
      Collection<String> lightDefinitionsNames = lightSubDefinitionsIndex.getAllNames(myProject);
      subsSet.addAll(lightDefinitionsNames);
      logger.debug("Got light definitions names: ", lightDefinitionsNames.size());
      ProgressManager.checkCanceled();
      var newSubSet = Collections.unmodifiableSet(subsSet);
      if (!newSubSet.equals(myKnownSubs)) {
        myKnownSubs = newSubSet;
        ResolveCache.getInstance(myProject).clearCache(true);
      }

      Set<String> namespacesSet = new HashSet<>(PerlPackageUtilCore.CORE_PACKAGES_ALL);

      PerlNamespaceIndex namespaceIndex = PerlNamespaceIndex.getInstance();
      Collection<String> namespacesNames = namespaceIndex.getAllNames(myProject);
      namespacesSet.addAll(namespacesNames);
      logger.debug("Got namespaces names: ", namespacesNames.size());
      ProgressManager.checkCanceled();

      PerlLightNamespaceIndex lightNamespaceIndex = PerlLightNamespaceIndex.getInstance();
      Collection<String> lightNamespacesNames = lightNamespaceIndex.getAllNames(myProject);
      namespacesSet.addAll(lightNamespacesNames);
      logger.debug("Got light namespaces names: ", lightNamespacesNames.size());
      var newNamespaceSet = Collections.unmodifiableSet(namespacesSet);
      if (!newNamespaceSet.equals(myKnownNamespaces)) {
        myKnownNamespaces = newNamespaceSet;
        ResolveCache.getInstance(myProject).clearCache(true);
      }

      logger.debug("Names cache updated");
      //noinspection ReturnOfNull
      return null;
    }).inSmartMode(myProject).expireWith(this).executeSynchronously();
  }

  @Override
  public boolean isDisposed() {
    return myIsDisposed.get();
  }

  @Override
  public void forceCacheUpdate() {
    var application = ApplicationManager.getApplication();
    application.assertIsNonDispatchThread();
    doUpdateCache();
  }

  @Override
  @TestOnly
  public void cleanCache() {
    myKnownSubs = Collections.emptySet();
    myKnownNamespaces = Collections.emptySet();
  }

  @Override
  public void dispose() {
    WriteAction.run(() -> myIsDisposed.set(true));
  }

  @Override
  public @NotNull Set<String> getSubsNamesSet() {
    return myKnownSubs;
  }

  @Override
  public @NotNull Set<String> getNamespacesNamesSet() {
    return myKnownNamespaces;
  }

  @TestOnly
  public void stopQueue() {
    myQueue.dispose();
  }

  @TestOnly
  public boolean isUpdating() { return myIsUpdating.get(); }
}

1	/*
2	* Copyright 2015-2025 Alexandr Evstigneev
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package com.perl5.lang.perl.idea.project;
18
19	import com.intellij.ide.lightEdit.LightEdit;
20	import com.intellij.openapi.application.ApplicationManager;
21	import com.intellij.openapi.application.ReadAction;
22	import com.intellij.openapi.application.WriteAction;
23	import com.intellij.openapi.diagnostic.Logger;
24	import com.intellij.openapi.progress.ProgressManager;
25	import com.intellij.openapi.project.DumbService;
26	import com.intellij.openapi.project.Project;
27	import com.intellij.openapi.roots.ModuleRootEvent;
28	import com.intellij.openapi.roots.ModuleRootListener;
29	import com.intellij.psi.PsiManager;
30	import com.intellij.psi.PsiTreeChangeAdapter;
31	import com.intellij.psi.PsiTreeChangeEvent;
32	import com.intellij.psi.impl.source.resolve.ResolveCache;
33	import com.intellij.util.messages.MessageBusConnection;
34	import com.intellij.util.ui.update.MergingUpdateQueue;
35	import com.intellij.util.ui.update.Update;
36	import com.perl5.lang.perl.psi.stubs.namespaces.PerlLightNamespaceIndex;
37	import com.perl5.lang.perl.psi.stubs.namespaces.PerlNamespaceIndex;
38	import com.perl5.lang.perl.psi.stubs.subsdeclarations.PerlSubDeclarationIndex;
39	import com.perl5.lang.perl.psi.stubs.subsdefinitions.PerlLightSubDefinitionsIndex;
40	import com.perl5.lang.perl.psi.stubs.subsdefinitions.PerlSubDefinitionsIndex;
41	import com.perl5.lang.perl.util.PerlPackageUtilCore;
42	import com.perl5.lang.perl.util.PerlTimeLogger;
43	import org.jetbrains.annotations.NotNull;
44	import org.jetbrains.annotations.TestOnly;
45
46	import java.util.Collection;
47	import java.util.Collections;
48	import java.util.HashSet;
49	import java.util.Set;
50	import java.util.concurrent.atomic.AtomicBoolean;
51
52
53	public class PerlNamesBackendCache implements PerlNamesCache {
54	private static final Logger LOG = Logger.getInstance(PerlNamesBackendCache.class);	1✔
55	private final MergingUpdateQueue myQueue = new MergingUpdateQueue("Perl names cache updater", 1000, true, null, this, null, false);	1✔
56	private final Project myProject;
57	private final AtomicBoolean myIsUpdating = new AtomicBoolean(false);	1✔
58	private volatile Set<String> myKnownSubs = Collections.emptySet();	1✔
59	private volatile Set<String> myKnownNamespaces = Collections.emptySet();	1✔
60	private final AtomicBoolean myIsDisposed = new AtomicBoolean(false);	1✔
61
62	public PerlNamesBackendCache(Project project) {	1✔
63	myProject = project;	1✔
64	if (LightEdit.owns(myProject) \|\| project.isDefault()) {	1!
65	return;	×
66	}
67	MessageBusConnection connection = project.getMessageBus().connect(this);	1✔
68	connection.subscribe(ModuleRootListener.TOPIC, new ModuleRootListener() {	1✔
69	@Override
70	public void rootsChanged(@NotNull ModuleRootEvent event) {
71	queueUpdate();	1✔
72	}	1✔
73	});
74	connection.subscribe(DumbService.DUMB_MODE, new DumbService.DumbModeListener() {	1✔
75	@Override
76	public void exitDumbMode() {
77	queueUpdate();	1✔
78	}	1✔
79	});
80	PsiManager.getInstance(myProject).addPsiTreeChangeListener(new PsiTreeChangeAdapter() {	1✔
81	@Override
82	public void childAdded(@NotNull PsiTreeChangeEvent event) {
83	queueUpdate();	1✔
84	}	1✔
85
86	@Override
87	public void childRemoved(@NotNull PsiTreeChangeEvent event) {
88	queueUpdate();	1✔
89	}	1✔
90
91	@Override
92	public void childReplaced(@NotNull PsiTreeChangeEvent event) {
93	queueUpdate();	1✔
94	}	1✔
95
96	@Override
97	public void childMoved(@NotNull PsiTreeChangeEvent event) {
98	queueUpdate();	×
99	}	×
100
101	@Override
102	public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
103	queueUpdate();	1✔
104	}	1✔
105
106	@Override
107	public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
108	queueUpdate();	1✔
109	}	1✔
110	}, this);
111	}	1✔
112
113	private void queueUpdate() {
114	if (!myProject.isDefault()) {	1!
115	myQueue.queue(Update.create(this, this::doUpdateSingleThread));	1✔
116	}
117	}	1✔
118
119	private void doUpdateSingleThread() {
120	if (!DumbService.isDumb(myProject) && myIsUpdating.compareAndSet(false, true)) {	1!
121	try {
122	doUpdateCache();	1✔
123	}
124	finally {
125	myIsUpdating.set(false);	1✔
126	}	1✔
127	}
128	else {
129	queueUpdate();	1✔
130	}
131	}	1✔
132
133	private void doUpdateCache() {
134	if (LightEdit.owns(myProject)) {	1!
135	return;	×
136	}
137	ReadAction.nonBlocking(() -> {	1✔
138	PerlTimeLogger logger = PerlTimeLogger.create(LOG);	1✔
139	logger.debug("Starting to update names cache at");	1✔
140
141	PerlSubDeclarationIndex subDeclarationIndex = PerlSubDeclarationIndex.getInstance();	1✔
142	Collection<String> declarationsNames = subDeclarationIndex.getAllNames(myProject);	1✔
143	Set<String> subsSet = new HashSet<>(declarationsNames);	1✔
144	logger.debug("Got declarations names: ", declarationsNames.size());	1✔
145	ProgressManager.checkCanceled();	1✔
146
147	PerlSubDefinitionsIndex subDefinitionsIndex = PerlSubDefinitionsIndex.getInstance();	1✔
148	Collection<String> definitionsNames = subDefinitionsIndex.getAllNames(myProject);	1✔
149	subsSet.addAll(definitionsNames);	1✔
150	logger.debug("Got definitions names: ", definitionsNames.size());	1✔
151	ProgressManager.checkCanceled();	1✔
152
153	PerlLightSubDefinitionsIndex lightSubDefinitionsIndex = PerlLightSubDefinitionsIndex.getInstance();	1✔
154	Collection<String> lightDefinitionsNames = lightSubDefinitionsIndex.getAllNames(myProject);	1✔
155	subsSet.addAll(lightDefinitionsNames);	1✔
156	logger.debug("Got light definitions names: ", lightDefinitionsNames.size());	1✔
157	ProgressManager.checkCanceled();	1✔
158	var newSubSet = Collections.unmodifiableSet(subsSet);	1✔
159	if (!newSubSet.equals(myKnownSubs)) {	1✔
160	myKnownSubs = newSubSet;	1✔
161	ResolveCache.getInstance(myProject).clearCache(true);	1✔
162	}
163
164	Set<String> namespacesSet = new HashSet<>(PerlPackageUtilCore.CORE_PACKAGES_ALL);	1✔
165
166	PerlNamespaceIndex namespaceIndex = PerlNamespaceIndex.getInstance();	1✔
167	Collection<String> namespacesNames = namespaceIndex.getAllNames(myProject);	1✔
168	namespacesSet.addAll(namespacesNames);	1✔
169	logger.debug("Got namespaces names: ", namespacesNames.size());	1✔
170	ProgressManager.checkCanceled();	1✔
171
172	PerlLightNamespaceIndex lightNamespaceIndex = PerlLightNamespaceIndex.getInstance();	1✔
173	Collection<String> lightNamespacesNames = lightNamespaceIndex.getAllNames(myProject);	1✔
174	namespacesSet.addAll(lightNamespacesNames);	1✔
175	logger.debug("Got light namespaces names: ", lightNamespacesNames.size());	1✔
176	var newNamespaceSet = Collections.unmodifiableSet(namespacesSet);	1✔
177	if (!newNamespaceSet.equals(myKnownNamespaces)) {	1✔
178	myKnownNamespaces = newNamespaceSet;	1✔
179	ResolveCache.getInstance(myProject).clearCache(true);	1✔
180	}
181
182	logger.debug("Names cache updated");	1✔
183	//noinspection ReturnOfNull
184	return null;	1✔
185	}).inSmartMode(myProject).expireWith(this).executeSynchronously();	1✔
186	}	1✔
187
188	@Override
189	public boolean isDisposed() {
UNCOV 190	return myIsDisposed.get();	×
191	}
192
193	@Override
194	public void forceCacheUpdate() {
195	var application = ApplicationManager.getApplication();	1✔
196	application.assertIsNonDispatchThread();	1✔
197	doUpdateCache();	1✔
198	}	1✔
199
200	@Override
201	@TestOnly
202	public void cleanCache() {
203	myKnownSubs = Collections.emptySet();	1✔
204	myKnownNamespaces = Collections.emptySet();	1✔
205	}	1✔
206
207	@Override
208	public void dispose() {
209	WriteAction.run(() -> myIsDisposed.set(true));	1✔
210	}	1✔
211
212	@Override
213	public @NotNull Set<String> getSubsNamesSet() {
214	return myKnownSubs;	1!
215	}
216
217	@Override
218	public @NotNull Set<String> getNamespacesNamesSet() {
219	return myKnownNamespaces;	1!
220	}
221
222	@TestOnly
223	public void stopQueue() {
224	myQueue.dispose();	1✔
225	}	1✔
226
227	@TestOnly
228	public boolean isUpdating() { return myIsUpdating.get(); }	1✔
229	}

Camelcade / Perl5-IDEA / #525521701

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous