@Nullable
public static IProject getFrom(@NotNull Project project) {
IProject gsProject = project.getUserData(PROJECT_KEY);
if (gsProject == null) {
project.putUserData(PROJECT_KEY, gsProject = new IjProject(project));
}
return gsProject;
}
@Override
public void removeProjectManagerListener(
@NotNull Project project, @NotNull ProjectManagerListener listener) {
List<ProjectManagerListener> listeners = project.getUserData(LISTENERS_IN_PROJECT_KEY);
LOG.assertTrue(listeners != null);
boolean removed = listeners.remove(listener);
LOG.assertTrue(removed);
}
@NotNull
public static String getCreationPlace(@NotNull Project project) {
String place = project.getUserData(CREATION_PLACE);
Object base;
try {
base = project.isDisposed() ? "" : project.getBaseDir();
} catch (Exception e) {
base = " (" + e + " while getting base dir)";
}
return project + (place != null ? place : "") + base;
}
@TestOnly
public static void pushInjectors(@NotNull Project project) {
InjectedLanguageManagerImpl cachedManager =
(InjectedLanguageManagerImpl) project.getUserData(INSTANCE_CACHE);
if (cachedManager == null) return;
try {
assert cachedManager.myInjectorsClone.isEmpty() : cachedManager.myInjectorsClone;
} finally {
cachedManager.myInjectorsClone.clear();
}
cachedManager.myInjectorsClone.putAll(cachedManager.injectors);
}
@Override
public void addProjectManagerListener(
@NotNull Project project, @NotNull ProjectManagerListener listener) {
List<ProjectManagerListener> listeners = project.getUserData(LISTENERS_IN_PROJECT_KEY);
if (listeners == null) {
listeners =
((UserDataHolderEx) project)
.putUserDataIfAbsent(
LISTENERS_IN_PROJECT_KEY,
ContainerUtil.<ProjectManagerListener>createLockFreeCopyOnWriteList());
}
listeners.add(listener);
}
private static boolean wasEverInitialized(@NotNull Project project) {
Boolean was = project.getUserData(PROJECT_WAS_EVER_INITIALIZED);
if (was == null) {
if (project.isInitialized()) {
was = Boolean.valueOf(true);
project.putUserData(PROJECT_WAS_EVER_INITIALIZED, was);
} else {
was = Boolean.valueOf(false);
}
}
return was.booleanValue();
}
private static Set<String> collectDevPatternClassNames(@NotNull final Project project) {
CachedValue<Set<String>> cachedValue = project.getUserData(PATTERN_CLASSES);
if (cachedValue == null) {
cachedValue =
CachedValuesManager.getManager(project)
.createCachedValue(
new CachedValueProvider<Set<String>>() {
@Nullable
@Override
public Result<Set<String>> compute() {
return Result.create(
calcDevPatternClassNames(project),
PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
},
false);
project.putUserData(PATTERN_CLASSES, cachedValue);
}
return cachedValue.getValue();
}
@TestOnly
public static void checkInjectorsAreDisposed(@NotNull Project project) {
InjectedLanguageManagerImpl cachedManager =
(InjectedLanguageManagerImpl) project.getUserData(INSTANCE_CACHE);
if (cachedManager == null) return;
try {
for (Map.Entry<Class, MultiHostInjector[]> entry : cachedManager.injectors.entrySet()) {
Class key = entry.getKey();
if (cachedManager.myInjectorsClone.isEmpty()) return;
MultiHostInjector[] oldInjectors = cachedManager.myInjectorsClone.get(key);
for (MultiHostInjector injector : entry.getValue()) {
if (!ArrayUtil.contains(injector, oldInjectors)) {
throw new AssertionError("Injector was not disposed: " + key + " -> " + injector);
}
}
}
} finally {
cachedManager.myInjectorsClone.clear();
}
}
/**
* Analyze project with string cache for the whole project. All given files will be analyzed only
* for descriptors.
*/
public static AnalyzeExhaust analyzeProjectWithCache(
@NotNull final Project project, @NotNull final Collection<JetFile> files) {
// Need lock for getValue(), because parallel threads can start evaluation of compute()
// simultaneously
synchronized (lock) {
CachedValue<AnalyzeExhaust> bindingContextCachedValue = project.getUserData(BINDING_CONTEXT);
if (bindingContextCachedValue == null) {
bindingContextCachedValue =
CachedValuesManager.getManager(project)
.createCachedValue(
new CachedValueProvider<AnalyzeExhaust>() {
@Override
public Result<AnalyzeExhaust> compute() {
try {
AnalyzeExhaust analyzeExhaust =
analyzeFilesWithJavaIntegration(
project,
files,
Predicates.<PsiFile>alwaysFalse(),
JetControlFlowDataTraceFactory.EMPTY);
return new Result<AnalyzeExhaust>(
analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT);
} catch (ProcessCanceledException e) {
throw e;
} catch (Throwable e) {
DiagnosticUtils.throwIfRunningOnServer(e);
LOG.error(e);
BindingTraceContext bindingTraceContext = new BindingTraceContext();
AnalyzeExhaust analyzeExhaust =
new AnalyzeExhaust(bindingTraceContext.getBindingContext(), null);
return new Result<AnalyzeExhaust>(
analyzeExhaust, PsiModificationTracker.MODIFICATION_COUNT);
}
}
},
false);
project.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
}
return bindingContextCachedValue.getValue();
}
}
@NotNull
private static PsiFile getRootByClasses(@NotNull PsiFile file, @NotNull Class[] classes) {
final Project project = file.getProject();
SoftFactoryMap<Class[], PsiFile> map = project.getUserData(PATTERN_INJECTION_CONTEXT);
if (map == null) {
map =
new SoftFactoryMap<Class[], PsiFile>() {
@Override
protected PsiFile create(Class[] key) {
String text =
PatternCompilerFactory.getFactory()
.getPatternCompiler(key)
.dumpContextDeclarations();
return PsiFileFactory.getInstance(project)
.createFileFromText("context.groovy", GroovyFileType.GROOVY_FILE_TYPE, text);
}
};
project.putUserData(PATTERN_INJECTION_CONTEXT, map);
}
return map.get(classes);
}
public static void scheduleDartPackageRootsUpdate(@NotNull final Project project) {
if (Registry.is("dart.projects.without.pubspec", false)) return;
if (project.getUserData(DART_PACKAGE_ROOTS_UPDATE_SCHEDULED_OR_IN_PROGRESS) == Boolean.TRUE) {
return;
}
setDartPackageRootUpdateScheduledOrInProgress(project, Boolean.TRUE);
DumbService.getInstance(project)
.smartInvokeLater(
new Runnable() {
@Override
public void run() {
try {
final DartSdk sdk = DartSdk.getDartSdk(project);
final Library library = actualizePackagesLibrary(project, sdk);
if (library == null) {
removeDartPackagesLibraryAndDependencies(project);
} else {
final Condition<Module> moduleFilter =
new Condition<Module>() {
@Override
public boolean value(final Module module) {
return DartSdkGlobalLibUtil.isDartSdkEnabled(module);
}
};
updateDependenciesOnDartPackagesLibrary(project, moduleFilter, library);
}
} finally {
setDartPackageRootUpdateScheduledOrInProgress(project, false);
}
}
},
ModalityState.NON_MODAL);
}
/** Returns the same as {@link #getGlobalDartSdk()} but much faster */
@Nullable
public static DartSdk getDartSdk(@NotNull final Project project) {
CachedValue<DartSdk> cachedValue = project.getUserData(CACHED_DART_SDK_KEY);
if (cachedValue == null) {
cachedValue =
CachedValuesManager.getManager(project)
.createCachedValue(
() -> {
final DartSdk sdk = getGlobalDartSdk();
if (sdk == null) {
return new CachedValueProvider.Result<DartSdk>(
null, DartProjectComponent.getProjectRootsModificationTracker(project));
}
List<Object> dependencies = new ArrayList<Object>(3);
dependencies.add(
DartProjectComponent.getProjectRootsModificationTracker(project));
ContainerUtil.addIfNotNull(
dependencies,
LocalFileSystem.getInstance()
.findFileByPath(sdk.getHomePath() + "/version"));
ContainerUtil.addIfNotNull(
dependencies,
LocalFileSystem.getInstance()
.findFileByPath(sdk.getHomePath() + "/lib/core/core.dart"));
return new CachedValueProvider.Result<DartSdk>(
sdk, ArrayUtil.toObjectArray(dependencies));
},
false);
project.putUserData(CACHED_DART_SDK_KEY, cachedValue);
}
return cachedValue.getValue();
}
@TestOnly
public static void checkInjectorsAreDisposed(@NotNull Project project) {
InjectedLanguageManagerImpl cachedManager =
(InjectedLanguageManagerImpl) project.getUserData(INSTANCE_CACHE);
if (cachedManager == null) {
return;
}
try {
ClassMapCachingNulls<MultiHostInjector> cached = cachedManager.cachedInjectors;
if (cached == null) return;
for (Map.Entry<Class, MultiHostInjector[]> entry : cached.getBackingMap().entrySet()) {
Class key = entry.getKey();
if (cachedManager.myInjectorsClone.isEmpty()) return;
MultiHostInjector[] oldInjectors = cachedManager.myInjectorsClone.get(key);
for (MultiHostInjector injector : entry.getValue()) {
if (ArrayUtil.indexOf(oldInjectors, injector) == -1) {
throw new AssertionError("Injector was not disposed: " + key + " -> " + injector);
}
}
}
} finally {
cachedManager.myInjectorsClone.clear();
}
}
@NotNull
private static List<ProjectManagerListener> getListeners(Project project) {
List<ProjectManagerListener> array = project.getUserData(LISTENERS_IN_PROJECT_KEY);
if (array == null) return Collections.emptyList();
return array;
}
@Override
public Collection<LineExtensionInfo> getLineExtensions(
@NotNull Project project, @NotNull VirtualFile file, int lineNumber) {
if (!Registry.is("ide.debugger.inline")) {
return null;
}
final Map<Pair<VirtualFile, Integer>, Set<XValueNodeImpl>> map =
project.getUserData(XVariablesView.DEBUG_VARIABLES);
final Map<VirtualFile, Long> timestamps =
project.getUserData(XVariablesView.DEBUG_VARIABLES_TIMESTAMPS);
final Document doc = FileDocumentManager.getInstance().getDocument(file);
if (map == null || timestamps == null || doc == null) {
return null;
}
Map<Variable, VariableValue> oldValues = project.getUserData(CACHE);
if (oldValues == null) {
oldValues = new HashMap<Variable, VariableValue>();
project.putUserData(CACHE, oldValues);
}
final Long timestamp = timestamps.get(file);
if (timestamp == null || timestamp < doc.getModificationStamp()) {
return null;
}
Set<XValueNodeImpl> values = map.get(Pair.create(file, lineNumber));
if (values != null && !values.isEmpty()) {
ArrayList<LineExtensionInfo> result = new ArrayList<LineExtensionInfo>();
for (XValueNodeImpl value : values) {
SimpleColoredText text = new SimpleColoredText();
XValueTextRendererImpl renderer = new XValueTextRendererImpl(text);
final XValuePresentation presentation = value.getValuePresentation();
if (presentation == null) continue;
try {
if (presentation instanceof XValueCompactPresentation) {
((XValueCompactPresentation) presentation).renderValue(renderer, value);
} else {
presentation.renderValue(renderer);
}
} catch (Exception e) {
continue;
}
final Color color = getForeground();
final String name = value.getName();
result.add(new LineExtensionInfo(" " + name + ": ", color, null, null, Font.PLAIN));
Variable var = new Variable(name, lineNumber);
VariableValue variableValue = oldValues.get(var);
if (variableValue == null) {
variableValue = new VariableValue(text.toString(), null, value.hashCode());
oldValues.put(var, variableValue);
}
if (variableValue.valueNodeHashCode != value.hashCode()) {
variableValue.old = variableValue.actual;
variableValue.actual = text.toString();
variableValue.valueNodeHashCode = value.hashCode();
}
if (!variableValue.isChanged()) {
for (String s : text.getTexts()) {
result.add(new LineExtensionInfo(s, color, null, null, Font.PLAIN));
}
} else {
variableValue.produceChangedParts(result);
}
}
return result;
}
return null;
}