diff options
Diffstat (limited to 'java')
336 files changed, 12501 insertions, 4063 deletions
diff --git a/java/compiler/impl/src/com/intellij/compiler/impl/CompileContextImpl.java b/java/compiler/impl/src/com/intellij/compiler/impl/CompileContextImpl.java index c9e9ce31020a..f57753ef7afc 100644 --- a/java/compiler/impl/src/com/intellij/compiler/impl/CompileContextImpl.java +++ b/java/compiler/impl/src/com/intellij/compiler/impl/CompileContextImpl.java @@ -55,7 +55,7 @@ import java.util.*; public class CompileContextImpl extends UserDataHolderBase implements CompileContextEx { private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.impl.CompileContextImpl"); private final Project myProject; - private final CompilerTask myTask; + private final CompilerTask myBuildSession; private final Map<CompilerMessageCategory, Collection<CompilerMessage>> myMessages = new EnumMap<CompilerMessageCategory, Collection<CompilerMessage>>(CompilerMessageCategory.class); private final boolean myShouldUpdateProblemsView; private CompileScope myCompileScope; @@ -77,7 +77,7 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon CompileScope compileScope, boolean isMake, boolean isRebuild) { myProject = project; - myTask = compilerSession; + myBuildSession = compilerSession; myCompileScope = compileScope; myMake = isMake; myIsRebuild = isRebuild; @@ -99,6 +99,10 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon myShouldUpdateProblemsView = workspaceConfig.MAKE_PROJECT_ON_SAVE; } + public CompilerTask getBuildSession() { + return myBuildSession; + } + public boolean shouldUpdateProblemsView() { return myShouldUpdateProblemsView; } @@ -154,7 +158,7 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon myMessages.put(msg.getCategory(), messages); } if (messages.add(msg)) { - myTask.addMessage(msg); + myBuildSession.addMessage(msg); } if (myShouldUpdateProblemsView && msg.getCategory() == CompilerMessageCategory.ERROR) { ProblemsView.SERVICE.getInstance(myProject).addMessage(msg, mySessionId); @@ -200,7 +204,7 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon } public ProgressIndicator getProgressIndicator() { - return myTask.getIndicator(); + return myBuildSession.getIndicator(); } public Module getModuleByFile(VirtualFile file) { diff --git a/java/compiler/impl/src/com/intellij/compiler/impl/CompileDriver.java b/java/compiler/impl/src/com/intellij/compiler/impl/CompileDriver.java index 406d16574955..c40edf0f595c 100644 --- a/java/compiler/impl/src/com/intellij/compiler/impl/CompileDriver.java +++ b/java/compiler/impl/src/com/intellij/compiler/impl/CompileDriver.java @@ -28,8 +28,9 @@ import com.intellij.compiler.ModuleCompilerUtil; import com.intellij.compiler.ProblemsView; import com.intellij.compiler.progress.CompilerTask; import com.intellij.compiler.server.BuildManager; -import com.intellij.compiler.server.CustomBuilderMessageHandler; import com.intellij.compiler.server.DefaultMessageHandler; +import com.intellij.notification.Notification; +import com.intellij.notification.NotificationListener; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.compiler.*; import com.intellij.openapi.compiler.ex.CompilerPathsEx; @@ -54,10 +55,7 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFileManager; -import com.intellij.openapi.wm.StatusBar; -import com.intellij.openapi.wm.ToolWindowId; -import com.intellij.openapi.wm.ToolWindowManager; -import com.intellij.openapi.wm.WindowManager; +import com.intellij.openapi.wm.*; import com.intellij.packaging.artifacts.Artifact; import com.intellij.packaging.impl.compiler.ArtifactCompilerUtil; import com.intellij.packaging.impl.compiler.ArtifactsCompiler; @@ -69,6 +67,7 @@ import com.intellij.util.ThrowableRunnable; import com.intellij.util.containers.HashMap; import com.intellij.util.containers.MultiMap; import com.intellij.util.messages.MessageBus; +import com.intellij.util.text.DateFormatUtil; import gnu.trove.THashSet; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -80,7 +79,9 @@ import org.jetbrains.jps.api.RequestFuture; import org.jetbrains.jps.model.java.JavaSourceRootType; import javax.swing.*; +import javax.swing.event.HyperlinkEvent; import java.io.File; +import java.lang.ref.WeakReference; import java.util.*; import java.util.concurrent.TimeUnit; @@ -340,13 +341,6 @@ public class CompileDriver { } compileContext.putUserDataIfAbsent(COMPILE_SERVER_BUILD_STATUS, status); break; - case CUSTOM_BUILDER_MESSAGE: - if (event.hasCustomBuilderMessage()) { - CmdlineRemoteProto.Message.BuilderMessage.BuildEvent.CustomBuilderMessage message = event.getCustomBuilderMessage(); - messageBus.syncPublisher(CustomBuilderMessageHandler.TOPIC).messageReceived(message.getBuilderId(), message.getMessageType(), - message.getMessageText()); - } - break; } } }); @@ -510,9 +504,24 @@ public class CompileDriver { if (duration > ONE_MINUTE_MS && CompilerWorkspaceConfiguration.getInstance(myProject).DISPLAY_NOTIFICATION_POPUP) { ToolWindowManager.getInstance(myProject).notifyByBalloon(ToolWindowId.MESSAGES_WINDOW, messageType, statusMessage); } - CompilerManager.NOTIFICATION_GROUP.createNotification(statusMessage, messageType).notify(myProject); + + final String wrappedMessage = _status != ExitStatus.UP_TO_DATE? "<a href='#'>" + statusMessage + "</a>" : statusMessage; + final Notification notification = CompilerManager.NOTIFICATION_GROUP.createNotification( + "", wrappedMessage, + messageType.toNotificationType(), + new MessagesActivationListener(compileContext) + ); + compileContext.getBuildSession().registerCloseAction(new Runnable() { + @Override + public void run() { + notification.expire(); + } + }); + notification.notify(myProject); + if (_status != ExitStatus.UP_TO_DATE && compileContext.getMessageCount(null) > 0) { - compileContext.addMessage(CompilerMessageCategory.INFORMATION, statusMessage, null, -1, -1); + final String msg = DateFormatUtil.formatDateTime(new Date()) + " - " + statusMessage; + compileContext.addMessage(CompilerMessageCategory.INFORMATION, msg, null, -1, -1); } } } @@ -793,4 +802,28 @@ public class CompileDriver { private void showConfigurationDialog(String moduleNameToSelect, String tabNameToSelect) { ProjectSettingsService.getInstance(myProject).showModuleConfigurationDialog(moduleNameToSelect, tabNameToSelect); } + + private static class MessagesActivationListener extends NotificationListener.Adapter { + private final WeakReference<Project> myProjectRef; + private final Object myContentId; + + public MessagesActivationListener(CompileContextImpl compileContext) { + myProjectRef = new WeakReference<Project>(compileContext.getProject()); + myContentId = compileContext.getBuildSession().getContentId(); + } + + @Override + protected void hyperlinkActivated(@NotNull Notification notification, @NotNull HyperlinkEvent e) { + final Project project = myProjectRef.get(); + if (project != null && !project.isDisposed() && CompilerTask.showCompilerContent(project, myContentId)) { + final ToolWindow tw = ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.MESSAGES_WINDOW); + if (tw != null) { + tw.activate(null, false); + } + } + else { + notification.expire(); + } + } + } } diff --git a/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java b/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java index f568f2d06364..2f9f023bc52a 100644 --- a/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java +++ b/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java @@ -22,12 +22,11 @@ package com.intellij.compiler.progress; import com.intellij.compiler.CompilerManagerImpl; -import com.intellij.compiler.CompilerMessageImpl; import com.intellij.compiler.impl.CompilerErrorTreeView; import com.intellij.ide.errorTreeView.NewErrorTreeViewPanel; import com.intellij.ide.errorTreeView.impl.ErrorTreeViewConfiguration; import com.intellij.ide.impl.ProjectUtil; -import com.intellij.openapi.application.Application; +import com.intellij.openapi.Disposable; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ModalityState; import com.intellij.openapi.compiler.*; @@ -42,6 +41,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.project.ProjectManager; import com.intellij.openapi.project.ProjectManagerListener; import com.intellij.openapi.ui.Messages; +import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.TextRange; import com.intellij.openapi.vfs.VirtualFile; @@ -120,6 +120,26 @@ public class CompilerTask extends Task.Backgroundable { mySessionId = sessionId; } + @NotNull + public Object getContentId() { + return myContentId; + } + + public void registerCloseAction(final Runnable onClose) { + synchronized (myMessageViewLock) { + if (myErrorTreeView != null) { + Disposer.register(myErrorTreeView, new Disposable() { + @Override + public void dispose() { + onClose.run(); + } + }); + return; + } + } + onClose.run(); + } + @Override public String getProcessId() { return "compilation"; @@ -221,13 +241,15 @@ public class CompilerTask extends Task.Backgroundable { private void addIndicatorDelegate() { ProgressIndicator indicator = myIndicator; - if (!(indicator instanceof ProgressIndicatorEx)) return; + if (!(indicator instanceof ProgressIndicatorEx)) { + return; + } ((ProgressIndicatorEx)indicator).addStateDelegate(new ProgressIndicatorBase() { @Override public void cancel() { super.cancel(); - closeUI(); + selectFirstMessage(); stopAppIconProgress(); } @@ -235,11 +257,26 @@ public class CompilerTask extends Task.Backgroundable { public void stop() { super.stop(); if (!isCanceled()) { - closeUI(); + selectFirstMessage(); } stopAppIconProgress(); } + private void selectFirstMessage() { + if (!isHeadlessMode()) { + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + synchronized (myMessageViewLock) { + if (myErrorTreeView != null) { + myErrorTreeView.selectFirstMessage(); + } + } + } + }); + } + } + private void stopAppIconProgress() { UIUtil.invokeLaterIfNeeded(new Runnable() { @Override @@ -249,7 +286,8 @@ public class CompilerTask extends Task.Backgroundable { if (myErrorCount > 0) { appIcon.setErrorBadge(myProject, String.valueOf(myErrorCount)); appIcon.requestAttention(myProject, true); - } else if (!myCompilationStartedAutomatically) { + } + else if (!myCompilationStartedAutomatically) { appIcon.setOkBadge(myProject, true); appIcon.requestAttention(myProject, false); } @@ -450,18 +488,22 @@ public class CompilerTask extends Task.Backgroundable { public void showCompilerContent() { synchronized (myMessageViewLock) { if (myErrorTreeView != null) { - final MessageView messageView = MessageView.SERVICE.getInstance(myProject); - Content[] contents = messageView.getContentManager().getContents(); - for (Content content : contents) { - if (CONTENT_ID_KEY.get(content) == myContentId) { - messageView.getContentManager().setSelectedContent(content); - return; - } - } + showCompilerContent(myProject, myContentId); } } } + public static boolean showCompilerContent(final Project project, final Object contentId) { + final MessageView messageView = MessageView.SERVICE.getInstance(project); + for (Content content : messageView.getContentManager().getContents()) { + if (CONTENT_ID_KEY.get(content) == contentId) { + messageView.getContentManager().setSelectedContent(content); + return true; + } + } + return false; + } + private void removeAllContents(Project project, Content notRemove) { if (project.isDisposed()) { return; @@ -488,7 +530,7 @@ public class CompilerTask extends Task.Backgroundable { private void activateMessageView() { synchronized (myMessageViewLock) { - if (myErrorTreeView != null) { + if (myErrorTreeView != null && myProject != null) { final ToolWindow tw = ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.MESSAGES_WINDOW); if (tw != null) { tw.activate(null, false); @@ -497,34 +539,6 @@ public class CompilerTask extends Task.Backgroundable { } } - private void closeUI() { - if (isHeadlessMode()) { - return; - } - Window window = getWindow(); - ModalityState modalityState = window != null ? ModalityState.stateForComponent(window) : ModalityState.NON_MODAL; - final Application application = ApplicationManager.getApplication(); - application.invokeLater(new Runnable() { - @Override - public void run() { - synchronized (myMessageViewLock) { - if (myErrorTreeView != null) { - final boolean shouldRetainView = myErrorCount > 0 || myWarningCount > 0 && !myErrorTreeView.isHideWarnings(); - if (shouldRetainView) { - addMessage(new CompilerMessageImpl(myProject, CompilerMessageCategory.STATISTICS, CompilerBundle.message("statistics.error.count", myErrorCount))); - addMessage(new CompilerMessageImpl(myProject, CompilerMessageCategory.STATISTICS, CompilerBundle.message("statistics.warnings.count", myWarningCount))); - //activateMessageView(); - myErrorTreeView.selectFirstMessage(); - } - else { - removeAllContents(myProject, null); - } - } - } - } - }, modalityState); - } - public Window getWindow(){ return null; } @@ -607,7 +621,7 @@ public class CompilerTask extends Task.Backgroundable { if (event.getContent() == myContent) { synchronized (myMessageViewLock) { if (myErrorTreeView != null) { - myErrorTreeView.dispose(); + Disposer.dispose(myErrorTreeView); myErrorTreeView = null; if (myIndicator.isRunning()) { cancel(); diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java index c40135db7c5f..669cf92d37da 100644 --- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java +++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java @@ -34,7 +34,9 @@ import com.intellij.openapi.application.Application; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ModalityState; import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.compiler.CompilationStatusListener; import com.intellij.openapi.compiler.CompileContext; +import com.intellij.openapi.compiler.CompilerTopics; import com.intellij.openapi.components.ApplicationComponent; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.EditorFactory; @@ -64,16 +66,14 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.registry.Registry; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.CharsetToolkit; +import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileManager; import com.intellij.openapi.vfs.newvfs.BulkFileListener; import com.intellij.openapi.vfs.newvfs.events.VFileEvent; import com.intellij.openapi.vfs.newvfs.impl.FileNameCache; import com.intellij.openapi.wm.IdeFrame; -import com.intellij.util.Alarm; -import com.intellij.util.Function; -import com.intellij.util.PathUtil; -import com.intellij.util.SmartList; +import com.intellij.util.*; import com.intellij.util.concurrency.Semaphore; import com.intellij.util.concurrency.SequentialTaskExecutor; import com.intellij.util.containers.IntArrayList; @@ -1117,6 +1117,44 @@ public class BuildManager implements ApplicationComponent{ scheduleAutoMake(); } }); + conn.subscribe(CompilerTopics.COMPILATION_STATUS, new CompilationStatusListener() { + private final Set<String> myRootsToRefresh = new THashSet<String>(FileUtil.PATH_HASHING_STRATEGY); + @Override + public void compilationFinished(boolean aborted, int errors, int warnings, CompileContext compileContext) { + final String[] roots; + synchronized (myRootsToRefresh) { + roots = ArrayUtil.toStringArray(myRootsToRefresh); + myRootsToRefresh.clear(); + } + ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { + @Override + public void run() { + if (project.isDisposed()) { + return; + } + final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex(); + final LocalFileSystem lfs = LocalFileSystem.getInstance(); + final Set<VirtualFile> filesToRefresh = new HashSet<VirtualFile>(); + for (String root : roots) { + final VirtualFile rootFile = lfs.refreshAndFindFileByPath(root); + if (rootFile != null && fileIndex.isInSourceContent(rootFile)) { + filesToRefresh.add(rootFile); + } + } + if (!filesToRefresh.isEmpty()) { + lfs.refreshFiles(filesToRefresh, true, true, null); + } + } + }); + } + + @Override + public void fileGenerated(String outputRoot, String relativePath) { + synchronized (myRootsToRefresh) { + myRootsToRefresh.add(outputRoot); + } + } + }); final String projectPath = getProjectPath(project); Disposer.register(project, new Disposable() { @Override diff --git a/java/compiler/impl/src/com/intellij/compiler/server/DefaultMessageHandler.java b/java/compiler/impl/src/com/intellij/compiler/server/DefaultMessageHandler.java index 6a8c9740df80..bfde64d4396e 100644 --- a/java/compiler/impl/src/com/intellij/compiler/server/DefaultMessageHandler.java +++ b/java/compiler/impl/src/com/intellij/compiler/server/DefaultMessageHandler.java @@ -20,6 +20,7 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.progress.ProcessCanceledException; import com.intellij.openapi.progress.ProgressIndicator; +import com.intellij.openapi.progress.util.ProgressIndicatorBase; import com.intellij.openapi.progress.util.ProgressIndicatorUtils; import com.intellij.openapi.progress.util.ReadTask; import com.intellij.openapi.project.DumbService; @@ -40,7 +41,6 @@ import org.jetbrains.jps.api.CmdlineRemoteProto; import org.jetbrains.org.objectweb.asm.Opcodes; import java.util.*; -import java.util.concurrent.atomic.AtomicBoolean; /** * @author Eugene Zhuravlev @@ -66,19 +66,23 @@ public abstract class DefaultMessageHandler implements BuilderMessageHandler { //noinspection EnumSwitchStatementWhichMissesCases switch (msg.getType()) { case BUILD_EVENT: - handleBuildEvent(sessionId, msg.getBuildEvent()); + final CmdlineRemoteProto.Message.BuilderMessage.BuildEvent event = msg.getBuildEvent(); + if (event.getEventType() == CmdlineRemoteProto.Message.BuilderMessage.BuildEvent.Type.CUSTOM_BUILDER_MESSAGE && event.hasCustomBuilderMessage()) { + final CmdlineRemoteProto.Message.BuilderMessage.BuildEvent.CustomBuilderMessage message = event.getCustomBuilderMessage(); + if (!myProject.isDisposed()) { + myProject.getMessageBus().syncPublisher(CustomBuilderMessageHandler.TOPIC).messageReceived( + message.getBuilderId(), message.getMessageType(), message.getMessageText() + ); + } + } + handleBuildEvent(sessionId, event); break; case COMPILE_MESSAGE: handleCompileMessage(sessionId, msg.getCompileMessage()); break; case CONSTANT_SEARCH_TASK: final CmdlineRemoteProto.Message.BuilderMessage.ConstantSearchTask task = msg.getConstantSearchTask(); - myTaskExecutor.submit(new Runnable() { - @Override - public void run() { - handleConstantSearchTask(channel, sessionId, task); - } - }); + handleConstantSearchTask(channel, sessionId, task); break; } } @@ -88,30 +92,29 @@ public abstract class DefaultMessageHandler implements BuilderMessageHandler { protected abstract void handleBuildEvent(UUID sessionId, CmdlineRemoteProto.Message.BuilderMessage.BuildEvent event); private void handleConstantSearchTask(final Channel channel, final UUID sessionId, final CmdlineRemoteProto.Message.BuilderMessage.ConstantSearchTask task) { - while (true) { - final AtomicBoolean canceled = new AtomicBoolean(false); - DumbService.getInstance(myProject).waitForSmartMode(); - ProgressIndicatorUtils.runWithWriteActionPriority(new ReadTask() { - @Override - public void computeInReadAction(@NotNull ProgressIndicator indicator) { - if (DumbService.isDumb(myProject)) { - canceled.set(true); - return; - } - - doHandleConstantSearchTask(channel, sessionId, task); + ProgressIndicatorUtils.scheduleWithWriteActionPriority(new ProgressIndicatorBase(), myTaskExecutor, new ReadTask() { + @Override + public void computeInReadAction(@NotNull ProgressIndicator indicator) { + if (DumbService.isDumb(myProject)) { + onCanceled(indicator); } - - @Override - public void onCanceled(@NotNull ProgressIndicator indicator) { - canceled.set(true); + else { + doHandleConstantSearchTask(channel, sessionId, task); } - }); - if (!canceled.get()) { - break; } - } + + @Override + public void onCanceled(@NotNull ProgressIndicator indicator) { + DumbService.getInstance(myProject).runWhenSmart(new Runnable() { + @Override + public void run() { + handleConstantSearchTask(channel, sessionId, task); + } + }); + } + }); } + private void doHandleConstantSearchTask(Channel channel, UUID sessionId, CmdlineRemoteProto.Message.BuilderMessage.ConstantSearchTask task) { final String ownerClassName = task.getOwnerClassName(); final String fieldName = task.getFieldName(); diff --git a/java/debugger/impl/src/com/intellij/debugger/actions/AdjustArrayRangeAction.java b/java/debugger/impl/src/com/intellij/debugger/actions/AdjustArrayRangeAction.java index 3a821fb10c0f..ce375815bb77 100644 --- a/java/debugger/impl/src/com/intellij/debugger/actions/AdjustArrayRangeAction.java +++ b/java/debugger/impl/src/com/intellij/debugger/actions/AdjustArrayRangeAction.java @@ -23,12 +23,10 @@ import com.intellij.debugger.ui.impl.watch.DebuggerTreeNodeImpl; import com.intellij.debugger.ui.impl.watch.NodeDescriptorImpl; import com.intellij.debugger.ui.impl.watch.ValueDescriptorImpl; import com.intellij.debugger.ui.tree.render.*; -import com.intellij.ide.actions.ShowSettingsUtilImpl; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.options.Configurable; -import com.intellij.openapi.options.ex.SingleConfigurableEditor; +import com.intellij.openapi.options.ShowSettingsUtil; import com.intellij.openapi.project.Project; -import com.intellij.openapi.ui.DialogWrapper; import org.jetbrains.annotations.Nullable; public class AdjustArrayRangeAction extends DebuggerAction { @@ -67,30 +65,25 @@ public class AdjustArrayRangeAction extends DebuggerAction { title = title + " " + label.substring(index); } final ArrayRenderer clonedRenderer = renderer.clone(); - final NamedArrayConfigurable configurable = new NamedArrayConfigurable(title, clonedRenderer); - SingleConfigurableEditor editor = new SingleConfigurableEditor(project, configurable, - ShowSettingsUtilImpl.createDimensionKey(configurable), false); - editor.show(); - - if(editor.getExitCode() == DialogWrapper.OK_EXIT_CODE) { + if (ShowSettingsUtil.getInstance().editConfigurable(project, new NamedArrayConfigurable(title, clonedRenderer))) { debugProcess.getManagerThread().schedule(new SuspendContextCommandImpl(debuggerContext.getSuspendContext()) { - @Override - public void contextAction() throws Exception { - final ValueDescriptorImpl nodeDescriptor = (ValueDescriptorImpl)selectedNode.getDescriptor(); - final Renderer lastRenderer = nodeDescriptor.getLastRenderer(); - if (lastRenderer instanceof ArrayRenderer) { - selectedNode.setRenderer(clonedRenderer); - } - else if (lastRenderer instanceof CompoundNodeRenderer) { - final CompoundNodeRenderer compoundRenderer = (CompoundNodeRenderer)lastRenderer; - final ChildrenRenderer childrenRenderer = compoundRenderer.getChildrenRenderer(); - if (childrenRenderer instanceof ExpressionChildrenRenderer) { - ExpressionChildrenRenderer.setPreferableChildrenRenderer(nodeDescriptor, clonedRenderer); - selectedNode.calcRepresentation(); - } + @Override + public void contextAction() throws Exception { + final ValueDescriptorImpl nodeDescriptor = (ValueDescriptorImpl)selectedNode.getDescriptor(); + final Renderer lastRenderer = nodeDescriptor.getLastRenderer(); + if (lastRenderer instanceof ArrayRenderer) { + selectedNode.setRenderer(clonedRenderer); + } + else if (lastRenderer instanceof CompoundNodeRenderer) { + final CompoundNodeRenderer compoundRenderer = (CompoundNodeRenderer)lastRenderer; + final ChildrenRenderer childrenRenderer = compoundRenderer.getChildrenRenderer(); + if (childrenRenderer instanceof ExpressionChildrenRenderer) { + ExpressionChildrenRenderer.setPreferableChildrenRenderer(nodeDescriptor, clonedRenderer); + selectedNode.calcRepresentation(); } } - }); + } + }); } } diff --git a/java/debugger/impl/src/com/intellij/debugger/actions/CustomizeThreadsViewAction.java b/java/debugger/impl/src/com/intellij/debugger/actions/CustomizeThreadsViewAction.java index 64705a373a21..7cef867334df 100644 --- a/java/debugger/impl/src/com/intellij/debugger/actions/CustomizeThreadsViewAction.java +++ b/java/debugger/impl/src/com/intellij/debugger/actions/CustomizeThreadsViewAction.java @@ -19,23 +19,15 @@ import com.intellij.debugger.settings.ThreadsViewConfigurable; import com.intellij.debugger.settings.ThreadsViewSettings; import com.intellij.idea.ActionsBundle; import com.intellij.openapi.actionSystem.AnActionEvent; -import com.intellij.openapi.actionSystem.CommonDataKeys; -import com.intellij.openapi.actionSystem.PlatformDataKeys; -import com.intellij.openapi.options.ex.SingleConfigurableEditor; -import com.intellij.openapi.project.Project; +import com.intellij.openapi.options.ShowSettingsUtil; -/** - * User: lex - * Date: Sep 26, 2003 - * Time: 4:40:12 PM - */ public class CustomizeThreadsViewAction extends DebuggerAction { + @Override public void actionPerformed(AnActionEvent e) { - Project project = CommonDataKeys.PROJECT.getData(e.getDataContext()); - final SingleConfigurableEditor editor = new SingleConfigurableEditor(project, new ThreadsViewConfigurable(ThreadsViewSettings.getInstance())); - editor.show(); + ShowSettingsUtil.getInstance().editConfigurable(e.getProject(), new ThreadsViewConfigurable(ThreadsViewSettings.getInstance())); } + @Override public void update(AnActionEvent e) { e.getPresentation().setVisible(true); e.getPresentation().setText(ActionsBundle.actionText(DebuggerActions.CUSTOMIZE_THREADS_VIEW)); diff --git a/java/debugger/impl/src/com/intellij/debugger/actions/JavaReferringObjectsValue.java b/java/debugger/impl/src/com/intellij/debugger/actions/JavaReferringObjectsValue.java new file mode 100644 index 000000000000..815ddd231f14 --- /dev/null +++ b/java/debugger/impl/src/com/intellij/debugger/actions/JavaReferringObjectsValue.java @@ -0,0 +1,172 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.debugger.actions; + +import com.intellij.debugger.DebuggerContext; +import com.intellij.debugger.engine.JavaValue; +import com.intellij.debugger.engine.evaluation.EvaluateException; +import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; +import com.intellij.debugger.engine.events.SuspendContextCommandImpl; +import com.intellij.debugger.ui.impl.watch.FieldDescriptorImpl; +import com.intellij.debugger.ui.impl.watch.NodeManagerImpl; +import com.intellij.debugger.ui.impl.watch.ValueDescriptorImpl; +import com.intellij.psi.PsiExpression; +import com.intellij.xdebugger.frame.*; +import com.intellij.xdebugger.frame.presentation.XValuePresentation; +import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodePresentationConfigurator; +import com.sun.jdi.Field; +import com.sun.jdi.ObjectReference; +import com.sun.jdi.Value; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.util.List; + +public class JavaReferringObjectsValue extends JavaValue { + private static final long MAX_REFERRING = 100; + private final boolean myIsField; + + private JavaReferringObjectsValue(@Nullable JavaValue parent, + @NotNull ValueDescriptorImpl valueDescriptor, + @NotNull EvaluationContextImpl evaluationContext, + NodeManagerImpl nodeManager, + boolean isField) { + super(parent, valueDescriptor, evaluationContext, nodeManager, false); + myIsField = isField; + } + + public JavaReferringObjectsValue(@NotNull JavaValue javaValue, boolean isField) { + super(null, javaValue.getDescriptor(), javaValue.getEvaluationContext(), null, false); + myIsField = isField; + } + + @Override + public boolean canNavigateToSource() { + return true; + } + + @Override + public void computeChildren(@NotNull final XCompositeNode node) { + getEvaluationContext().getDebugProcess().getManagerThread().schedule( + new SuspendContextCommandImpl(getEvaluationContext().getSuspendContext()) { + @Override + public Priority getPriority() { + return Priority.NORMAL; + } + + @Override + public void contextAction() throws Exception { + final XValueChildrenList children = new XValueChildrenList(); + + Value value = getDescriptor().getValue(); + List<ObjectReference> references = ((ObjectReference)value).referringObjects(MAX_REFERRING); + int i = 1; + for (final ObjectReference reference : references) { + // try to find field name + Field field = findField(reference, value); + if (field != null) { + ValueDescriptorImpl descriptor = new FieldDescriptorImpl(getProject(), reference, field) { + @Override + public Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException { + return reference; + } + }; + children.add(new JavaReferringObjectsValue(null, descriptor, getEvaluationContext(), null, true)); + i++; + } + else { + ValueDescriptorImpl descriptor = new ValueDescriptorImpl(getProject(), reference) { + @Override + public Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException { + return reference; + } + + @Override + public String getName() { + return "Ref"; + } + + @Override + public String calcValueName() { + return "Ref"; + } + + @Override + public PsiExpression getDescriptorEvaluation(DebuggerContext context) throws EvaluateException { + return null; + } + }; + children.add("Referrer " + i++, new JavaReferringObjectsValue(null, descriptor, getEvaluationContext(), null, false)); + } + } + + node.addChildren(children, true); + } + } + ); + } + + @Override + public void computePresentation(@NotNull final XValueNode node, @NotNull final XValuePlace place) { + if (!myIsField) { + super.computePresentation(node, place); + } + else { + super.computePresentation(new XValueNodePresentationConfigurator.ConfigurableXValueNodeImpl() { + @Override + public void applyPresentation(@Nullable Icon icon, @NotNull final XValuePresentation valuePresenter, boolean hasChildren) { + node.setPresentation(icon, new XValuePresentation() { + @NotNull + @Override + public String getSeparator() { + return " in "; + } + + @Nullable + @Override + public String getType() { + return valuePresenter.getType(); + } + + @Override + public void renderValue(@NotNull XValueTextRenderer renderer) { + valuePresenter.renderValue(renderer); + } + }, hasChildren); + } + + @Override + public void setFullValueEvaluator(@NotNull XFullValueEvaluator fullValueEvaluator) { + } + + @Override + public boolean isObsolete() { + return false; + } + }, place); + } + } + + private static Field findField(ObjectReference reference, Value value) { + for (Field field : reference.referenceType().allFields()) { + if (reference.getValue(field) == value) { + return field; + } + } + return null; + } +} diff --git a/java/debugger/impl/src/com/intellij/debugger/actions/ShowReferringObjectsAction.java b/java/debugger/impl/src/com/intellij/debugger/actions/ShowReferringObjectsAction.java deleted file mode 100644 index 68275af275c4..000000000000 --- a/java/debugger/impl/src/com/intellij/debugger/actions/ShowReferringObjectsAction.java +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright 2000-2014 JetBrains s.r.o. - * - * 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.intellij.debugger.actions; - -import com.intellij.debugger.DebuggerContext; -import com.intellij.debugger.engine.JavaValue; -import com.intellij.debugger.engine.evaluation.EvaluateException; -import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; -import com.intellij.debugger.engine.events.SuspendContextCommandImpl; -import com.intellij.debugger.ui.impl.watch.ValueDescriptorImpl; -import com.intellij.openapi.actionSystem.AnActionEvent; -import com.intellij.psi.PsiExpression; -import com.intellij.xdebugger.frame.*; -import com.intellij.xdebugger.impl.ui.tree.XDebuggerTree; -import com.intellij.xdebugger.impl.ui.tree.XInspectDialog; -import com.intellij.xdebugger.impl.ui.tree.actions.XDebuggerTreeActionBase; -import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl; -import com.sun.jdi.ObjectReference; -import com.sun.jdi.Value; -import org.jetbrains.annotations.NotNull; - -import java.util.List; - -/** - * @author egor - */ -public class ShowReferringObjectsAction extends XDebuggerTreeActionBase { - private static final long MAX_REFERRING = 100; - - @Override - public void update(AnActionEvent e) { - super.update(e); - } - - @Override - protected void perform(XValueNodeImpl node, @NotNull String nodeName, AnActionEvent e) { - XValue container = node.getValueContainer(); - JavaValue javaValue = null; - if (container instanceof ReferringObjectsValue) { - javaValue = ((ReferringObjectsValue)container).myJavaValue; - } - else if (container instanceof JavaValue) { - javaValue = ((JavaValue)container); - } - if (javaValue != null) { - XDebuggerTree tree = XDebuggerTree.getTree(e.getDataContext()); - XInspectDialog dialog = new XInspectDialog(tree.getProject(), - tree.getEditorsProvider(), - tree.getSourcePosition(), - nodeName, - new ReferringObjectsValue(javaValue), - tree.getValueMarkers()); - dialog.setTitle("Referring objects for " + nodeName); - dialog.show(); - } - } - - private static class ReferringObjectsValue extends XValue { - private final JavaValue myJavaValue; - - public ReferringObjectsValue(JavaValue javaValue) { - myJavaValue = javaValue; - } - - @Override - public void computePresentation(@NotNull XValueNode node, @NotNull XValuePlace place) { - myJavaValue.computePresentation(node, place); - } - - @Override - public void computeChildren(@NotNull final XCompositeNode node) { - myJavaValue.getEvaluationContext().getDebugProcess().getManagerThread().schedule( - new SuspendContextCommandImpl(myJavaValue.getEvaluationContext().getSuspendContext()) { - @Override - public Priority getPriority() { - return Priority.NORMAL; - } - - @Override - public void contextAction() throws Exception { - final XValueChildrenList children = new XValueChildrenList(); - - Value value = myJavaValue.getDescriptor().getValue(); - List<ObjectReference> references = ((ObjectReference)value).referringObjects(MAX_REFERRING); - int i = 1; - for (final ObjectReference reference : references) { - ValueDescriptorImpl descriptor = new ValueDescriptorImpl(myJavaValue.getProject(), reference) { - @Override - public Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException { - return reference; - } - - @Override - public String getName() { - return "Ref"; - } - - @Override - public String calcValueName() { - return "Ref"; - } - - @Override - public PsiExpression getDescriptorEvaluation(DebuggerContext context) throws EvaluateException { - return null; - } - }; - JavaValue jValue = JavaValue.create(descriptor, myJavaValue.getEvaluationContext(), null); - children.add("Referrer " + i++ ,new ReferringObjectsValue(jValue)); - } - - node.addChildren(children, true); - } - } - ); - } - } -} diff --git a/java/debugger/impl/src/com/intellij/debugger/actions/ToggleMethodBreakpointAction.java b/java/debugger/impl/src/com/intellij/debugger/actions/ToggleMethodBreakpointAction.java index 097039b0f9f4..b239fee363fc 100644 --- a/java/debugger/impl/src/com/intellij/debugger/actions/ToggleMethodBreakpointAction.java +++ b/java/debugger/impl/src/com/intellij/debugger/actions/ToggleMethodBreakpointAction.java @@ -38,6 +38,7 @@ import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiMethod; +import com.intellij.util.DocumentUtil; import com.intellij.util.text.CharArrayUtil; import org.jetbrains.annotations.Nullable; @@ -66,7 +67,7 @@ public class ToggleMethodBreakpointAction extends AnAction { } final BreakpointManager manager = debugManager.getBreakpointManager(); final PlaceInDocument place = getPlace(e); - if(place != null) { + if(place != null && DocumentUtil.isValidOffset(place.getOffset(), place.getDocument())) { Breakpoint breakpoint = manager.findBreakpoint(place.getDocument(), place.getOffset(), MethodBreakpoint.CATEGORY); if(breakpoint == null) { final int methodLine = place.getDocument().getLineNumber(place.getOffset()); diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/JavaDebuggerEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/engine/JavaDebuggerEvaluator.java index e37576bae8f4..f2178c1d4fb5 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/JavaDebuggerEvaluator.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/JavaDebuggerEvaluator.java @@ -15,6 +15,7 @@ */ package com.intellij.debugger.engine; +import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; import com.intellij.debugger.engine.evaluation.TextWithImportsImpl; import com.intellij.debugger.engine.events.DebuggerContextCommandImpl; @@ -73,9 +74,16 @@ public class JavaDebuggerEvaluator extends XDebuggerEvaluator { callback.errorOccurred("Context is not available"); return; } + descriptor.setContext(evalContext); + @SuppressWarnings("ThrowableResultOfMethodCallIgnored") + EvaluateException exception = descriptor.getEvaluateException(); + if (exception != null) { + callback.errorOccurred(exception.getMessage()); + return; + } JavaDebugProcess process = myDebugProcess.getXdebugProcess(); if (process != null) { - callback.evaluated(JavaValue.create(descriptor, evalContext, process.getNodeManager())); + callback.evaluated(JavaValue.create(null, descriptor, evalContext, process.getNodeManager(), true)); } } }); diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/JavaExecutionStack.java b/java/debugger/impl/src/com/intellij/debugger/engine/JavaExecutionStack.java index f2cb40008ad5..1bd95096055f 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/JavaExecutionStack.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/JavaExecutionStack.java @@ -17,7 +17,6 @@ package com.intellij.debugger.engine; import com.intellij.debugger.DebuggerBundle; import com.intellij.debugger.engine.evaluation.EvaluateException; -import com.intellij.debugger.engine.events.DebuggerCommandImpl; import com.intellij.debugger.engine.events.DebuggerContextCommandImpl; import com.intellij.debugger.engine.events.SuspendContextCommandImpl; import com.intellij.debugger.impl.DebuggerUtilsEx; @@ -46,7 +45,7 @@ public class JavaExecutionStack extends XExecutionStack { private final DebugProcessImpl myDebugProcess; private final NodeManagerImpl myNodeManager; private volatile JavaStackFrame myTopFrame; - private boolean myTopFrameReady = false; + private volatile boolean myTopFrameReady = false; private final MethodsTracker myTracker = new MethodsTracker(); public JavaExecutionStack(@NotNull ThreadReferenceProxyImpl threadProxy, @NotNull DebugProcessImpl debugProcess, boolean current) { @@ -99,25 +98,7 @@ public class JavaExecutionStack extends XExecutionStack { @Nullable @Override public JavaStackFrame getTopFrame() { - if (!myTopFrameReady) { - //TODO: remove sync calculation - if (DebuggerManagerThreadImpl.isManagerThread()) { - myTopFrame = calcTopFrame(); - } - else { - myDebugProcess.getManagerThread().invokeAndWait(new DebuggerCommandImpl() { - @Override - public Priority getPriority() { - return Priority.HIGH; - } - - @Override - protected void action() throws Exception { - myTopFrame = calcTopFrame(); - } - }); - } - } + assert myTopFrameReady : "Top frame must be already calculated here"; return myTopFrame; } @@ -183,8 +164,20 @@ public class JavaExecutionStack extends XExecutionStack { @Override public void contextAction() throws Exception { if (myStackFramesIterator.hasNext()) { - JavaStackFrame frame = new JavaStackFrame(myStackFramesIterator.next(), myDebugProcess, myTracker, myNodeManager); - if (DebuggerSettings.getInstance().SHOW_LIBRARY_STACKFRAMES || (!frame.getDescriptor().isSynthetic() && !frame.getDescriptor().isInLibraryContent())) { + JavaStackFrame frame; + boolean first = myAdded == 0; + if (first && myTopFrameReady) { + frame = myTopFrame; + myStackFramesIterator.next(); + } + else { + frame = new JavaStackFrame(myStackFramesIterator.next(), myDebugProcess, myTracker, myNodeManager); + if (first && !myTopFrameReady) { + myTopFrame = frame; + myTopFrameReady = true; + } + } + if (first || DebuggerSettings.getInstance().SHOW_LIBRARY_STACKFRAMES || (!frame.getDescriptor().isSynthetic() && !frame.getDescriptor().isInLibraryContent())) { if (++myAdded > mySkip) { myContainer.addStackFrames(Arrays.asList(frame), false); } diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/JavaStackFrame.java b/java/debugger/impl/src/com/intellij/debugger/engine/JavaStackFrame.java index 3f649e2b1dab..e7db635abe13 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/JavaStackFrame.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/JavaStackFrame.java @@ -370,7 +370,7 @@ public class JavaStackFrame extends XStackFrame { ArgumentValueDescriptorImpl descriptor = myNodeManager.getArgumentValueDescriptor(null, index, value, name); // setContext is required to calculate correct name descriptor.setContext(evaluationContext); - return JavaValue.create(descriptor, evaluationContext, myNodeManager); + return JavaValue.create(null, descriptor, evaluationContext, myNodeManager, true); } protected void superBuildVariables(final EvaluationContextImpl evaluationContext, XValueChildrenList children) throws EvaluateException { diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java b/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java index 9cfb2bfde84e..7b0ffffe98d5 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/JavaValue.java @@ -17,6 +17,7 @@ package com.intellij.debugger.engine; import com.intellij.debugger.DebuggerInvocationUtil; import com.intellij.debugger.SourcePosition; +import com.intellij.debugger.actions.JavaReferringObjectsValue; import com.intellij.debugger.actions.JumpToObjectAction; import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; @@ -66,27 +67,34 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV private final ValueDescriptorImpl myValueDescriptor; private final EvaluationContextImpl myEvaluationContext; private final NodeManagerImpl myNodeManager; + private final boolean myContextSet; - private JavaValue(JavaValue parent, + protected JavaValue(JavaValue parent, @NotNull ValueDescriptorImpl valueDescriptor, @NotNull EvaluationContextImpl evaluationContext, - NodeManagerImpl nodeManager) { + NodeManagerImpl nodeManager, + boolean contextSet) { super(valueDescriptor.getName()); myParent = parent; myValueDescriptor = valueDescriptor; myEvaluationContext = evaluationContext; myNodeManager = nodeManager; + myContextSet = contextSet; } - private static JavaValue create(JavaValue parent, @NotNull ValueDescriptorImpl valueDescriptor, EvaluationContextImpl evaluationContext, NodeManagerImpl nodeManager, boolean init) { + static JavaValue create(JavaValue parent, + @NotNull ValueDescriptorImpl valueDescriptor, + EvaluationContextImpl evaluationContext, + NodeManagerImpl nodeManager, + boolean contextSet) { DebuggerManagerThreadImpl.assertIsManagerThread(); - return new JavaValue(parent, valueDescriptor, evaluationContext, nodeManager); + return new JavaValue(parent, valueDescriptor, evaluationContext, nodeManager, contextSet); } - public static JavaValue create(@NotNull ValueDescriptorImpl valueDescriptor, + static JavaValue create(@NotNull ValueDescriptorImpl valueDescriptor, EvaluationContextImpl evaluationContext, NodeManagerImpl nodeManager) { - return create(null, valueDescriptor, evaluationContext, nodeManager, true); + return create(null, valueDescriptor, evaluationContext, nodeManager, false); } public JavaValue getParent() { @@ -113,7 +121,9 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV @Override public void threadAction() { - myValueDescriptor.setContext(myEvaluationContext); + if (!myContextSet) { + myValueDescriptor.setContext(myEvaluationContext); + } myValueDescriptor.updateRepresentation(myEvaluationContext, new DescriptorLabelListener() { @Override public void labelChanged() { @@ -123,12 +133,12 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV String type = strings[0]; XValuePresentation presentation; if (myValueDescriptor.isString()) { - presentation = new TypedStringValuePresentation(StringUtil.unquoteString(value), type); + presentation = new TypedStringValuePresentation(value, type); } else { EvaluateException exception = myValueDescriptor.getEvaluateException(); if (myValueDescriptor.getLastRenderer() instanceof ToStringRenderer && exception == null) { - presentation = new XRegularValuePresentation(StringUtil.wrapWithDoubleQuote(value), type); + presentation = new XRegularValuePresentation(StringUtil.wrapWithDoubleQuote(value.substring(0,Math.min(value.length(), XValueNode.MAX_VALUE_LENGTH))), type); } else { presentation = new JavaValuePresentation(value, type, exception != null ? exception.getMessage() : null); @@ -339,15 +349,16 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { + final boolean nearest = navigatable instanceof XNearestSourcePosition; if (myValueDescriptor instanceof FieldDescriptorImpl) { - SourcePosition position = ((FieldDescriptorImpl)myValueDescriptor).getSourcePosition(getProject(), getDebuggerContext()); + SourcePosition position = ((FieldDescriptorImpl)myValueDescriptor).getSourcePosition(getProject(), getDebuggerContext(), nearest); if (position != null) { navigatable.setSourcePosition(DebuggerUtilsEx.toXSourcePosition(position)); } } if (myValueDescriptor instanceof LocalVariableDescriptorImpl) { SourcePosition position = - ((LocalVariableDescriptorImpl)myValueDescriptor).getSourcePosition(getProject(), getDebuggerContext()); + ((LocalVariableDescriptorImpl)myValueDescriptor).getSourcePosition(getProject(), getDebuggerContext(), nearest); if (position != null) { navigatable.setSourcePosition(DebuggerUtilsEx.toXSourcePosition(position)); } @@ -442,4 +453,14 @@ public class JavaValue extends XNamedValue implements NodeDescriptorProvider, XV public String getValueText() { return myValueDescriptor.getValueText(); } + @Nullable + @Override + public XReferrersProvider getReferrersProvider() { + return new XReferrersProvider() { + @Override + public XValue getReferringObjectsValue() { + return new JavaReferringObjectsValue(JavaValue.this, false); + } + }; + } } diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java index 45af0e10ac72..83ad91b4e27d 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java @@ -40,6 +40,7 @@ import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiTypesUtil; +import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.util.IncorrectOperationException; import com.sun.jdi.Value; @@ -1036,7 +1037,8 @@ public class EvaluatorBuilderImpl implements EvaluatorBuilder { final PsiType castType = expression.getCastType().getType(); final PsiType operandType = operandExpr.getType(); - if (castType != null && operandType != null && !TypeConversionUtil.areTypesConvertible(operandType, castType)) { + // if operand type can not be resolved in current context - leave it for runtime checks + if (castType != null && operandType != null && !TypeConversionUtil.areTypesConvertible(operandType, castType) && PsiUtil.resolveClassInType(operandType) != null) { throw new EvaluateRuntimeException( new EvaluateException(JavaErrorMessages.message("inconvertible.type.cast", JavaHighlightUtil.formatType(operandType), JavaHighlightUtil .formatType(castType))) diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java index 2569559d2d11..6ba88653749b 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/MethodEvaluator.java @@ -21,21 +21,19 @@ package com.intellij.debugger.engine.evaluation.expression; import com.intellij.debugger.DebuggerBundle; +import com.intellij.debugger.engine.DebugProcess; import com.intellij.debugger.engine.DebugProcessImpl; import com.intellij.debugger.engine.DebuggerUtils; import com.intellij.debugger.engine.JVMName; -import com.intellij.debugger.engine.evaluation.EvaluateException; -import com.intellij.debugger.engine.evaluation.EvaluateExceptionUtil; -import com.intellij.debugger.engine.evaluation.EvaluateRuntimeException; -import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; +import com.intellij.debugger.engine.evaluation.*; import com.intellij.debugger.impl.DebuggerUtilsEx; +import com.intellij.debugger.jdi.VirtualMachineProxyImpl; import com.intellij.openapi.diagnostic.Logger; -import com.sun.jdi.ClassType; -import com.sun.jdi.Method; -import com.sun.jdi.ObjectReference; -import com.sun.jdi.ReferenceType; +import com.intellij.rt.debugger.DefaultMethodInvoker; +import com.sun.jdi.*; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; public class MethodEvaluator implements Evaluator { @@ -149,7 +147,13 @@ public class MethodEvaluator implements Evaluator { if (requiresSuperObject) { return debugProcess.invokeInstanceMethod(context, objRef, jdiMethod, args, ObjectReference.INVOKE_NONVIRTUAL); } - return debugProcess.invokeMethod(context, objRef, jdiMethod, args); + // fix for default methods in interfaces, see IDEA-124066 + if (Boolean.valueOf(System.getProperty("debugger.invoke.default")) && jdiMethod.declaringType() instanceof InterfaceType) { + return invokeDefaultMethod(debugProcess, context, objRef, myMethodName); + } + else { + return debugProcess.invokeMethod(context, objRef, jdiMethod, args); + } } catch (Exception e) { if (LOG.isDebugEnabled()) { @@ -158,4 +162,22 @@ public class MethodEvaluator implements Evaluator { throw EvaluateExceptionUtil.createEvaluateException(e); } } + + // only methods without arguments for now + private static Value invokeDefaultMethod(DebugProcess debugProcess, EvaluationContext evaluationContext, + Value obj, String name) + throws EvaluateException, ClassNotLoadedException, InvalidTypeException { + ClassType invokerClass = (ClassType)debugProcess.findClass( + evaluationContext, DefaultMethodInvoker.class.getName(), + evaluationContext.getClassLoader()); + + if (invokerClass != null) { + List<Method> methods = invokerClass.methodsByName("invoke"); + if (!methods.isEmpty()) { + return debugProcess.invokeMethod(evaluationContext, invokerClass, methods.get(0), + Arrays.asList(obj, ((VirtualMachineProxyImpl)debugProcess.getVirtualMachineProxy()).mirrorOf(name))); + } + } + return null; + } } diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerContextUtil.java b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerContextUtil.java index e75abd2f1e52..8408364f7e73 100644 --- a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerContextUtil.java +++ b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerContextUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,13 +15,27 @@ */ package com.intellij.debugger.impl; +import com.intellij.codeInsight.daemon.impl.IdentifierHighlighterPass; +import com.intellij.debugger.SourcePosition; import com.intellij.debugger.engine.SuspendContextImpl; import com.intellij.debugger.engine.SuspendManagerUtil; import com.intellij.debugger.jdi.StackFrameProxyImpl; import com.intellij.debugger.ui.impl.watch.ThreadDescriptorImpl; import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.util.Couple; +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.psi.util.PsiUtilBase; +import com.intellij.xdebugger.XDebugSession; +import com.intellij.xdebugger.XSourcePosition; import org.jetbrains.annotations.NotNull; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + public class DebuggerContextUtil { public static void setStackFrame(DebuggerStateManager manager, final StackFrameProxyImpl stackFrame) { ApplicationManager.getApplication().assertIsDispatchThread(); @@ -53,4 +67,43 @@ public class DebuggerContextUtil { public static DebuggerContextImpl createDebuggerContext(@NotNull DebuggerSession session, SuspendContextImpl suspendContext){ return DebuggerContextImpl.createDebuggerContext(session, suspendContext, suspendContext != null ? suspendContext.getThread() : null, null); } + + public static SourcePosition findNearest(@NotNull DebuggerContextImpl context, @NotNull PsiElement psi, @NotNull PsiFile file) { + final DebuggerSession session = context.getDebuggerSession(); + if (session != null) { + try { + final XDebugSession debugSession = session.getXDebugSession(); + if (debugSession != null) { + final XSourcePosition position = debugSession.getCurrentPosition(); + final Editor editor = PsiUtilBase.findEditor(psi); + if (editor != null && position != null && file.getVirtualFile().equals(position.getFile())) { + final Couple<Collection<TextRange>> usages = IdentifierHighlighterPass.getHighlightUsages(psi, file); + final List<TextRange> ranges = new ArrayList<TextRange>(); + ranges.addAll(usages.first); + ranges.addAll(usages.second); + final int breakPointLine = position.getLine(); + int bestLine = -1; + boolean hasSameLine = false; + for (TextRange range : ranges) { + final int line = editor.offsetToLogicalPosition(range.getStartOffset()).line; + if (line > bestLine && line < breakPointLine) { + bestLine = line; + } else if (line == breakPointLine) { + hasSameLine = true; + } + } + if (bestLine > 0) { + if (hasSameLine && breakPointLine - bestLine > 4) { + return SourcePosition.createFromLine(file, breakPointLine); + } + return SourcePosition.createFromLine(file, bestLine); + } + } + } + } + catch (Exception ignore) { + } + } + return SourcePosition.createFromOffset(file, psi.getTextOffset()); + } } diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/HotSwapProgressImpl.java b/java/debugger/impl/src/com/intellij/debugger/ui/HotSwapProgressImpl.java index b2b0091fc949..601ec7957849 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/HotSwapProgressImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/HotSwapProgressImpl.java @@ -38,7 +38,7 @@ import java.util.Collections; import java.util.List; public class HotSwapProgressImpl extends HotSwapProgress{ - static final NotificationGroup NOTIFICATION_GROUP = NotificationGroup.toolWindowGroup("HotSwap", ToolWindowId.DEBUG, true); + static final NotificationGroup NOTIFICATION_GROUP = NotificationGroup.toolWindowGroup("HotSwap", ToolWindowId.DEBUG); TIntObjectHashMap<List<String>> myMessages = new TIntObjectHashMap<List<String>>(); private final ProgressWindow myProgressWindow; diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/JavaDebuggerSupport.java b/java/debugger/impl/src/com/intellij/debugger/ui/JavaDebuggerSupport.java index 20d95f8fff3d..ec2288fa7a57 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/JavaDebuggerSupport.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/JavaDebuggerSupport.java @@ -165,7 +165,7 @@ public class JavaDebuggerSupport extends DebuggerSupport { @NotNull @Override public DebuggerActionHandler getAddToWatchesActionHandler() { - return myAddToWatchedActionHandler; + return DISABLED; } diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java new file mode 100644 index 000000000000..042216c40f05 --- /dev/null +++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java @@ -0,0 +1,217 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.debugger.ui.impl.watch; + +import com.intellij.debugger.engine.DebugProcess; +import com.intellij.debugger.engine.evaluation.EvaluateException; +import com.intellij.debugger.engine.evaluation.EvaluationContext; +import com.intellij.debugger.engine.evaluation.TextWithImports; +import com.intellij.debugger.engine.evaluation.expression.ExpressionEvaluator; +import com.intellij.debugger.engine.evaluation.expression.Modifier; +import com.intellij.debugger.jdi.VirtualMachineProxyImpl; +import com.sun.jdi.*; + +import javax.tools.*; +import java.io.ByteArrayOutputStream; +import java.net.URI; +import java.util.*; + +/** +* @author egor +*/ +class CompilingEvaluator implements ExpressionEvaluator { + private final TextWithImports myText; + + public CompilingEvaluator(TextWithImports text) { + myText = text; + } + + @Override + public Value getValue() { + return null; + } + + @Override + public Modifier getModifier() { + return null; + } + + @Override + public Value evaluate(EvaluationContext context) throws EvaluateException { + try { + DebugProcess process = context.getDebugProcess(); + ThreadReference threadReference = context.getSuspendContext().getThread().getThreadReference(); + + ClassLoaderReference classLoader = getClassLoader(context); + + Collection<OutputFileObject> classes = compile(); + + ClassType mainClass = defineClasses(classes, context, process, threadReference, classLoader); + + Method foo = mainClass.methodsByName(GEN_METHOD_NAME).get(0); + return mainClass.invokeMethod(threadReference, foo, Collections.<Value>emptyList() ,ClassType.INVOKE_SINGLE_THREADED); + } + catch (Exception e) { + throw new EvaluateException(e.getMessage()); + } + } + + private static ClassLoaderReference getClassLoader(EvaluationContext context) + throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException { + // TODO: cache + DebugProcess process = context.getDebugProcess(); + ClassType loaderClass = (ClassType)process.findClass(context, "java.net.URLClassLoader", context.getClassLoader()); + Method ctorMethod = loaderClass.concreteMethodByName("<init>", "([Ljava/net/URL;)V"); + ThreadReference threadReference = context.getSuspendContext().getThread().getThreadReference(); + return (ClassLoaderReference)loaderClass.newInstance(threadReference, ctorMethod, + Arrays.asList(createURLArray(context)), ClassType.INVOKE_SINGLE_THREADED); + } + + private static ClassType defineClasses(Collection<OutputFileObject> classes, + EvaluationContext context, + DebugProcess process, + ThreadReference threadReference, + ClassLoaderReference classLoader) + throws EvaluateException, InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException, InvocationException { + + VirtualMachineProxyImpl proxy = (VirtualMachineProxyImpl)process.getVirtualMachineProxy(); + for (OutputFileObject cls : classes) { + Method defineMethod = ((ClassType)classLoader.referenceType()).concreteMethodByName("defineClass", "(Ljava/lang/String;[BII)Ljava/lang/Class;"); + byte[] bytes = cls.toByteArray(); + ArrayList<Value> args = new ArrayList<Value>(); + args.add(proxy.mirrorOf(cls.myOrigName)); + args.add(mirrorOf(bytes, context, process)); + args.add(proxy.mirrorOf(0)); + args.add(proxy.mirrorOf(bytes.length)); + classLoader.invokeMethod(threadReference, defineMethod, args, ClassType.INVOKE_SINGLE_THREADED); + } + return (ClassType)process.findClass(context, GEN_CLASS_FULL_NAME, classLoader); + } + + private static ArrayReference mirrorOf(byte[] bytes, EvaluationContext context, DebugProcess process) + throws EvaluateException, InvalidTypeException, ClassNotLoadedException { + ArrayType arrayClass = (ArrayType)process.findClass(context, "byte[]", context.getClassLoader()); + ArrayReference reference = process.newInstance(arrayClass, bytes.length); + reference.disableCollection(); + for (int i = 0; i < bytes.length; i++) { + reference.setValue(i, ((VirtualMachineProxyImpl)process.getVirtualMachineProxy()).mirrorOf(bytes[i])); + } + return reference; + } + + private static final String GEN_CLASS_NAME = "Evaluator"; + private static final String GEN_CLASS_PACKAGE = "dummy"; + private static final String GEN_CLASS_FULL_NAME = GEN_CLASS_PACKAGE + '.' + GEN_CLASS_NAME; + private static final String GEN_METHOD_NAME = "eval"; + + private static String createClassCode(TextWithImports body) { + StringBuilder text = new StringBuilder(); + text.append("package " + GEN_CLASS_PACKAGE + ";"); + String imports = body.getImports(); + if (!imports.isEmpty()) { + for (String s : imports.split(",")) { + text.append("import " + s + ";"); + } + } + String bodyText = body.getText(); + if (!bodyText.endsWith(";")) { + bodyText += ';'; + } + text.append("public class " + GEN_CLASS_NAME + " { public static Object " + GEN_METHOD_NAME + "() throws Exception {" + bodyText + "}}"); + return text.toString(); + } + + private static ArrayReference createURLArray(EvaluationContext context) + throws EvaluateException, InvocationException, InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException { + DebugProcess process = context.getDebugProcess(); + ArrayType arrayType = (ArrayType)process.findClass(context, "java.net.URL[]", context.getClassLoader()); + ArrayReference arrayRef = arrayType.newInstance(1); + ClassType classType = (ClassType)process.findClass(context, "java.net.URL", context.getClassLoader()); + VirtualMachineProxyImpl proxy = (VirtualMachineProxyImpl)process.getVirtualMachineProxy(); + ThreadReference threadReference = context.getSuspendContext().getThread().getThreadReference(); + ObjectReference reference = classType.newInstance(threadReference, classType.concreteMethodByName("<init>", "(Ljava/lang/String;)V"), + Arrays.asList(proxy.mirrorOf("file:a")), ClassType.INVOKE_SINGLE_THREADED); + arrayRef.setValues(Arrays.asList(reference)); + return arrayRef; + } + + ///////////////// Compiler stuff + + private Collection<OutputFileObject> compile() throws EvaluateException { + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + MemoryFileManager manager = new MemoryFileManager(compiler); + DiagnosticCollector<JavaFileObject> diagnostic = new DiagnosticCollector<JavaFileObject>(); + if (!compiler.getTask(null, manager, diagnostic, null, null, Arrays + .asList(new SourceFileObject(GEN_CLASS_NAME, JavaFileObject.Kind.SOURCE, createClassCode(myText)))).call()) { + // TODO: show only errors + throw new EvaluateException(diagnostic.getDiagnostics().get(0).getMessage(Locale.getDefault())); + } + return manager.classes; + } + + private static URI getUri(String name, JavaFileObject.Kind kind) { + return URI.create("memo:///" + name.replace('.', '/') + kind.extension); + } + + private static class SourceFileObject extends SimpleJavaFileObject { + private final String myContent; + + SourceFileObject(String name, Kind kind, String content) { + super(getUri(name, kind), kind); + myContent = content; + } + + @Override + public CharSequence getCharContent(boolean ignore) { + return myContent; + } + } + + private static class OutputFileObject extends SimpleJavaFileObject { + private final ByteArrayOutputStream myStream = new ByteArrayOutputStream(); + private final String myOrigName; + + OutputFileObject(String name, Kind kind) { + super(getUri(name, kind), kind); + myOrigName = name; + } + + byte[] toByteArray() { + return myStream.toByteArray(); + } + + @Override + public ByteArrayOutputStream openOutputStream() { + return myStream; + } + } + + private static class MemoryFileManager extends ForwardingJavaFileManager { + private final Collection<OutputFileObject> classes = new ArrayList<OutputFileObject>(); + + MemoryFileManager(JavaCompiler compiler) { + super(compiler.getStandardFileManager(null, null, null)); + } + + @Override + public OutputFileObject getJavaFileForOutput(Location location, String name, JavaFileObject.Kind kind, FileObject source) { + OutputFileObject mc = new OutputFileObject(name, kind); + classes.add(mc); + return mc; + } + } + +} diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java index e09c17c979e5..1f880513cacd 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java @@ -28,6 +28,7 @@ import com.intellij.debugger.impl.DebuggerUtilsEx; import com.intellij.debugger.impl.PositionUtil; import com.intellij.debugger.jdi.StackFrameProxyImpl; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.registry.Registry; import com.intellij.psi.PsiCodeFragment; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiExpression; @@ -80,14 +81,20 @@ public abstract class EvaluationDescriptor extends ValueDescriptorImpl{ try { final EvaluationContextImpl thisEvaluationContext = getEvaluationContext(evaluationContext); - final ExpressionEvaluator evaluator = DebuggerInvocationUtil.commitAndRunReadAction(myProject, new EvaluatingComputable<ExpressionEvaluator>() { - public ExpressionEvaluator compute() throws EvaluateException { - final PsiElement psiContext = PositionUtil.getContextElement(evaluationContext); - return getEffectiveCodeFragmentFactory(psiContext).getEvaluatorBuilder().build(getEvaluationCode(thisEvaluationContext), - ContextUtil.getSourcePosition(thisEvaluationContext)); - } - }); - + final ExpressionEvaluator evaluator; + if (Registry.is("debugger.compiling.evaluator")) { + evaluator = new CompilingEvaluator(getEvaluationText()); + } + else { + evaluator = DebuggerInvocationUtil.commitAndRunReadAction(myProject, new EvaluatingComputable<ExpressionEvaluator>() { + public ExpressionEvaluator compute() throws EvaluateException { + final PsiElement psiContext = PositionUtil.getContextElement(evaluationContext); + return getEffectiveCodeFragmentFactory(psiContext).getEvaluatorBuilder().build(getEvaluationCode(thisEvaluationContext), + ContextUtil + .getSourcePosition(thisEvaluationContext)); + } + }); + } if (!thisEvaluationContext.getDebugProcess().isAttached()) { throw EvaluateExceptionUtil.PROCESS_EXITED; diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/FieldDescriptorImpl.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/FieldDescriptorImpl.java index 6a7a57ba7670..c36630e3a973 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/FieldDescriptorImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/FieldDescriptorImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,6 +26,7 @@ import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluateExceptionUtil; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; import com.intellij.debugger.impl.DebuggerContextImpl; +import com.intellij.debugger.impl.DebuggerContextUtil; import com.intellij.debugger.impl.DebuggerSession; import com.intellij.debugger.impl.PositionUtil; import com.intellij.debugger.settings.NodeRendererSettings; @@ -73,6 +74,12 @@ public class FieldDescriptorImpl extends ValueDescriptorImpl implements FieldDes @SuppressWarnings({"HardCodedStringLiteral"}) @Nullable public SourcePosition getSourcePosition(final Project project, final DebuggerContextImpl context) { + return getSourcePosition(project, context, false); + } + + @SuppressWarnings({"HardCodedStringLiteral"}) + @Nullable + public SourcePosition getSourcePosition(final Project project, final DebuggerContextImpl context, boolean nearest) { if (context.getFrameProxy() == null) { return null; } @@ -95,6 +102,9 @@ public class FieldDescriptorImpl extends ValueDescriptorImpl implements FieldDes if (psiVariable == null) { return null; } + if (nearest) { + return DebuggerContextUtil.findNearest(context, psiVariable, aClass.getContainingFile()); + } return SourcePosition.createFromOffset(psiVariable.getContainingFile(), psiVariable.getTextOffset()); } else { @@ -125,6 +135,9 @@ public class FieldDescriptorImpl extends ValueDescriptorImpl implements FieldDes aClass = (PsiClass) aClass.getNavigationElement(); for (PsiField field : aClass.getFields()) { if (fieldName.equals(field.getName())) { + if (nearest) { + return DebuggerContextUtil.findNearest(context, field, aClass.getContainingFile()); + } return SourcePosition.createFromOffset(field.getContainingFile(), field.getTextOffset()); } } diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/LocalVariableDescriptorImpl.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/LocalVariableDescriptorImpl.java index d2109c54f1c4..f936d79a6725 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/LocalVariableDescriptorImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/LocalVariableDescriptorImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,6 +22,7 @@ import com.intellij.debugger.engine.DebuggerUtils; import com.intellij.debugger.engine.evaluation.EvaluateException; import com.intellij.debugger.engine.evaluation.EvaluationContextImpl; import com.intellij.debugger.impl.DebuggerContextImpl; +import com.intellij.debugger.impl.DebuggerContextUtil; import com.intellij.debugger.impl.PositionUtil; import com.intellij.debugger.jdi.LocalVariableProxyImpl; import com.intellij.debugger.jdi.StackFrameProxyImpl; @@ -61,6 +62,11 @@ public class LocalVariableDescriptorImpl extends ValueDescriptorImpl implements @Nullable public SourcePosition getSourcePosition(final Project project, final DebuggerContextImpl context) { + return getSourcePosition(project, context, false); + } + + @Nullable + public SourcePosition getSourcePosition(final Project project, final DebuggerContextImpl context, boolean nearest) { StackFrameProxyImpl frame = context.getFrameProxy(); if (frame == null) return null; @@ -77,7 +83,9 @@ public class LocalVariableDescriptorImpl extends ValueDescriptorImpl implements PsiFile containingFile = psiVariable.getContainingFile(); if(containingFile == null) return null; - + if (nearest) { + return DebuggerContextUtil.findNearest(context, psiVariable, containingFile); + } return SourcePosition.createFromOffset(containingFile, psiVariable.getTextOffset()); } diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/ValueDescriptorImpl.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/ValueDescriptorImpl.java index f4da39f318a7..680d2ab424c3 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/ValueDescriptorImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/ValueDescriptorImpl.java @@ -203,6 +203,7 @@ public abstract class ValueDescriptorImpl extends NodeDescriptorImpl implements } catch (EvaluateException e) { myValueException = e; + setFailed(e); myValue = getTargetExceptionWithStackTraceFilled(evaluationContext, e); myIsExpandable = false; } diff --git a/java/debugger/openapi/src/com/intellij/debugger/SourcePosition.java b/java/debugger/openapi/src/com/intellij/debugger/SourcePosition.java index 9028b1489970..45f50d34b922 100644 --- a/java/debugger/openapi/src/com/intellij/debugger/SourcePosition.java +++ b/java/debugger/openapi/src/com/intellij/debugger/SourcePosition.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -128,7 +128,12 @@ public abstract class SourcePosition implements Navigatable{ return true; } final PsiElement psiElement = myPsiElement; - return psiElement != null && !psiElement.isValid(); + return psiElement != null && !ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + return psiElement.isValid(); + } + }); } @Override @@ -194,7 +199,7 @@ public abstract class SourcePosition implements Navigatable{ @Nullable protected PsiElement calcPsiElement() { - PsiFile psiFile = getFile(); + final PsiFile psiFile = getFile(); int lineNumber = getLine(); if(lineNumber < 0) { return psiFile; @@ -207,47 +212,52 @@ public abstract class SourcePosition implements Navigatable{ if (lineNumber >= document.getLineCount()) { return psiFile; } - int startOffset = document.getLineStartOffset(lineNumber); + final int startOffset = document.getLineStartOffset(lineNumber); if(startOffset == -1) { return null; } - PsiElement rootElement = psiFile; - - List<PsiFile> allFiles = psiFile.getViewProvider().getAllFiles(); - if (allFiles.size() > 1) { // jsp & gsp - PsiClassOwner owner = ContainerUtil.findInstance(allFiles, PsiClassOwner.class); - if (owner != null) { - PsiClass[] classes = owner.getClasses(); - if (classes.length == 1 && classes[0] instanceof SyntheticElement) { - rootElement = classes[0]; + return ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { + @Override + public PsiElement compute() { + PsiElement rootElement = psiFile; + + List<PsiFile> allFiles = psiFile.getViewProvider().getAllFiles(); + if (allFiles.size() > 1) { // jsp & gsp + PsiClassOwner owner = ContainerUtil.findInstance(allFiles, PsiClassOwner.class); + if (owner != null) { + PsiClass[] classes = owner.getClasses(); + if (classes.length == 1 && classes[0] instanceof SyntheticElement) { + rootElement = classes[0]; + } + } } - } - } - PsiElement element; - while(true) { - final CharSequence charsSequence = document.getCharsSequence(); - for (; startOffset < charsSequence.length(); startOffset++) { - char c = charsSequence.charAt(startOffset); - if (c != ' ' && c != '\t') { - break; + PsiElement element; + int offset = startOffset; + while (true) { + final CharSequence charsSequence = document.getCharsSequence(); + for (; offset < charsSequence.length(); offset++) { + char c = charsSequence.charAt(offset); + if (c != ' ' && c != '\t') { + break; + } + } + element = rootElement.findElementAt(offset); + + if (element instanceof PsiComment) { + offset = element.getTextRange().getEndOffset() + 1; + } + else { + break; + } } + if (element != null && element.getParent() instanceof PsiForStatement) { + return ((PsiForStatement)element.getParent()).getInitialization(); + } + return element; } - element = rootElement.findElementAt(startOffset); - - if(element instanceof PsiComment) { - startOffset = element.getTextRange().getEndOffset() + 1; - } - else{ - break; - } - } - - if (element != null && element.getParent() instanceof PsiForStatement) { - return ((PsiForStatement)element.getParent()).getInitialization(); - } - return element; + }); } } diff --git a/java/execution/impl/src/com/intellij/execution/impl/DefaultJavaProgramRunner.java b/java/execution/impl/src/com/intellij/execution/impl/DefaultJavaProgramRunner.java index 27280b193c2c..626a47509144 100644 --- a/java/execution/impl/src/com/intellij/execution/impl/DefaultJavaProgramRunner.java +++ b/java/execution/impl/src/com/intellij/execution/impl/DefaultJavaProgramRunner.java @@ -69,10 +69,7 @@ public class DefaultJavaProgramRunner extends JavaPatchableProgramRunner { } @Override - protected RunContentDescriptor doExecute(@NotNull final Project project, - @NotNull final RunProfileState state, - final RunContentDescriptor contentToReuse, - @NotNull final ExecutionEnvironment env) throws ExecutionException { + protected RunContentDescriptor doExecute(@NotNull final RunProfileState state, @NotNull final ExecutionEnvironment env) throws ExecutionException { FileDocumentManager.getInstance().saveAllDocuments(); ExecutionResult executionResult; @@ -100,11 +97,11 @@ public class DefaultJavaProgramRunner extends JavaPatchableProgramRunner { onProcessStarted(env.getRunnerSettings(), executionResult); final RunContentBuilder contentBuilder = new RunContentBuilder(executionResult, env); - Disposer.register(project, contentBuilder); + Disposer.register(env.getProject(), contentBuilder); if (shouldAddDefaultActions) { addDefaultActions(contentBuilder); } - return contentBuilder.showRunContent(contentToReuse); + return contentBuilder.showRunContent(env.getContentToReuse()); } @Deprecated diff --git a/java/execution/openapi/src/com/intellij/execution/configurations/JavaParameters.java b/java/execution/openapi/src/com/intellij/execution/configurations/JavaParameters.java index daf045c2638f..bf89d82ea5c1 100644 --- a/java/execution/openapi/src/com/intellij/execution/configurations/JavaParameters.java +++ b/java/execution/openapi/src/com/intellij/execution/configurations/JavaParameters.java @@ -18,6 +18,7 @@ package com.intellij.execution.configurations; import com.intellij.execution.CantRunException; import com.intellij.execution.ExecutionBundle; import com.intellij.openapi.actionSystem.DataKey; +import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.Module; import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; @@ -25,6 +26,7 @@ import com.intellij.openapi.roots.*; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.encoding.EncodingProjectManager; import com.intellij.util.NotNullFunction; +import com.intellij.util.PathsList; import org.intellij.lang.annotations.MagicConstant; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -32,6 +34,8 @@ import org.jetbrains.annotations.Nullable; import java.nio.charset.Charset; public class JavaParameters extends SimpleJavaParameters { + private static final Logger LOG = Logger.getInstance(JavaParameters.class); + private static final String JAVA_LIBRARY_PATH_PROPERTY = "java.library.path"; public static final DataKey<JavaParameters> JAVA_PARAMETERS = DataKey.create("javaParameters"); public String getJdkPath() throws CantRunException { @@ -70,6 +74,21 @@ public class JavaParameters extends SimpleJavaParameters { setDefaultCharset(module.getProject()); configureEnumerator(OrderEnumerator.orderEntries(module).runtimeOnly().recursively(), classPathType, jdk).collectPaths(getClassPath()); + configureJavaLibraryPath(OrderEnumerator.orderEntries(module).recursively()); + } + + private void configureJavaLibraryPath(OrderEnumerator enumerator) { + PathsList pathsList = new PathsList(); + enumerator.runtimeOnly().withoutSdk().roots(NativeLibraryOrderRootType.getInstance()).collectPaths(pathsList); + if (!pathsList.getPathList().isEmpty()) { + ParametersList vmParameters = getVMParametersList(); + if (vmParameters.hasProperty(JAVA_LIBRARY_PATH_PROPERTY)) { + LOG.info(JAVA_LIBRARY_PATH_PROPERTY + " property is already specified, native library paths from dependencies (" + pathsList.getPathsString() + ") won't be added"); + } + else { + vmParameters.addProperty(JAVA_LIBRARY_PATH_PROPERTY, pathsList.getPathsString()); + } + } } @Nullable @@ -123,6 +142,7 @@ public class JavaParameters extends SimpleJavaParameters { } setDefaultCharset(project); configureEnumerator(OrderEnumerator.orderEntries(project).runtimeOnly(), classPathType, jdk).collectPaths(getClassPath()); + configureJavaLibraryPath(OrderEnumerator.orderEntries(project)); } private static OrderRootsEnumerator configureEnumerator(OrderEnumerator enumerator, @MagicConstant(valuesFromClass = JavaParameters.class) int classPathType, Sdk jdk) { diff --git a/java/idea-ui/src/com/intellij/facet/impl/ui/libraries/LibraryOptionsPanel.java b/java/idea-ui/src/com/intellij/facet/impl/ui/libraries/LibraryOptionsPanel.java index d44864e1485c..3bb96adb1141 100644 --- a/java/idea-ui/src/com/intellij/facet/impl/ui/libraries/LibraryOptionsPanel.java +++ b/java/idea-ui/src/com/intellij/facet/impl/ui/libraries/LibraryOptionsPanel.java @@ -246,7 +246,7 @@ public class LibraryOptionsPanel implements Disposable { onVersionChanged(getPresentableVersion()); } }); - myExistingLibraryComboBox.setRenderer(new ColoredListCellRenderer() { + myExistingLibraryComboBox.setRenderer(new ColoredListCellRenderer(myExistingLibraryComboBox) { @Override protected void customizeCellRenderer(JList list, Object value, int index, boolean selected, boolean hasFocus) { if (value == null) { diff --git a/java/idea-ui/src/com/intellij/ide/actions/ImportModuleAction.java b/java/idea-ui/src/com/intellij/ide/actions/ImportModuleAction.java index 2faa20bc412d..3d497b829d50 100644 --- a/java/idea-ui/src/com/intellij/ide/actions/ImportModuleAction.java +++ b/java/idea-ui/src/com/intellij/ide/actions/ImportModuleAction.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,6 +24,7 @@ import com.intellij.openapi.actionSystem.AnAction; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.actionSystem.Presentation; import com.intellij.openapi.fileChooser.FileChooserDescriptor; +import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory; import com.intellij.openapi.fileChooser.FileChooserDialog; import com.intellij.openapi.fileChooser.FileChooserFactory; import com.intellij.openapi.module.Module; @@ -39,7 +40,6 @@ import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import javax.swing.*; import java.awt.*; import java.util.Arrays; import java.util.Collections; @@ -94,14 +94,7 @@ public class ImportModuleAction extends AnAction { @Nullable public static AddModuleWizard selectFileAndCreateWizard(final Project project, Component dialogParent) { - FileChooserDescriptor descriptor = new FileChooserDescriptor(true, true, true, true, false, false) { - FileChooserDescriptor myDelegate = new OpenProjectFileChooserDescriptor(true); - @Override - public Icon getIcon(VirtualFile file) { - Icon icon = myDelegate.getIcon(file); - return icon == null ? super.getIcon(file) : icon; - } - }; + FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleLocalFileDescriptor(); descriptor.setHideIgnored(false); descriptor.setTitle("Select File or Directory to Import"); ProjectImportProvider[] providers = ProjectImportProvider.PROJECT_IMPORT_PROVIDER.getExtensions(); diff --git a/java/idea-ui/src/com/intellij/ide/actions/OpenProjectAction.java b/java/idea-ui/src/com/intellij/ide/actions/OpenProjectAction.java deleted file mode 100644 index 8cbb5543db6b..000000000000 --- a/java/idea-ui/src/com/intellij/ide/actions/OpenProjectAction.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright 2000-2013 JetBrains s.r.o. - * - * 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.intellij.ide.actions; - -import com.intellij.ide.IdeBundle; -import com.intellij.ide.highlighter.ProjectFileType; -import com.intellij.ide.impl.ProjectUtil; -import com.intellij.openapi.actionSystem.ActionPlaces; -import com.intellij.openapi.actionSystem.AnAction; -import com.intellij.openapi.actionSystem.AnActionEvent; -import com.intellij.openapi.actionSystem.CommonDataKeys; -import com.intellij.openapi.actionSystem.PlatformDataKeys; -import com.intellij.openapi.extensions.Extensions; -import com.intellij.openapi.fileChooser.FileChooser; -import com.intellij.openapi.fileChooser.FileChooserDescriptor; -import com.intellij.openapi.fileChooser.PathChooserDialog; -import com.intellij.openapi.project.DumbAware; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.SystemInfo; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.openapi.vfs.VfsUtil; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.projectImport.ProjectOpenProcessor; -import com.intellij.projectImport.ProjectOpenProcessorBase; -import com.intellij.util.Consumer; - -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -public class OpenProjectAction extends AnAction implements DumbAware { - public void actionPerformed(AnActionEvent e) { - final FileChooserDescriptor descriptor = new OpenProjectFileChooserDescriptor(true); - descriptor.setTitle(IdeBundle.message("title.open.project")); - final Set<String> extensions = new LinkedHashSet<String>(); - extensions.add(ProjectFileType.DOT_DEFAULT_EXTENSION); - final ProjectOpenProcessor[] openProcessors = Extensions.getExtensions(ProjectOpenProcessor.EXTENSION_POINT_NAME); - for (ProjectOpenProcessor openProcessor : openProcessors) { - if (!(openProcessor instanceof ProjectOpenProcessorBase)) continue; - final String[] supportedExtensions = ((ProjectOpenProcessorBase)openProcessor).getSupportedExtensions(); - if (supportedExtensions != null) { - Collections.addAll(extensions, supportedExtensions); - } - } - descriptor.setDescription(IdeBundle.message("filter.project.files", StringUtil.join(extensions, ", "))); - - VirtualFile userHomeDir = null; - if (SystemInfo.isUnix) { - userHomeDir = VfsUtil.getUserHomeDir(); - } - - descriptor.putUserData(PathChooserDialog.PREFER_LAST_OVER_EXPLICIT, Boolean.TRUE); - - final Project project = CommonDataKeys.PROJECT.getData(e.getDataContext()); - FileChooser.chooseFiles(descriptor, project, userHomeDir, new Consumer<List<VirtualFile>>() { - @Override - public void consume(final List<VirtualFile> files) { - if (files.size() == 1) { - ProjectUtil.openOrImport(files.get(0).getPath(), project, false); - } - } - }); - } - - @Override - public void update(AnActionEvent e) { - super.update(e); - e.getPresentation().setEnabledAndVisible(ActionPlaces.WELCOME_SCREEN.equals(e.getPlace())); - } -}
\ No newline at end of file diff --git a/java/idea-ui/src/com/intellij/ide/actions/ShowStructureSettingsAction.java b/java/idea-ui/src/com/intellij/ide/actions/ShowStructureSettingsAction.java index ded07d482ed3..b43698ece136 100644 --- a/java/idea-ui/src/com/intellij/ide/actions/ShowStructureSettingsAction.java +++ b/java/idea-ui/src/com/intellij/ide/actions/ShowStructureSettingsAction.java @@ -37,6 +37,7 @@ import javax.swing.border.CompoundBorder; import javax.swing.border.EmptyBorder; public class ShowStructureSettingsAction extends AnAction implements DumbAware { + @Override public void actionPerformed(AnActionEvent e) { Project project = CommonDataKeys.PROJECT.getData(e.getDataContext()); if (project == null) { @@ -56,12 +57,13 @@ public class ShowStructureSettingsAction extends AnAction implements DumbAware { protected JComponent createSouthPanel() { JComponent panel = super.createSouthPanel(); assert panel != null; - CustomLineBorder line = new CustomLineBorder(new JBColor(Gray._153, Gray._80), 1, 0, 0, 0); + CustomLineBorder line = new CustomLineBorder(new JBColor(Gray._153.withAlpha(128), Gray._100.withAlpha(128)), 1, 0, 0, 0); panel.setBorder(new CompoundBorder(line, new EmptyBorder(10, 5, 5, 5))); return panel; } }.show(); - } else { + } + else { ShowSettingsUtil .getInstance().editConfigurable(project, OptionsEditorDialog.DIMENSION_KEY, ProjectStructureConfigurable.getInstance(project)); } diff --git a/java/idea-ui/src/com/intellij/ide/actions/TemplateProjectStructureAction.java b/java/idea-ui/src/com/intellij/ide/actions/TemplateProjectStructureAction.java index 0255cb005ee7..093552e12be0 100644 --- a/java/idea-ui/src/com/intellij/ide/actions/TemplateProjectStructureAction.java +++ b/java/idea-ui/src/com/intellij/ide/actions/TemplateProjectStructureAction.java @@ -25,6 +25,7 @@ import com.intellij.openapi.project.ex.ProjectManagerEx; import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable; public class TemplateProjectStructureAction extends AnAction implements DumbAware { + @Override public void actionPerformed(final AnActionEvent e) { Project defaultProject = ProjectManagerEx.getInstanceEx().getDefaultProject(); ShowSettingsUtil.getInstance().editConfigurable(defaultProject, OptionsEditorDialog.DIMENSION_KEY, ProjectStructureConfigurable.getInstance(defaultProject)); diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/DefaultLibraryRootsComponentDescriptor.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/DefaultLibraryRootsComponentDescriptor.java index 34bd02b84950..eb87df2a47e7 100644 --- a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/DefaultLibraryRootsComponentDescriptor.java +++ b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/DefaultLibraryRootsComponentDescriptor.java @@ -16,6 +16,7 @@ package com.intellij.openapi.roots.ui.configuration.libraryEditor; import com.intellij.codeInsight.ExternalAnnotationsManager; +import com.intellij.openapi.fileChooser.FileChooserDescriptor; import com.intellij.openapi.fileTypes.StdFileTypes; import com.intellij.openapi.module.Module; import com.intellij.openapi.progress.ProgressIndicator; @@ -23,22 +24,22 @@ import com.intellij.openapi.project.ProjectBundle; import com.intellij.openapi.projectRoots.ui.Util; import com.intellij.openapi.roots.AnnotationOrderRootType; import com.intellij.openapi.roots.JavadocOrderRootType; +import com.intellij.openapi.roots.NativeLibraryOrderRootType; import com.intellij.openapi.roots.OrderRootType; import com.intellij.openapi.roots.libraries.ui.*; import com.intellij.openapi.roots.ui.OrderRootTypeUIFactory; import com.intellij.openapi.roots.ui.configuration.PathUIUtils; +import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileVisitor; import com.intellij.util.IconUtil; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.swing.*; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; +import java.util.*; /** * @author nik @@ -63,7 +64,15 @@ public class DefaultLibraryRootsComponentDescriptor extends LibraryRootsComponen PathUIUtils.JAVA_SOURCE_ROOT_DETECTOR, new FileTypeBasedRootFilter(OrderRootType.SOURCES, true, StdFileTypes.JAVA, "source archive directory"), new JavadocRootDetector(), - new AnnotationsRootFilter()); + new AnnotationsRootFilter(), new NativeLibraryRootFilter()); + } + + @NotNull + @Override + public FileChooserDescriptor createAttachFilesChooserDescriptor(@Nullable String libraryName) { + FileChooserDescriptor descriptor = super.createAttachFilesChooserDescriptor(libraryName); + descriptor.setDescription(ProjectBundle.message("library.java.attach.files.description")); + return descriptor; } public static OrderRootTypePresentation getDefaultPresentation(OrderRootType type) { @@ -110,6 +119,27 @@ public class DefaultLibraryRootsComponentDescriptor extends LibraryRootsComponen } } + private static class NativeLibraryRootFilter extends RootFilter { + private static final Set<String> NATIVE_LIBRARY_EXTENSIONS = ContainerUtil.newTroveSet(FileUtil.PATH_HASHING_STRATEGY, "dll", "so", "dylib"); + + private NativeLibraryRootFilter() { + super(NativeLibraryOrderRootType.getInstance(), false, "external annotations"); + } + + @Override + public boolean isAccepted(@NotNull VirtualFile rootCandidate, @NotNull ProgressIndicator progressIndicator) { + if (rootCandidate.isDirectory()) { + for (VirtualFile file : rootCandidate.getChildren()) { + String extension = file.getExtension(); + if (extension != null && NATIVE_LIBRARY_EXTENSIONS.contains(extension)) { + return true; + } + } + } + return false; + } + } + private static class AttachUrlJavadocDescriptor extends AttachRootButtonDescriptor { private AttachUrlJavadocDescriptor() { super(JavadocOrderRootType.getInstance(), IconUtil.getAddLinkIcon(), ProjectBundle.message("module.libraries.javadoc.url.button")); diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/NativeLibraryOrderRootTypeUIFactory.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/NativeLibraryOrderRootTypeUIFactory.java new file mode 100644 index 000000000000..85ddcc42405c --- /dev/null +++ b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/NativeLibraryOrderRootTypeUIFactory.java @@ -0,0 +1,46 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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. + */ + +/* + * User: anna + * Date: 26-Dec-2007 + */ +package com.intellij.openapi.roots.ui.configuration.libraryEditor; + +import com.intellij.icons.AllIcons; +import com.intellij.openapi.project.ProjectBundle; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.projectRoots.ui.SdkPathEditor; +import com.intellij.openapi.roots.ui.OrderRootTypeUIFactory; + +import javax.swing.*; + +public class NativeLibraryOrderRootTypeUIFactory implements OrderRootTypeUIFactory { + @Override + public Icon getIcon() { + return AllIcons.Nodes.NativeLibrariesFolder; + } + + @Override + public String getNodeText() { + return ProjectBundle.message("project.roots.native.library.node.text"); + } + + @Override + public SdkPathEditor createPathEditor(Sdk sdk) { + return null; + } +} diff --git a/java/java-analysis-impl/src/com/intellij/analysis/JavaAnalysisScope.java b/java/java-analysis-impl/src/com/intellij/analysis/JavaAnalysisScope.java index c69b3739f00b..681d0e4ca51a 100644 --- a/java/java-analysis-impl/src/com/intellij/analysis/JavaAnalysisScope.java +++ b/java/java-analysis-impl/src/com/intellij/analysis/JavaAnalysisScope.java @@ -85,14 +85,16 @@ public class JavaAnalysisScope extends AnalysisScope { } - + @NotNull @Override public String getShortenName() { - if (myType == PACKAGE) - return AnalysisScopeBundle.message("scope.package", ((PsiPackage)myElement).getQualifiedName()); + if (myType == PACKAGE) { + return AnalysisScopeBundle.message("scope.package", ((PsiPackage)myElement).getQualifiedName()); + } return super.getShortenName(); } + @NotNull @Override public String getDisplayName() { if (myType == PACKAGE) { @@ -125,7 +127,8 @@ public class JavaAnalysisScope extends AnalysisScope { for (PsiDirectory dir : dirs) { accept(dir, visitor, needReadAction); } - } else { + } + else { super.accept(visitor, needReadAction); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/JavaHighlightInfoTypes.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/JavaHighlightInfoTypes.java index 6e69b5a157a9..2558ccf43feb 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/JavaHighlightInfoTypes.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/JavaHighlightInfoTypes.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,7 +25,7 @@ import com.intellij.openapi.editor.colors.CodeInsightColors; * @author anna * Date: 01-Feb-2008 */ -public interface JavaHighlightInfoTypes extends HighlightInfoType { +public interface JavaHighlightInfoTypes { HighlightInfoType UNUSED_IMPORT = new HighlightInfoType.HighlightInfoTypeSeverityByKey( HighlightDisplayKey.findOrRegister(UnusedImportLocalInspection.SHORT_NAME, UnusedImportLocalInspection.DISPLAY_NAME), CodeInsightColors.NOT_USED_ELEMENT_ATTRIBUTES); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Analysis.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Analysis.java index 47ef448c7484..01993d5e9dd0 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Analysis.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Analysis.java @@ -15,7 +15,10 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; -import gnu.trove.TIntObjectHashMap; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph; +import com.intellij.codeInspection.bytecodeAnalysis.asm.DFSTree; +import com.intellij.codeInspection.bytecodeAnalysis.asm.RichControlFlow; +import org.jetbrains.annotations.NotNull; import org.jetbrains.org.objectweb.asm.Opcodes; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.tree.MethodNode; @@ -71,6 +74,12 @@ class AbstractValues { } } + static final BasicValue CLASS_VALUE = new NotNullValue(Type.getObjectType("java/lang/Class")); + static final BasicValue METHOD_VALUE = new NotNullValue(Type.getObjectType("java/lang/invoke/MethodType")); + static final BasicValue STRING_VALUE = new NotNullValue(Type.getObjectType("java/lang/String")); + static final BasicValue METHOD_HANDLE_VALUE = new NotNullValue(Type.getObjectType("java/lang/invoke/MethodHandle")); + + static boolean isInstance(Conf curr, Conf prev) { if (curr.insnIndex != prev.insnIndex) { return false; @@ -187,50 +196,30 @@ final class State { } } -interface PendingAction<Res> {} -class ProceedState<Res> implements PendingAction<Res> { - final State state; - - ProceedState(State state) { - this.state = state; - } -} -class MakeResult<Res> implements PendingAction<Res> { - final State state; - final Res subResult; - final int[] indices; - - MakeResult(State state, Res subResult, int[] indices) { - this.state = state; - this.subResult = subResult; - this.indices = indices; - } -} - abstract class Analysis<Res> { + public static final int STEPS_LIMIT = 30000; public static final int EQUATION_SIZE_LIMIT = 30; + + protected static final ThreadLocal<State[]> ourPendingStates = new ThreadLocal<State[]>() { + @Override + protected State[] initialValue() { + return new State[STEPS_LIMIT]; + } + }; + final RichControlFlow richControlFlow; final Direction direction; final ControlFlowGraph controlFlow; final MethodNode methodNode; final Method method; final DFSTree dfsTree; - final Res myIdentity; - final Deque<PendingAction<Res>> pending = new LinkedList<PendingAction<Res>>(); - final TIntObjectHashMap<List<State>> computed = new TIntObjectHashMap<List<State>>(); - final TIntObjectHashMap<Res> results = new TIntObjectHashMap<Res>(); + final protected List<State>[] computed; final Key aKey; Res earlyResult = null; - abstract Res identity(); - abstract Res combineResults(Res delta, List<Res> subResults) throws AnalyzerException; - abstract boolean isEarlyResult(Res res); - abstract Equation<Key, Value> mkEquation(Res result); - abstract void processState(State state) throws AnalyzerException; - protected Analysis(RichControlFlow richControlFlow, Direction direction, boolean stable) { this.richControlFlow = richControlFlow; this.direction = direction; @@ -239,7 +228,7 @@ abstract class Analysis<Res> { method = new Method(controlFlow.className, methodNode.name, methodNode.desc); dfsTree = richControlFlow.dfsTree; aKey = new Key(method, direction, stable); - myIdentity = identity(); + computed = (List<State>[]) new List[controlFlow.transitions.length]; } final State createStartState() { @@ -269,87 +258,8 @@ abstract class Analysis<Res> { return true; } - final Equation<Key, Value> analyze() throws AnalyzerException { - pending.push(new ProceedState<Res>(createStartState())); - int steps = 0; - while (!pending.isEmpty() && earlyResult == null) { - steps ++; - if (steps >= STEPS_LIMIT) { - throw new AnalyzerException(null, "limit is reached, steps: " + steps + " in method " + method); - } - PendingAction<Res> action = pending.pop(); - if (action instanceof MakeResult) { - MakeResult<Res> makeResult = (MakeResult<Res>) action; - ArrayList<Res> subResults = new ArrayList<Res>(); - for (int index : makeResult.indices) { - subResults.add(results.get(index)); - } - Res result = combineResults(makeResult.subResult, subResults); - if (isEarlyResult(result)) { - earlyResult = result; - } else { - State state = makeResult.state; - int insnIndex = state.conf.insnIndex; - results.put(state.index, result); - List<State> thisComputed = computed.get(insnIndex); - if (thisComputed == null) { - thisComputed = new ArrayList<State>(); - computed.put(insnIndex, thisComputed); - } - thisComputed.add(state); - } - } - else if (action instanceof ProceedState) { - ProceedState<Res> proceedState = (ProceedState<Res>) action; - State state = proceedState.state; - int insnIndex = state.conf.insnIndex; - Conf conf = state.conf; - List<Conf> history = state.history; - - boolean fold = false; - if (dfsTree.loopEnters.contains(insnIndex)) { - for (Conf prev : history) { - if (AbstractValues.isInstance(conf, prev)) { - fold = true; - } - } - } - if (fold) { - results.put(state.index, myIdentity); - List<State> thisComputed = computed.get(insnIndex); - if (thisComputed == null) { - thisComputed = new ArrayList<State>(); - computed.put(insnIndex, thisComputed); - } - thisComputed.add(state); - } - else { - State baseState = null; - List<State> thisComputed = computed.get(insnIndex); - if (thisComputed != null) { - for (State prevState : thisComputed) { - if (stateEquiv(state, prevState)) { - baseState = prevState; - break; - } - } - } - if (baseState != null) { - results.put(state.index, results.get(baseState.index)); - } else { - // the main call - processState(state); - } - - } - } - } - if (earlyResult != null) { - return mkEquation(earlyResult); - } else { - return mkEquation(results.get(0)); - } - } + @NotNull + protected abstract Equation<Key, Value> analyze() throws AnalyzerException; final Frame<BasicValue> createStartFrame() { Frame<BasicValue> frame = new Frame<BasicValue>(methodNode.maxLocals, methodNode.maxStack); @@ -396,4 +306,13 @@ abstract class Analysis<Res> { result.add(x); return result; } + + protected void addComputed(int i, State s) { + List<State> states = computed[i]; + if (states == null) { + states = new ArrayList<State>(); + computed[i] = states; + } + states.add(s); + } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverter.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverter.java index 0239a661c4ee..84a5851e847d 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverter.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverter.java @@ -15,271 +15,208 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.components.ApplicationComponent; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.TypeConversionUtil; -import gnu.trove.TLongArrayList; -import gnu.trove.TLongHashSet; -import gnu.trove.TLongObjectHashMap; -import gnu.trove.TLongObjectIterator; import org.jetbrains.annotations.NotNull; -import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.annotations.Nullable; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Set; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.*; import static com.intellij.codeInspection.bytecodeAnalysis.ProjectBytecodeAnalysis.LOG; /** * @author lambdamix */ -public abstract class BytecodeAnalysisConverter implements ApplicationComponent { +public class BytecodeAnalysisConverter { - public static final int SHIFT = 4096; + // how many bytes are taken from class fqn digest + public static final int CLASS_HASH_SIZE = 10; + // how many bytes are taken from signature digest + public static final int SIGNATURE_HASH_SIZE = 4; + public static final int HASH_SIZE = CLASS_HASH_SIZE + SIGNATURE_HASH_SIZE; - public static BytecodeAnalysisConverter getInstance() { - return ApplicationManager.getApplication().getComponent(BytecodeAnalysisConverter.class); + public static MessageDigest getMessageDigest() throws NoSuchAlgorithmException { + return MessageDigest.getInstance("MD5"); } + /** + * Converts an equation over asm keys into equation over small hash keys. + */ @NotNull - @Override - public String getComponentName() { - return "BytecodeAnalysisConverter"; - } - - public abstract int getVersion(); - - protected abstract int enumerateString(@NotNull String s) throws IOException; - - protected abstract int enumerateCompoundKey(@NotNull int[] key) throws IOException; - - IdEquation convert(Equation<Key, Value> equation) throws IOException { + static DirectionResultPair convert(@NotNull Equation<Key, Value> equation, @NotNull MessageDigest md) { ProgressManager.checkCanceled(); Result<Key, Value> rhs = equation.rhs; - IdResult result; + HResult result; if (rhs instanceof Final) { - result = new IdFinal(((Final<Key, Value>)rhs).value); + result = new HFinal(((Final<Key, Value>)rhs).value); } else { Pending<Key, Value> pending = (Pending<Key, Value>)rhs; Set<Product<Key, Value>> sumOrigin = pending.sum; - IntIdComponent[] components = new IntIdComponent[sumOrigin.size()]; + HComponent[] components = new HComponent[sumOrigin.size()]; int componentI = 0; for (Product<Key, Value> prod : sumOrigin) { - long[] intProd = new long[prod.ids.size()]; + HKey[] intProd = new HKey[prod.ids.size()]; int idI = 0; for (Key id : prod.ids) { - long rawId = mkAsmKey(id); - if (rawId <= 0) { - LOG.error("raw key should be positive. rawId = " + rawId); - } - intProd[idI] = id.stable ? rawId : -rawId; + intProd[idI] = asmKey(id, md); idI++; } - IntIdComponent intIdComponent = new IntIdComponent(prod.value, intProd); + HComponent intIdComponent = new HComponent(prod.value, intProd); components[componentI] = intIdComponent; componentI++; } - result = new IdPending(components); + result = new HPending(components); } - - long rawKey = mkAsmKey(equation.id); - if (rawKey <= 0) { - LOG.error("raw key should be positive. rawKey = " + rawKey); - } - - long key = equation.id.stable ? rawKey : -rawKey; - return new IdEquation(key, result); + return new DirectionResultPair(mkDirectionKey(equation.id.direction), result); } - public long mkAsmKey(@NotNull Key key) throws IOException { - long baseKey = mkAsmSignatureKey(key.method); - long directionKey = mkDirectionKey(key.direction); - return baseKey * SHIFT + directionKey; + /** + * Converts an asm method key to a small hash key (HKey) + */ + @NotNull + public static HKey asmKey(@NotNull Key key, @NotNull MessageDigest md) { + byte[] classDigest = md.digest(key.method.internalClassName.getBytes()); + md.update(key.method.methodName.getBytes()); + md.update(key.method.methodDesc.getBytes()); + byte[] sigDigest = md.digest(); + byte[] digest = new byte[HASH_SIZE]; + System.arraycopy(classDigest, 0, digest, 0, CLASS_HASH_SIZE); + System.arraycopy(sigDigest, 0, digest, CLASS_HASH_SIZE, SIGNATURE_HASH_SIZE); + return new HKey(digest, mkDirectionKey(key.direction), key.stable); } - private static int mkDirectionKey(Direction dir) throws IOException { - if (dir instanceof Out) { - return 0; - } else if (dir instanceof In) { - In in = (In)dir; - return 8 * in.paramId() + 1; - } else { - InOut inOut = (InOut)dir; - return 8 * inOut.paramId() + 2 + inOut.valueId(); + /** + * Converts a Psi method to a small hash key (HKey). + * Returns null if conversion is impossible (something is not resolvable). + */ + @Nullable + public static HKey psiKey(@NotNull PsiMethod psiMethod, @NotNull Direction direction, @NotNull MessageDigest md) { + final PsiClass psiClass = PsiTreeUtil.getParentOfType(psiMethod, PsiClass.class, false); + if (psiClass == null) { + return null; } - } - - @NotNull - private static Direction extractDirection(int directionKey) { - if (directionKey == 0) { - return new Out(); + byte[] classDigest = psiClassDigest(psiClass, md); + if (classDigest == null) { + return null; } - else { - int paramId = directionKey / 8; - int subDirection = directionKey % 8; - if (subDirection == 1) { - return new In(paramId); - } - else { - return new InOut(paramId, Value.values()[subDirection - 2]); - } + byte[] sigDigest = methodDigest(psiMethod, md); + if (sigDigest == null) { + return null; } + byte[] digest = new byte[HASH_SIZE]; + System.arraycopy(classDigest, 0, digest, 0, CLASS_HASH_SIZE); + System.arraycopy(sigDigest, 0, digest, CLASS_HASH_SIZE, SIGNATURE_HASH_SIZE); + return new HKey(digest, mkDirectionKey(direction), true); } - // class + short signature - private int mkAsmSignatureKey(@NotNull Method method) throws IOException { - int[] sigKey = new int[2]; - sigKey[0] = mkAsmTypeKey(Type.getObjectType(method.internalClassName)); - sigKey[1] = mkAsmShortSignatureKey(method); - return enumerateCompoundKey(sigKey); - } - - private int mkAsmShortSignatureKey(@NotNull Method method) throws IOException { - Type[] argTypes = Type.getArgumentTypes(method.methodDesc); - int arity = argTypes.length; - int[] sigKey = new int[2 + arity]; - sigKey[0] = mkAsmTypeKey(Type.getReturnType(method.methodDesc)); - sigKey[1] = enumerateString(method.methodName); - for (int i = 0; i < argTypes.length; i++) { - sigKey[2 + i] = mkAsmTypeKey(argTypes[i]); + @Nullable + private static byte[] psiClassDigest(@NotNull PsiClass psiClass, @NotNull MessageDigest md) { + String descriptor = descriptor(psiClass, 0, false); + if (descriptor == null) { + return null; } - return enumerateCompoundKey(sigKey); + return md.digest(descriptor.getBytes()); } - private int mkAsmTypeKey(Type type) throws IOException { - String className = type.getClassName(); - int dotIndex = className.lastIndexOf('.'); - String packageName; - String simpleName; - if (dotIndex > 0) { - packageName = className.substring(0, dotIndex); - simpleName = className.substring(dotIndex + 1); - } else { - packageName = ""; - simpleName = className; + @Nullable + private static byte[] methodDigest(@NotNull PsiMethod psiMethod, @NotNull MessageDigest md) { + String descriptor = descriptor(psiMethod); + if (descriptor == null) { + return null; } - int[] classKey = new int[]{enumerateString(packageName), enumerateString(simpleName)}; - return enumerateCompoundKey(classKey); + return md.digest(descriptor.getBytes()); } - public long mkPsiKey(@NotNull PsiMethod psiMethod, Direction direction) throws IOException { - final PsiClass psiClass = PsiTreeUtil.getParentOfType(psiMethod, PsiClass.class, false); - if (psiClass == null) { - LOG.debug("PsiClass was null for " + psiMethod.getName()); - return -1; - } - long sigKey = mkPsiSignatureKey(psiMethod); - if (sigKey == -1) { - return -1; - } - long directionKey = mkDirectionKey(direction); - return sigKey * SHIFT + directionKey; - } - - private int mkPsiSignatureKey(@NotNull PsiMethod psiMethod) throws IOException { + @Nullable + private static String descriptor(@NotNull PsiMethod psiMethod) { + StringBuilder sb = new StringBuilder(); final PsiClass psiClass = PsiTreeUtil.getParentOfType(psiMethod, PsiClass.class, false); if (psiClass == null) { - LOG.debug("PsiClass was null for " + psiMethod.getName()); - return -1; + return null; } PsiClass outerClass = psiClass.getContainingClass(); boolean isInnerClassConstructor = psiMethod.isConstructor() && (outerClass != null) && !psiClass.hasModifierProperty(PsiModifier.STATIC); PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); PsiType returnType = psiMethod.getReturnType(); - final int shift = isInnerClassConstructor ? 1 : 0; - final int arity = parameters.length + shift; - int[] shortSigKey = new int[2 + arity]; - if (returnType == null) { - shortSigKey[0] = mkPsiTypeKey(PsiType.VOID); - shortSigKey[1] = enumerateString("<init>"); - } else { - shortSigKey[0] = mkPsiTypeKey(returnType); - shortSigKey[1] = enumerateString(psiMethod.getName()); - } + sb.append(returnType == null ? "<init>" : psiMethod.getName()); + sb.append('('); + + String desc; + if (isInnerClassConstructor) { - shortSigKey[2] = mkPsiClassKey(outerClass, 0); - } - for (int i = 0; i < parameters.length; i++) { - PsiParameter parameter = parameters[i]; - shortSigKey[2 + i + shift] = mkPsiTypeKey(parameter.getType()); - } - for (int aShortSigKey : shortSigKey) { - if (aShortSigKey == -1) { - return -1; + desc = descriptor(outerClass, 0, true); + if (desc == null) { + return null; } + sb.append(desc); } - - int[] sigKey = new int[2]; - int classKey = mkPsiClassKey(psiClass, 0); - if (classKey == -1) { - return -1; + for (PsiParameter parameter : parameters) { + desc = descriptor(parameter.getType()); + if (desc == null) { + return null; + } + sb.append(desc); } - sigKey[0] = classKey; - sigKey[1] = enumerateCompoundKey(shortSigKey); - - return enumerateCompoundKey(sigKey); - } - - public TLongArrayList mkInOutKeys(@NotNull PsiMethod psiMethod, long primaryKey) throws IOException { - PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); - TLongArrayList keys = new TLongArrayList(parameters.length * 2 + 1); - for (int i = 0; i < parameters.length; i++) { - PsiParameter parameter = parameters[i]; - PsiType parameterType = parameter.getType(); - if (parameterType instanceof PsiPrimitiveType) { - if (PsiType.BOOLEAN.equals(parameterType)) { - keys.add(primaryKey + mkDirectionKey(new InOut(i, Value.False))); - keys.add(primaryKey + mkDirectionKey(new InOut(i, Value.True))); - } + sb.append(')'); + if (returnType == null) { + sb.append('V'); + } else { + desc = descriptor(returnType); + if (desc == null) { + return null; } else { - keys.add(primaryKey + mkDirectionKey(new InOut(i, Value.NotNull))); - keys.add(primaryKey + mkDirectionKey(new InOut(i, Value.Null))); + sb.append(desc); } } - return keys; + return sb.toString(); } - - private int mkPsiClassKey(PsiClass psiClass, int dimensions) throws IOException { + @Nullable + private static String descriptor(@NotNull PsiClass psiClass, int dimensions, boolean full) { PsiFile containingFile = psiClass.getContainingFile(); if (!(containingFile instanceof PsiClassOwner)) { LOG.debug("containingFile was not resolved for " + psiClass.getQualifiedName()); - return -1; + return null; } PsiClassOwner psiFile = (PsiClassOwner)containingFile; String packageName = psiFile.getPackageName(); String qname = psiClass.getQualifiedName(); if (qname == null) { - return -1; + return null; } - String className = qname; + String className; if (packageName.length() > 0) { className = qname.substring(packageName.length() + 1).replace('.', '$'); - } - int[] classKey = new int[2]; - classKey[0] = enumerateString(packageName); - if (dimensions == 0) { - classKey[1] = enumerateString(className); } else { - StringBuilder sb = new StringBuilder(className); - for (int j = 0; j < dimensions; j++) { - sb.append("[]"); - } - classKey[1] = enumerateString(sb.toString()); + className = qname.replace('.', '$'); + } + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < dimensions; i++) { + sb.append('['); + } + if (full) { + sb.append('L'); } - return enumerateCompoundKey(classKey); + if (packageName.length() > 0) { + sb.append(packageName.replace('.', '/')); + sb.append('/'); + } + sb.append(className); + if (full) { + sb.append(';'); + } + return sb.toString(); } - private int mkPsiTypeKey(PsiType psiType) throws IOException { + @Nullable + private static String descriptor(@NotNull PsiType psiType) { int dimensions = 0; psiType = TypeConversionUtil.erasure(psiType); if (psiType instanceof PsiArrayType) { @@ -289,56 +226,130 @@ public abstract class BytecodeAnalysisConverter implements ApplicationComponent } if (psiType instanceof PsiClassType) { - // no resolve() -> no package/class split PsiClass psiClass = ((PsiClassType)psiType).resolve(); if (psiClass != null) { - return mkPsiClassKey(psiClass, dimensions); + return descriptor(psiClass, dimensions, true); } else { LOG.debug("resolve was null for " + ((PsiClassType)psiType).getClassName()); - return -1; + return null; } } else if (psiType instanceof PsiPrimitiveType) { - String packageName = ""; - String className = psiType.getPresentableText(); - int[] classKey = new int[2]; - classKey[0] = enumerateString(packageName); - if (dimensions == 0) { - classKey[1] = enumerateString(className); - } else { - StringBuilder sb = new StringBuilder(className); - for (int j = 0; j < dimensions; j++) { - sb.append("[]"); - } - classKey[1] = enumerateString(sb.toString()); + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < dimensions; i++) { + sb.append('['); + } + if (PsiType.VOID.equals(psiType)) { + sb.append('V'); + } + else if (PsiType.BOOLEAN.equals(psiType)) { + sb.append('Z'); + } + else if (PsiType.CHAR.equals(psiType)) { + sb.append('C'); + } + else if (PsiType.BYTE.equals(psiType)) { + sb.append('B'); + } + else if (PsiType.SHORT.equals(psiType)) { + sb.append('S'); + } + else if (PsiType.INT.equals(psiType)) { + sb.append('I'); } - return enumerateCompoundKey(classKey); + else if (PsiType.FLOAT.equals(psiType)) { + sb.append('F'); + } + else if (PsiType.LONG.equals(psiType)) { + sb.append('J'); + } + else if (PsiType.DOUBLE.equals(psiType)) { + sb.append('D'); + } + return sb.toString(); } - return -1; + return null; } - public void addMethodAnnotations(TLongObjectHashMap<Value> internalIdSolutions, Annotations annotations, long methodKey, int arity) { + private static int mkDirectionKey(Direction dir) { + if (dir instanceof Out) { + return 0; + } else if (dir instanceof In) { + In in = (In)dir; + // nullity mask is 0/1 + return 8 * in.paramId() + 1 + in.nullityMask; + } else { + InOut inOut = (InOut)dir; + return 8 * inOut.paramId() + 3 + inOut.valueId(); + } + } - List<String> clauses = new ArrayList<String>(); - TLongObjectIterator<Value> solutionsIterator = internalIdSolutions.iterator(); + @NotNull + private static Direction extractDirection(int directionKey) { + if (directionKey == 0) { + return new Out(); + } + else { + int paramId = directionKey / 8; + int subDirection = directionKey % 8; + if (subDirection <= 2) { + return new In(paramId, subDirection - 1); + } + else { + return new InOut(paramId, Value.values()[subDirection - 3]); + } + } + } + + /** + * Given a PSI method and its primary HKey enumerate all contract keys for it. + */ + @NotNull + public static ArrayList<HKey> mkInOutKeys(@NotNull PsiMethod psiMethod, @NotNull HKey primaryKey) { + PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); + ArrayList<HKey> keys = new ArrayList<HKey>(parameters.length * 2 + 1); + for (int i = 0; i < parameters.length; i++) { + PsiParameter parameter = parameters[i]; + PsiType parameterType = parameter.getType(); + if (parameterType instanceof PsiPrimitiveType) { + if (PsiType.BOOLEAN.equals(parameterType)) { + keys.add(primaryKey.updateDirection(mkDirectionKey(new InOut(i, Value.False)))); + keys.add(primaryKey.updateDirection(mkDirectionKey(new InOut(i, Value.True)))); + } + } else { + keys.add(primaryKey.updateDirection(mkDirectionKey(new InOut(i, Value.NotNull)))); + keys.add(primaryKey.updateDirection(mkDirectionKey(new InOut(i, Value.Null)))); + } + } + return keys; + } - TLongHashSet notNulls = annotations.notNulls; - TLongObjectHashMap<String> contracts = annotations.contracts; - for (int i = internalIdSolutions.size(); i-- > 0;) { - solutionsIterator.advance(); - long key = Math.abs(solutionsIterator.key()); - Value value = solutionsIterator.value(); + /** + * Given `solution` of all dependencies of a method with the `methodKey`, converts this solution into annotations. + * + * @param solution solution of equations + * @param methodAnnotations annotations to which corresponding solutions should be added + * @param methodKey a primary key of a method being analyzed + * @param arity arity of this method (hint for constructing @Contract annotations) + */ + public static void addMethodAnnotations(@NotNull HashMap<HKey, Value> solution, @NotNull MethodAnnotations methodAnnotations, @NotNull HKey methodKey, int arity) { + List<String> clauses = new ArrayList<String>(); + HashSet<HKey> notNulls = methodAnnotations.notNulls; + HashMap<HKey, String> contracts = methodAnnotations.contracts; + for (Map.Entry<HKey, Value> entry : solution.entrySet()) { + HKey key = entry.getKey().mkStable(); + Value value = entry.getValue(); if (value == Value.Top || value == Value.Bot) { continue; } - Direction direction = extractDirection((int)(key % SHIFT)); - if (value == Value.NotNull && direction instanceof Out && key == methodKey) { + Direction direction = extractDirection(key.dirKey); + if (value == Value.NotNull && direction instanceof Out && methodKey.equals(key)) { notNulls.add(key); } else if (direction instanceof InOut) { - long baseKey = key - (key % SHIFT); - if (baseKey == methodKey) { + HKey baseKey = key.mkBase(); + if (methodKey.equals(baseKey)) { clauses.add(contractElement(arity, (InOut)direction, value)); } } @@ -353,24 +364,7 @@ public abstract class BytecodeAnalysisConverter implements ApplicationComponent } } - public void addParameterAnnotations(TLongObjectHashMap<Value> internalIdSolutions, Annotations annotations) { - TLongObjectIterator<Value> solutionsIterator = internalIdSolutions.iterator(); - TLongHashSet notNulls = annotations.notNulls; - for (int i = internalIdSolutions.size(); i-- > 0;) { - solutionsIterator.advance(); - long key = Math.abs(solutionsIterator.key()); - Value value = solutionsIterator.value(); - if (value == Value.Top || value == Value.Bot) { - continue; - } - Direction direction = extractDirection((int)(key % SHIFT)); - if (value == Value.NotNull && (direction instanceof In || direction instanceof Out)) { - notNulls.add(key); - } - } - } - - static String contractValueString(Value v) { + private static String contractValueString(@NotNull Value v) { switch (v) { case False: return "false"; case True: return "true"; @@ -380,7 +374,7 @@ public abstract class BytecodeAnalysisConverter implements ApplicationComponent } } - static String contractElement(int arity, InOut inOut, Value value) { + private static String contractElement(int arity, InOut inOut, Value value) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < arity; i++) { Value currentValue = Value.Top; diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverterImpl.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverterImpl.java deleted file mode 100644 index 067cc743679e..000000000000 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisConverterImpl.java +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Copyright 2000-2014 JetBrains s.r.o. - * - * 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.intellij.codeInspection.bytecodeAnalysis; - -import com.intellij.ide.util.PropertiesComponent; -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.application.PathManager; -import com.intellij.openapi.util.ThrowableComputable; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.util.io.*; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.io.*; -import java.io.DataOutputStream; -import java.util.Arrays; - -import static com.intellij.codeInspection.bytecodeAnalysis.ProjectBytecodeAnalysis.LOG; - -/** - * @author lambdamix - */ -public class BytecodeAnalysisConverterImpl extends BytecodeAnalysisConverter { - private static final int LOGIC_VERSION = 1; - private static final String ENUMERATORS_VERSION_KEY = "BytecodeAnalysisConverter.Enumerators"; - - private File myVersionFile; - private PersistentStringEnumerator myNamesEnumerator; - private PersistentEnumeratorDelegate<int[]> myCompoundKeyEnumerator; - private int version; - - @Override - public void initComponent() { - - // suffix as an indicator of version - final File keysDir = new File(PathManager.getIndexRoot(), "bytecodekeys"); - final File namesFile = new File(keysDir, "names" + LOGIC_VERSION); - final File compoundKeysFile = new File(keysDir, "compound" + LOGIC_VERSION); - myVersionFile = new File(keysDir, "version" + LOGIC_VERSION); - - version = PropertiesComponent.getInstance().getOrInitInt(ENUMERATORS_VERSION_KEY, 0); - if (ApplicationManager.getApplication().isUnitTestMode()) { - version = _readVersion(); - } - - if (!namesFile.exists() || !compoundKeysFile.exists() || !myVersionFile.exists()) { - LOG.info("No enumerators detected, re-initialization of enumerators."); - IOUtil.deleteAllFilesStartingWith(keysDir); - version++; - } - - try { - IOUtil.openCleanOrResetBroken(new ThrowableComputable<Void, IOException>() { - @Override - public Void compute() throws IOException { - myNamesEnumerator = new PersistentStringEnumerator(namesFile, true); - myCompoundKeyEnumerator = new IntArrayPersistentEnumerator(compoundKeysFile, new IntArrayKeyDescriptor()); - return null; - } - }, new Runnable() { - @Override - public void run() { - LOG.info("Error during initialization of enumerators in bytecode analysis. Re-initializing."); - IOUtil.deleteAllFilesStartingWith(keysDir); - version++; - } - }); - } - catch (IOException e) { - LOG.error("Re-initialization of enumerators in bytecode analysis failed.", e); - } - PropertiesComponent.getInstance().setValue(ENUMERATORS_VERSION_KEY, String.valueOf(version)); - _saveVersion(); - } - - @Override - public void disposeComponent() { - try { - myNamesEnumerator.close(); - myCompoundKeyEnumerator.close(); - } - catch (IOException e) { - LOG.debug(e); - } - } - - public int _readVersion() { - try { - final DataInputStream is = new DataInputStream(new FileInputStream(myVersionFile)); - try { - return is.readInt(); - } - finally { - is.close(); - } - } - catch (FileNotFoundException ignored) { - } - catch (IOException ignored) { - } - return 0; - } - - private void _saveVersion() { - try { - FileUtil.createIfDoesntExist(myVersionFile); - final DataOutputStream os = new DataOutputStream(new FileOutputStream(myVersionFile)); - try { - os.writeInt(version); - } - finally { - os.close(); - } - } - catch (IOException ignored) { - } - } - - public int getVersion() { - return version; - } - - @Override - protected int enumerateString(@NotNull String s) throws IOException { - return myNamesEnumerator.enumerate(s); - } - - @Override - protected int enumerateCompoundKey(@NotNull int[] key) throws IOException { - return myCompoundKeyEnumerator.enumerate(key); - } - - private static class IntArrayKeyDescriptor implements KeyDescriptor<int[]>, DifferentSerializableBytesImplyNonEqualityPolicy { - - @Override - public void save(@NotNull DataOutput out, int[] value) throws IOException { - DataInputOutputUtil.writeINT(out, value.length); - for (int i : value) { - DataInputOutputUtil.writeINT(out, i); - } - } - - @Override - public int[] read(@NotNull DataInput in) throws IOException { - int[] value = new int[DataInputOutputUtil.readINT(in)]; - for (int i = 0; i < value.length; i++) { - value[i] = DataInputOutputUtil.readINT(in); - } - return value; - } - - @Override - public int getHashCode(int[] value) { - return Arrays.hashCode(value); - } - - @Override - public boolean isEqual(int[] val1, int[] val2) { - return Arrays.equals(val1, val2); - } - } - - private static class IntArrayPersistentEnumerator extends PersistentEnumeratorDelegate<int[]> { - private final CachingEnumerator<int[]> myCache; - - public IntArrayPersistentEnumerator(File compoundKeysFile, IntArrayKeyDescriptor descriptor) throws IOException { - super(compoundKeysFile, descriptor, 1024 * 4); - myCache = new CachingEnumerator<int[]>(new DataEnumerator<int[]>() { - @Override - public int enumerate(@Nullable int[] value) throws IOException { - return IntArrayPersistentEnumerator.super.enumerate(value); - } - - @Nullable - @Override - public int[] valueOf(int idx) throws IOException { - return IntArrayPersistentEnumerator.super.valueOf(idx); - } - }, descriptor); - } - - @Override - public int enumerate(@Nullable int[] value) throws IOException { - return myCache.enumerate(value); - } - - @Nullable - @Override - public int[] valueOf(int idx) throws IOException { - return myCache.valueOf(idx); - } - } -} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIndex.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIndex.java index 297b2b694c62..a7070b882431 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIndex.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIndex.java @@ -16,8 +16,6 @@ package com.intellij.codeInspection.bytecodeAnalysis; import com.intellij.ide.highlighter.JavaClassFileType; -import com.intellij.openapi.application.Application; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.util.SystemProperties; import com.intellij.util.indexing.*; @@ -30,46 +28,42 @@ import org.jetbrains.annotations.NotNull; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; /** * @author lambdamix */ -public class BytecodeAnalysisIndex extends FileBasedIndexExtension<Long, IdEquation> { - public static final ID<Long, IdEquation> NAME = ID.create("bytecodeAnalysis"); - private final EquationExternalizer myExternalizer = new EquationExternalizer(); - private static final DataIndexer<Long, IdEquation, FileContent> INDEXER = - new ClassDataIndexer(BytecodeAnalysisConverter.getInstance()); - private static final SmartLongKeyDescriptor KEY_DESCRIPTOR = new SmartLongKeyDescriptor(); - - private static final int ourInternalVersion = 3; - private static boolean ourEnabled = SystemProperties.getBooleanProperty("idea.enable.bytecode.contract.inference", isEnabledByDefault()); - - private static boolean isEnabledByDefault() { - Application application = ApplicationManager.getApplication(); - return application.isInternal() || application.isUnitTestMode(); - } +public class BytecodeAnalysisIndex extends FileBasedIndexExtension<Bytes, HEquations> { + public static final ID<Bytes, HEquations> NAME = ID.create("bytecodeAnalysis"); + private final HEquationsExternalizer myExternalizer = new HEquationsExternalizer(); + private static final ClassDataIndexer INDEXER = new ClassDataIndexer(); + private static final HKeyDescriptor KEY_DESCRIPTOR = new HKeyDescriptor(); + + private static final int ourInternalVersion = 1; + private static boolean ourEnabled = SystemProperties.getBooleanProperty("idea.enable.bytecode.contract.inference", true); @NotNull @Override - public ID<Long, IdEquation> getName() { + public ID<Bytes, HEquations> getName() { return NAME; } @NotNull @Override - public DataIndexer<Long, IdEquation, FileContent> getIndexer() { + public DataIndexer<Bytes, HEquations, FileContent> getIndexer() { return INDEXER; } @NotNull @Override - public KeyDescriptor<Long> getKeyDescriptor() { + public KeyDescriptor<Bytes> getKeyDescriptor() { return KEY_DESCRIPTOR; } @NotNull @Override - public DataExternalizer<IdEquation> getValueExternalizer() { + public DataExternalizer<HEquations> getValueExternalizer() { return myExternalizer; } @@ -91,111 +85,103 @@ public class BytecodeAnalysisIndex extends FileBasedIndexExtension<Long, IdEquat @Override public int getVersion() { - return ourInternalVersion + BytecodeAnalysisConverter.getInstance().getVersion() + (ourEnabled ? 0xFF : 0); + return ourInternalVersion + (ourEnabled ? 0xFF : 0); } - public static class EquationExternalizer implements DataExternalizer<IdEquation>, DifferentSerializableBytesImplyNonEqualityPolicy { + private static class HKeyDescriptor implements KeyDescriptor<Bytes>, DifferentSerializableBytesImplyNonEqualityPolicy { + @Override - public void save(@NotNull DataOutput out, IdEquation equation) throws IOException { - long id = equation.id; - int sign = id > 0 ? 1 : -1; - id = Math.abs(id); - int primaryId = (int)(id / BytecodeAnalysisConverter.SHIFT); - int secondaryId = (int)(id % BytecodeAnalysisConverter.SHIFT); - out.writeInt(sign * primaryId); - DataInputOutputUtil.writeINT(out, secondaryId); - IdResult rhs = equation.rhs; - if (rhs instanceof IdFinal) { - IdFinal finalResult = (IdFinal)rhs; - out.writeBoolean(true); // final flag - DataInputOutputUtil.writeINT(out, finalResult.value.ordinal()); - } else { - IdPending pendResult = (IdPending)rhs; - out.writeBoolean(false); // pending flag - DataInputOutputUtil.writeINT(out, pendResult.delta.length); - - for (IntIdComponent component : pendResult.delta) { - DataInputOutputUtil.writeINT(out, component.value.ordinal()); - long[] ids = component.ids; - DataInputOutputUtil.writeINT(out, ids.length); - for (long id1 : ids) { - sign = id1 > 0 ? 1 : -1; - id = Math.abs(id1); - primaryId = (int)(id / BytecodeAnalysisConverter.SHIFT); - secondaryId = (int)(id % BytecodeAnalysisConverter.SHIFT); - out.writeInt(sign * primaryId); - DataInputOutputUtil.writeINT(out, secondaryId); - } - } - } + public void save(@NotNull DataOutput out, Bytes value) throws IOException { + out.write(value.bytes); } @Override - public IdEquation read(@NotNull DataInput in) throws IOException { - long primaryId = in.readInt(); - int sign = primaryId > 0 ? 1 : -1; - primaryId = Math.abs(primaryId); - int secondaryId = DataInputOutputUtil.readINT(in); - long equationId = sign * (primaryId * BytecodeAnalysisConverter.SHIFT + secondaryId); - boolean isFinal = in.readBoolean(); // flag - if (isFinal) { - int ordinal = DataInputOutputUtil.readINT(in); - Value value = Value.values()[ordinal]; - return new IdEquation(equationId, new IdFinal(value)); - } else { - - int sumLength = DataInputOutputUtil.readINT(in); - IntIdComponent[] components = new IntIdComponent[sumLength]; - - for (int i = 0; i < sumLength; i++) { - int ordinal = DataInputOutputUtil.readINT(in); - Value value = Value.values()[ordinal]; - int componentSize = DataInputOutputUtil.readINT(in); - long[] ids = new long[componentSize]; - for (int j = 0; j < componentSize; j++) { - primaryId = in.readInt(); - sign = primaryId > 0 ? 1 : -1; - primaryId = Math.abs(primaryId); - secondaryId = DataInputOutputUtil.readINT(in); - long id = sign * (primaryId * BytecodeAnalysisConverter.SHIFT + secondaryId); - ids[j] = id; - } - components[i] = new IntIdComponent(value, ids); - } - return new IdEquation(equationId, new IdPending(components)); + public Bytes read(@NotNull DataInput in) throws IOException { + byte[] bytes = new byte[BytecodeAnalysisConverter.HASH_SIZE]; + for (int i = 0; i < bytes.length; i++) { + bytes[i] = in.readByte(); } + return new Bytes(bytes); } - } - private static class SmartLongKeyDescriptor implements KeyDescriptor<Long>, DifferentSerializableBytesImplyNonEqualityPolicy { @Override - public void save(@NotNull DataOutput out, Long value) throws IOException { - long id = value.longValue(); - int sign = id > 0 ? 1 : -1; - id = Math.abs(id); - int primaryId = (int)(id / BytecodeAnalysisConverter.SHIFT); - int secondaryId = (int)(id % BytecodeAnalysisConverter.SHIFT); - out.writeInt(primaryId * sign); - DataInputOutputUtil.writeINT(out, secondaryId); + public int getHashCode(Bytes value) { + return Arrays.hashCode(value.bytes); } @Override - public Long read(@NotNull DataInput in) throws IOException { - long primaryId = in.readInt(); - int sign = primaryId > 0 ? 1 : -1; - primaryId = Math.abs(primaryId); - int secondaryId = DataInputOutputUtil.readINT(in); - return sign * (primaryId * BytecodeAnalysisConverter.SHIFT + secondaryId); + public boolean isEqual(Bytes val1, Bytes val2) { + return Arrays.equals(val1.bytes, val2.bytes); } + } + public static class HEquationsExternalizer implements DataExternalizer<HEquations>, DifferentSerializableBytesImplyNonEqualityPolicy { @Override - public int getHashCode(Long value) { - return value.hashCode(); + public void save(@NotNull DataOutput out, HEquations eqs) throws IOException { + out.writeBoolean(eqs.stable); + DataInputOutputUtil.writeINT(out, eqs.results.size()); + for (DirectionResultPair pair : eqs.results) { + DataInputOutputUtil.writeINT(out, pair.directionKey); + HResult rhs = pair.hResult; + if (rhs instanceof HFinal) { + HFinal finalResult = (HFinal)rhs; + out.writeBoolean(true); // final flag + DataInputOutputUtil.writeINT(out, finalResult.value.ordinal()); + } + else { + HPending pendResult = (HPending)rhs; + out.writeBoolean(false); // pending flag + DataInputOutputUtil.writeINT(out, pendResult.delta.length); + + for (HComponent component : pendResult.delta) { + DataInputOutputUtil.writeINT(out, component.value.ordinal()); + HKey[] ids = component.ids; + DataInputOutputUtil.writeINT(out, ids.length); + for (HKey hKey : ids) { + out.write(hKey.key); + DataInputOutputUtil.writeINT(out, hKey.dirKey); + out.writeBoolean(hKey.stable); + } + } + } + } } @Override - public boolean isEqual(Long val1, Long val2) { - return val1.longValue() == val2.longValue(); + public HEquations read(@NotNull DataInput in) throws IOException { + boolean stable = in.readBoolean(); + int size = DataInputOutputUtil.readINT(in); + ArrayList<DirectionResultPair> results = new ArrayList<DirectionResultPair>(size); + for (int k = 0; k < size; k++) { + int directionKey = DataInputOutputUtil.readINT(in); + boolean isFinal = in.readBoolean(); // flag + if (isFinal) { + int ordinal = DataInputOutputUtil.readINT(in); + Value value = Value.values()[ordinal]; + results.add(new DirectionResultPair(directionKey, new HFinal(value))); + } + else { + int sumLength = DataInputOutputUtil.readINT(in); + HComponent[] components = new HComponent[sumLength]; + + for (int i = 0; i < sumLength; i++) { + int ordinal = DataInputOutputUtil.readINT(in); + Value value = Value.values()[ordinal]; + int componentSize = DataInputOutputUtil.readINT(in); + HKey[] ids = new HKey[componentSize]; + for (int j = 0; j < componentSize; j++) { + byte[] bytes = new byte[BytecodeAnalysisConverter.HASH_SIZE]; + for (int bi = 0; bi < bytes.length; bi++) { + bytes[bi] = in.readByte(); + } + ids[j] = new HKey(bytes, DataInputOutputUtil.readINT(in), in.readBoolean()); + } + components[i] = new HComponent(value, ids); + } + results.add(new DirectionResultPair(directionKey, new HPending(components))); + } + } + return new HEquations(results, stable); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ClassDataIndexer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ClassDataIndexer.java index 9e656b98a7fb..316307896467 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ClassDataIndexer.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ClassDataIndexer.java @@ -15,17 +15,20 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; +import com.intellij.codeInspection.bytecodeAnalysis.asm.*; import com.intellij.openapi.progress.ProcessCanceledException; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.util.NotNullLazyValue; +import com.intellij.openapi.util.NullableLazyValue; +import com.intellij.openapi.util.Pair; import com.intellij.util.indexing.DataIndexer; import com.intellij.util.indexing.FileContent; -import gnu.trove.TIntHashSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.org.objectweb.asm.*; import org.jetbrains.org.objectweb.asm.tree.MethodNode; import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; +import java.security.MessageDigest; import java.util.*; import static com.intellij.codeInspection.bytecodeAnalysis.ProjectBytecodeAnalysis.LOG; @@ -33,29 +36,32 @@ import static com.intellij.codeInspection.bytecodeAnalysis.ProjectBytecodeAnalys /** * @author lambdamix */ -public class ClassDataIndexer implements DataIndexer<Long, IdEquation, FileContent> { - final BytecodeAnalysisConverter myConverter; +public class ClassDataIndexer implements DataIndexer<Bytes, HEquations, FileContent> { - public ClassDataIndexer(BytecodeAnalysisConverter converter) { - myConverter = converter; - } + private static final int STABLE_FLAGS = Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC; + public static final Final<Key, Value> FINAL_TOP = new Final<Key, Value>(Value.Top); + public static final Final<Key, Value> FINAL_BOT = new Final<Key, Value>(Value.Bot); + public static final Final<Key, Value> FINAL_NOT_NULL = new Final<Key, Value>(Value.NotNull); + public static final Final<Key, Value> FINAL_NULL = new Final<Key, Value>(Value.Null); + private static final List<Equation<Key, Value>> EMPTY_EQUATIONS = Collections.EMPTY_LIST; @NotNull @Override - public Map<Long, IdEquation> map(@NotNull FileContent inputData) { - HashMap<Long, IdEquation> map = new HashMap<Long, IdEquation>(); + public Map<Bytes, HEquations> map(@NotNull FileContent inputData) { + HashMap<Bytes, HEquations> map = new HashMap<Bytes, HEquations>(); try { - ClassEquations rawEquations = processClass(new ClassReader(inputData.getContent())); - List<Equation<Key, Value>> rawParameterEquations = rawEquations.parameterEquations; - List<Equation<Key, Value>> rawContractEquations = rawEquations.contractEquations; + MessageDigest md = BytecodeAnalysisConverter.getMessageDigest(); + Map<Key, List<Equation<Key, Value>>> rawEquations = processClass(new ClassReader(inputData.getContent()), inputData.getFile().getPresentableUrl()); + for (Map.Entry<Key, List<Equation<Key, Value>>> entry: rawEquations.entrySet()) { + Key primaryKey = entry.getKey(); + Key serKey = new Key(primaryKey.method, primaryKey.direction, true); - for (Equation<Key, Value> rawParameterEquation: rawParameterEquations) { - IdEquation equation = myConverter.convert(rawParameterEquation); - map.put(equation.id, equation); - } - for (Equation<Key, Value> rawContractEquation: rawContractEquations) { - IdEquation equation = myConverter.convert(rawContractEquation); - map.put(equation.id, equation); + List<Equation<Key, Value>> equations = entry.getValue(); + List<DirectionResultPair> result = new ArrayList<DirectionResultPair>(equations.size()); + for (Equation<Key, Value> equation : equations) { + result.add(BytecodeAnalysisConverter.convert(equation, md)); + } + map.put(new Bytes(BytecodeAnalysisConverter.asmKey(serKey, md).key), new HEquations(result, primaryKey.stable)); } } catch (ProcessCanceledException e) { @@ -66,28 +72,21 @@ public class ClassDataIndexer implements DataIndexer<Long, IdEquation, FileConte // so here we suppose that exception is due to incorrect bytecode LOG.debug("Unexpected Error during indexing of bytecode", e); } + //return map; return map; } - private static class ClassEquations { - final List<Equation<Key, Value>> parameterEquations; - final List<Equation<Key, Value>> contractEquations; - - private ClassEquations(List<Equation<Key, Value>> parameterEquations, List<Equation<Key, Value>> contractEquations) { - this.parameterEquations = parameterEquations; - this.contractEquations = contractEquations; - } - } + public static Map<Key, List<Equation<Key, Value>>> processClass(final ClassReader classReader, final String presentableUrl) { - public static ClassEquations processClass(final ClassReader classReader) { - final List<Equation<Key, Value>> parameterEquations = new ArrayList<Equation<Key, Value>>(); - final List<Equation<Key, Value>> contractEquations = new ArrayList<Equation<Key, Value>>(); + final Map<Key, List<Equation<Key, Value>>> equations = new HashMap<Key, List<Equation<Key, Value>>>(); classReader.accept(new ClassVisitor(Opcodes.ASM5) { + private String className; private boolean stableClass; @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { + className = name; stableClass = (access & Opcodes.ACC_FINAL) != 0; super.visit(version, access, name, signature, superName, interfaces); } @@ -96,164 +95,286 @@ public class ClassDataIndexer implements DataIndexer<Long, IdEquation, FileConte public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { final MethodNode node = new MethodNode(Opcodes.ASM5, access, name, desc, signature, exceptions); return new MethodVisitor(Opcodes.ASM5, node) { + private boolean jsr; + + @Override + public void visitJumpInsn(int opcode, Label label) { + if (opcode == Opcodes.JSR) { + jsr = true; + } + super.visitJumpInsn(opcode, label); + } + @Override public void visitEnd() { super.visitEnd(); - processMethod(classReader.getClassName(), node, stableClass); + Pair<Key, List<Equation<Key, Value>>> methodEquations = processMethod(node, jsr); + equations.put(methodEquations.first, methodEquations.second); } }; } - void processMethod(final String className, final MethodNode methodNode, boolean stableClass) { + private Pair<Key, List<Equation<Key, Value>>> processMethod(final MethodNode methodNode, boolean jsr) { ProgressManager.checkCanceled(); - Type[] argumentTypes = Type.getArgumentTypes(methodNode.desc); - Type resultType = Type.getReturnType(methodNode.desc); - int resultSort = resultType.getSort(); - boolean isReferenceResult = resultSort == Type.OBJECT || resultSort == Type.ARRAY; - boolean isBooleanResult = Type.BOOLEAN_TYPE == resultType; - boolean isInterestingResult = isReferenceResult || isBooleanResult; + final Type[] argumentTypes = Type.getArgumentTypes(methodNode.desc); + final Type resultType = Type.getReturnType(methodNode.desc); + final boolean isReferenceResult = ASMUtils.isReferenceType(resultType); + final boolean isBooleanResult = ASMUtils.isBooleanType(resultType); + final boolean isInterestingResult = isReferenceResult || isBooleanResult; + final Method method = new Method(className, methodNode.name, methodNode.desc); + final boolean stable = stableClass || (methodNode.access & STABLE_FLAGS) != 0 || "<init>".equals(methodNode.name); + + Key primaryKey = new Key(method, new Out(), stable); if (argumentTypes.length == 0 && !isInterestingResult) { - return; + return Pair.create(primaryKey, EMPTY_EQUATIONS); } - Method method = new Method(className, methodNode.name, methodNode.desc); - int access = methodNode.access; - boolean stable = - stableClass || - (access & Opcodes.ACC_FINAL) != 0 || - (access & Opcodes.ACC_PRIVATE) != 0 || - (access & Opcodes.ACC_STATIC) != 0 || - "<init>".equals(methodNode.name); try { - boolean added = false; - ControlFlowGraph graph = cfg.buildControlFlowGraph(className, methodNode); - - boolean maybeLeakingParameter = false; - for (Type argType : argumentTypes) { - int argSort = argType.getSort(); - if (argSort == Type.OBJECT || argSort == Type.ARRAY || (isInterestingResult && Type.BOOLEAN_TYPE.equals(argType))) { - maybeLeakingParameter = true; - break; + final ControlFlowGraph graph = ControlFlowGraph.build(className, methodNode, jsr); + if (graph.transitions.length > 0) { + final DFSTree dfs = DFSTree.build(graph.transitions, graph.edgeCount); + boolean branching = !dfs.back.isEmpty(); + if (!branching) { + for (int[] transition : graph.transitions) { + if (transition != null && transition.length > 1) { + branching = true; + break; + } + } + } + + if (branching) { + RichControlFlow richControlFlow = new RichControlFlow(graph, dfs); + if (richControlFlow.reducible()) { + return Pair.create(primaryKey, + processBranchingMethod(method, methodNode, richControlFlow, argumentTypes, isReferenceResult, isInterestingResult, stable, jsr)); + } + LOG.debug(method + ": CFG is not reducible"); + } + // simple + else { + return Pair.create(primaryKey, + processNonBranchingMethod(method, argumentTypes, graph, isReferenceResult, isBooleanResult, stable)); } } + return Pair.create(primaryKey, topEquations(method, argumentTypes, isReferenceResult, isInterestingResult, stable)); + } + catch (ProcessCanceledException e) { + throw e; + } + catch (Throwable e) { + // incorrect bytecode may result in Runtime exceptions during analysis + // so here we suppose that exception is due to incorrect bytecode + LOG.debug("Unexpected Error during processing of " + method + " in " + presentableUrl, e); + return Pair.create(primaryKey, topEquations(method, argumentTypes, isReferenceResult, isInterestingResult, stable)); + } + } - if (graph.transitions.length > 0) { - DFSTree dfs = cfg.buildDFSTree(graph.transitions); - boolean reducible = dfs.back.isEmpty() || cfg.reducible(graph, dfs); - if (reducible) { - NotNullLazyValue<TIntHashSet> resultOrigins = new NotNullLazyValue<TIntHashSet>() { - @NotNull - @Override - protected TIntHashSet compute() { - try { - return cfg.resultOrigins(className, methodNode); - } - catch (AnalyzerException e) { - throw new RuntimeException(e); - } - } - }; - boolean[] leakingParameters = maybeLeakingParameter ? cfg.leakingParameters(className, methodNode) : null; - boolean shouldComputeResult = isReferenceResult; - - if (!shouldComputeResult && isInterestingResult && maybeLeakingParameter) { - loop: for (int i = 0; i < argumentTypes.length; i++) { - Type argType = argumentTypes[i]; - int argSort = argType.getSort(); - boolean isReferenceArg = argSort == Type.OBJECT || argSort == Type.ARRAY; - boolean isBooleanArg = Type.BOOLEAN_TYPE.equals(argType); - if ((isReferenceArg || isBooleanArg) && !leakingParameters[i]) { - shouldComputeResult = true; - break loop; - } - } + private List<Equation<Key, Value>> processBranchingMethod(final Method method, + final MethodNode methodNode, + final RichControlFlow richControlFlow, + Type[] argumentTypes, + boolean isReferenceResult, + boolean isInterestingResult, + final boolean stable, + boolean jsr) throws AnalyzerException { + + List<Equation<Key, Value>> result = new ArrayList<Equation<Key, Value>>(argumentTypes.length * 4 + 1); + boolean maybeLeakingParameter = isInterestingResult; + for (Type argType : argumentTypes) { + if (ASMUtils.isReferenceType(argType) || (isReferenceResult && ASMUtils.isBooleanType(argType))) { + maybeLeakingParameter = true; + break; + } + } + + final LeakingParameters leakingParametersAndFrames = + maybeLeakingParameter ? leakingParametersAndFrames(method, methodNode, argumentTypes, jsr) : null; + boolean[] leakingParameters = + leakingParametersAndFrames != null ? leakingParametersAndFrames.parameters : null; + boolean[] leakingNullableParameters = + leakingParametersAndFrames != null ? leakingParametersAndFrames.nullableParameters : null; + + final NullableLazyValue<boolean[]> origins = new NullableLazyValue<boolean[]>() { + @Override + protected boolean[] compute() { + try { + return OriginsAnalysis.resultOrigins(leakingParametersAndFrames.frames, methodNode.instructions, richControlFlow.controlFlow); + } + catch (AnalyzerException e) { + LOG.debug("when processing " + method + " in " + presentableUrl, e); + return null; + } + } + }; + + NotNullLazyValue<Equation<Key, Value>> outEquation = new NotNullLazyValue<Equation<Key, Value>>() { + @NotNull + @Override + protected Equation<Key, Value> compute() { + if (origins.getValue() != null) { + try { + return new InOutAnalysis(richControlFlow, new Out(), origins.getValue(), stable).analyze(); + } + catch (AnalyzerException ignored) { } + } + return new Equation<Key, Value>(new Key(method, new Out(), stable), FINAL_TOP); + } + }; - Equation<Key, Value> resultEquation = - shouldComputeResult ? new InOutAnalysis(new RichControlFlow(graph, dfs), new Out(), resultOrigins.getValue(), stable).analyze() : null; - - for (int i = 0; i < argumentTypes.length; i++) { - Type argType = argumentTypes[i]; - int argSort = argType.getSort(); - boolean isReferenceArg = argSort == Type.OBJECT || argSort == Type.ARRAY; - boolean isBooleanArg = Type.BOOLEAN_TYPE.equals(argType); - if (isReferenceArg) { - if (leakingParameters[i]) { - parameterEquations.add(new NonNullInAnalysis(new RichControlFlow(graph, dfs), new In(i), stable).analyze()); - } else { - parameterEquations.add(new Equation<Key, Value>(new Key(method, new In(i), stable), new Final<Key, Value>(Value.Top))); - } - } - if (isReferenceArg && isInterestingResult) { - if (leakingParameters[i]) { - contractEquations.add(new InOutAnalysis(new RichControlFlow(graph, dfs), new InOut(i, Value.Null), resultOrigins.getValue(), stable).analyze()); - contractEquations.add(new InOutAnalysis(new RichControlFlow(graph, dfs), new InOut(i, Value.NotNull), resultOrigins.getValue(), stable).analyze()); - } else { - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), resultEquation.rhs)); - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.NotNull), stable), resultEquation.rhs)); - } + if (isReferenceResult) { + result.add(outEquation.getValue()); + } + + for (int i = 0; i < argumentTypes.length; i++) { + boolean isReferenceArg = ASMUtils.isReferenceType(argumentTypes[i]); + boolean notNullParam = false; + + if (isReferenceArg) { + boolean possibleNPE = false; + if (leakingParameters[i]) { + NonNullInAnalysis notNullInAnalysis = new NonNullInAnalysis(richControlFlow, new In(i, In.NOT_NULL), stable); + Equation<Key, Value> notNullParamEquation = notNullInAnalysis.analyze(); + possibleNPE = notNullInAnalysis.possibleNPE; + notNullParam = notNullParamEquation.rhs.equals(FINAL_NOT_NULL); + result.add(notNullParamEquation); + } + else { + // parameter is not leaking, so it is definitely NOT @NotNull + result.add(new Equation<Key, Value>(new Key(method, new In(i, In.NOT_NULL), stable), FINAL_TOP)); + } + if (leakingNullableParameters[i]) { + if (notNullParam || possibleNPE) { + result.add(new Equation<Key, Value>(new Key(method, new In(i, In.NULLABLE), stable), FINAL_TOP)); + } + else { + result.add(new NullableInAnalysis(richControlFlow, new In(i, In.NULLABLE), stable).analyze()); + } + } + else { + result.add(new Equation<Key, Value>(new Key(method, new In(i, In.NULLABLE), stable), FINAL_NULL)); + } + } + if (isReferenceArg && isInterestingResult) { + if (leakingParameters[i]) { + if (origins.getValue() != null) { + // result origins analysis was ok + if (!notNullParam) { + // may be null on some branch, running "null->..." analysis + result.add(new InOutAnalysis(richControlFlow, new InOut(i, Value.Null), origins.getValue(), stable).analyze()); } - if (isBooleanArg && isInterestingResult) { - if (leakingParameters[i]) { - contractEquations.add(new InOutAnalysis(new RichControlFlow(graph, dfs), new InOut(i, Value.False), resultOrigins.getValue(), stable).analyze()); - contractEquations.add(new InOutAnalysis(new RichControlFlow(graph, dfs), new InOut(i, Value.True), resultOrigins.getValue(), stable).analyze()); - } else { - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.False), stable), resultEquation.rhs)); - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.True), stable), resultEquation.rhs)); - } + else { + // @NotNull, so "null->fail" + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), FINAL_BOT)); } + result.add(new InOutAnalysis(richControlFlow, new InOut(i, Value.NotNull), origins.getValue(), stable).analyze()); } - if (isReferenceResult) { - if (resultEquation != null) { - contractEquations.add(resultEquation); - } else { - contractEquations.add(new InOutAnalysis(new RichControlFlow(graph, dfs), new Out(), resultOrigins.getValue(), stable).analyze()); - } + else { + // result origins analysis failed, approximating to Top + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), FINAL_TOP)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.NotNull), stable), FINAL_TOP)); } - added = true; } else { - LOG.debug("CFG for " + method + " is not reducible"); + // parameter is not leaking, so a contract is the same as for the whole method + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), outEquation.getValue().rhs)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.NotNull), stable), outEquation.getValue().rhs)); } } - - if (!added) { - method = new Method(className, methodNode.name, methodNode.desc); - for (int i = 0; i < argumentTypes.length; i++) { - Type argType = argumentTypes[i]; - int argSort = argType.getSort(); - boolean isReferenceArg = argSort == Type.OBJECT || argSort == Type.ARRAY; - boolean isBooleanArg = Type.BOOLEAN_TYPE.equals(argType); - - if (isReferenceArg) { - parameterEquations.add(new Equation<Key, Value>(new Key(method, new In(i), stable), new Final<Key, Value>(Value.Top))); - } - if (isReferenceArg && isInterestingResult) { - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), new Final<Key, Value>(Value.Top))); - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.NotNull), stable), new Final<Key, Value>(Value.Top))); + if (ASMUtils.isBooleanType(argumentTypes[i]) && isInterestingResult) { + if (leakingParameters[i]) { + if (origins.getValue() != null) { + // result origins analysis was ok + result.add(new InOutAnalysis(richControlFlow, new InOut(i, Value.False), origins.getValue(), stable).analyze()); + result.add(new InOutAnalysis(richControlFlow, new InOut(i, Value.True), origins.getValue(), stable).analyze()); } - if (isBooleanArg && isInterestingResult) { - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.False), stable), new Final<Key, Value>(Value.Top))); - contractEquations.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.True), stable), new Final<Key, Value>(Value.Top))); + else { + // result origins analysis failed, approximating to Top + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.False), stable), FINAL_TOP)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.True), stable), FINAL_TOP)); } } - if (isReferenceResult) { - contractEquations.add(new Equation<Key, Value>(new Key(method, new Out(), stable), new Final<Key, Value>(Value.Top))); + else { + // parameter is not leaking, so a contract is the same as for the whole method + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.False), stable), outEquation.getValue().rhs)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.True), stable), outEquation.getValue().rhs)); } } } - catch (ProcessCanceledException e) { - throw e; + return result; + } + + private List<Equation<Key, Value>> processNonBranchingMethod(Method method, + Type[] argumentTypes, + ControlFlowGraph graph, + boolean isReferenceResult, + boolean isBooleanResult, + boolean stable) throws AnalyzerException { + List<Equation<Key, Value>> result = new ArrayList<Equation<Key, Value>>(argumentTypes.length * 4 + 1); + CombinedSingleAnalysis analyzer = new CombinedSingleAnalysis(method, graph); + analyzer.analyze(); + if (isReferenceResult) { + result.add(analyzer.outContractEquation(stable)); } - catch (Throwable e) { - // incorrect bytecode may result in Runtime exceptions during analysis - // so here we suppose that exception is due to incorrect bytecode - LOG.debug("Unexpected Error during processing of " + method, e); + for (int i = 0; i < argumentTypes.length; i++) { + Type argType = argumentTypes[i]; + boolean isRefArg = ASMUtils.isReferenceType(argType); + if (isRefArg) { + result.add(analyzer.notNullParamEquation(i, stable)); + result.add(analyzer.nullableParamEquation(i, stable)); + } + if (isRefArg && (isReferenceResult || isBooleanResult)) { + result.add(analyzer.contractEquation(i, Value.Null, stable)); + result.add(analyzer.contractEquation(i, Value.NotNull, stable)); + } + if (ASMUtils.isBooleanType(argType) && (isReferenceResult || isBooleanResult)) { + result.add(analyzer.contractEquation(i, Value.True, stable)); + result.add(analyzer.contractEquation(i, Value.False, stable)); + } } + return result; + } + + private List<Equation<Key, Value>> topEquations(Method method, + Type[] argumentTypes, + boolean isReferenceResult, + boolean isInterestingResult, + boolean stable) { + List<Equation<Key, Value>> result = new ArrayList<Equation<Key, Value>>(argumentTypes.length * 3 + 1); + if (isReferenceResult) { + result.add(new Equation<Key, Value>(new Key(method, new Out(), stable), FINAL_TOP)); + } + for (int i = 0; i < argumentTypes.length; i++) { + Type argType = argumentTypes[i]; + boolean isReferenceArg = ASMUtils.isReferenceType(argType); + boolean isBooleanArg = ASMUtils.isBooleanType(argType); + + if (isReferenceArg) { + result.add(new Equation<Key, Value>(new Key(method, new In(i, In.NOT_NULL), stable), FINAL_TOP)); + result.add(new Equation<Key, Value>(new Key(method, new In(i, In.NULLABLE), stable), FINAL_TOP)); + } + if (isReferenceArg && isInterestingResult) { + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.Null), stable), FINAL_TOP)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.NotNull), stable), FINAL_TOP)); + } + if (isBooleanArg && isInterestingResult) { + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.False), stable), FINAL_TOP)); + result.add(new Equation<Key, Value>(new Key(method, new InOut(i, Value.True), stable), FINAL_TOP)); + } + } + return result; + } + + private LeakingParameters leakingParametersAndFrames(Method method, MethodNode methodNode, Type[] argumentTypes, boolean jsr) + throws AnalyzerException { + return argumentTypes.length < 32 ? + LeakingParameters.buildFast(method.internalClassName, methodNode, jsr) : + LeakingParameters.build(method.internalClassName, methodNode, jsr); } }, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); - return new ClassEquations(parameterEquations, contractEquations); + return equations; } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Combined.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Combined.java new file mode 100644 index 000000000000..645c00260af1 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Combined.java @@ -0,0 +1,465 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis; + +import com.intellij.codeInspection.bytecodeAnalysis.asm.ASMUtils; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph; +import com.intellij.util.SingletonSet; +import com.intellij.util.containers.HashSet; +import org.jetbrains.org.objectweb.asm.Handle; +import org.jetbrains.org.objectweb.asm.Opcodes; +import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.tree.*; +import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; +import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter; +import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue; +import org.jetbrains.org.objectweb.asm.tree.analysis.Frame; + +import java.util.Collections; +import java.util.List; +import java.util.Set; + +import static com.intellij.codeInspection.bytecodeAnalysis.AbstractValues.*; +import static org.jetbrains.org.objectweb.asm.Opcodes.*; + +final class ParamKey { + final Method method; + final int i; + final boolean stable; + + + ParamKey(Method method, int i, boolean stable) { + this.method = method; + this.i = i; + this.stable = stable; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + ParamKey paramKey = (ParamKey)o; + + if (i != paramKey.i) return false; + if (stable != paramKey.stable) return false; + if (!method.equals(paramKey.method)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = method.hashCode(); + result = 31 * result + i; + result = 31 * result + (stable ? 1 : 0); + return result; + } +} + +final class CombinedCall extends BasicValue { + final Method method; + final boolean stableCall; + final List<? extends BasicValue> args; + + CombinedCall(Type tp, Method method, boolean stableCall, List<? extends BasicValue> args) { + super(tp); + this.method = method; + this.stableCall = stableCall; + this.args = args; + } +} + +final class NParamValue extends BasicValue { + final int n; + public NParamValue(Type type, int n) { + super(type); + this.n = n; + } +} + +final class CombinedSingleAnalysis { + private final ControlFlowGraph controlFlow; + private final Method method; + private final CombinedInterpreter interpreter; + private BasicValue returnValue; + private boolean exception; + private final MethodNode methodNode; + + CombinedSingleAnalysis(Method method, ControlFlowGraph controlFlow) { + this.method = method; + this.controlFlow = controlFlow; + methodNode = controlFlow.methodNode; + interpreter = new CombinedInterpreter(Type.getArgumentTypes(methodNode.desc).length); + } + + final void analyze() throws AnalyzerException { + Frame<BasicValue> frame = createStartFrame(); + int insnIndex = 0; + + while (true) { + AbstractInsnNode insnNode = methodNode.instructions.get(insnIndex); + switch (insnNode.getType()) { + case AbstractInsnNode.LABEL: + case AbstractInsnNode.LINE: + case AbstractInsnNode.FRAME: + insnIndex = controlFlow.transitions[insnIndex][0]; + break; + default: + switch (insnNode.getOpcode()) { + case ATHROW: + exception = true; + return; + case ARETURN: + case IRETURN: + case LRETURN: + case FRETURN: + case DRETURN: + returnValue = frame.pop(); + return; + case RETURN: + // nothing to return + return; + default: + frame.execute(insnNode, interpreter); + insnIndex = controlFlow.transitions[insnIndex][0]; + } + } + } + } + + final Equation<Key, Value> notNullParamEquation(int i, boolean stable) { + final Key key = new Key(method, new In(i, In.NOT_NULL), stable); + final Result<Key, Value> result; + if (interpreter.dereferenced[i]) { + result = new Final<Key, Value>(Value.NotNull); + } + else { + Set<ParamKey> calls = interpreter.callDerefs[i]; + if (calls == null || calls.isEmpty()) { + result = new Final<Key, Value>(Value.Top); + } + else { + Set<Key> keys = new HashSet<Key>(); + for (ParamKey pk: calls) { + keys.add(new Key(pk.method, new In(pk.i, In.NOT_NULL), pk.stable)); + } + result = new Pending<Key, Value>(new SingletonSet<Product<Key, Value>>(new Product<Key, Value>(Value.Top, keys))); + } + } + return new Equation<Key, Value>(key, result); + } + + final Equation<Key, Value> nullableParamEquation(int i, boolean stable) { + final Key key = new Key(method, new In(i, In.NULLABLE), stable); + final Result<Key, Value> result; + if (interpreter.dereferenced[i] || interpreter.notNullable[i] || returnValue instanceof NParamValue && ((NParamValue)returnValue).n == i) { + result = new Final<Key, Value>(Value.Top); + } + else { + Set<ParamKey> calls = interpreter.callDerefs[i]; + if (calls == null || calls.isEmpty()) { + result = new Final<Key, Value>(Value.Null); + } + else { + Set<Product<Key, Value>> sum = new HashSet<Product<Key, Value>>(); + for (ParamKey pk: calls) { + sum.add(new Product<Key, Value>(Value.Top, Collections.singleton(new Key(pk.method, new In(pk.i, In.NULLABLE), pk.stable)))); + } + result = new Pending<Key, Value>(sum); + } + } + return new Equation<Key, Value>(key, result); + } + + final Equation<Key, Value> contractEquation(int i, Value inValue, boolean stable) { + final Key key = new Key(method, new InOut(i, inValue), stable); + final Result<Key, Value> result; + if (exception || (inValue == Value.Null && interpreter.dereferenced[i])) { + result = new Final<Key, Value>(Value.Bot); + } + else if (FalseValue == returnValue) { + result = new Final<Key, Value>(Value.False); + } + else if (TrueValue == returnValue) { + result = new Final<Key, Value>(Value.True); + } + else if (NullValue == returnValue) { + result = new Final<Key, Value>(Value.Null); + } + else if (returnValue instanceof NotNullValue) { + result = new Final<Key, Value>(Value.NotNull); + } + else if (returnValue instanceof NParamValue && ((NParamValue)returnValue).n == i) { + result = new Final<Key, Value>(inValue); + } + else if (returnValue instanceof CombinedCall) { + CombinedCall call = (CombinedCall)returnValue; + HashSet<Key> keys = new HashSet<Key>(); + for (int argI = 0; argI < call.args.size(); argI++) { + BasicValue arg = call.args.get(argI); + if (arg instanceof NParamValue) { + NParamValue npv = (NParamValue)arg; + if (npv.n == i) { + keys.add(new Key(call.method, new InOut(argI, inValue), call.stableCall)); + } + } + } + if (ASMUtils.isReferenceType(call.getType())) { + keys.add(new Key(call.method, new Out(), call.stableCall)); + } + if (keys.isEmpty()) { + result = new Final<Key, Value>(Value.Top); + } else { + result = new Pending<Key, Value>(new SingletonSet<Product<Key, Value>>(new Product<Key, Value>(Value.Top, keys))); + } + } + else { + result = new Final<Key, Value>(Value.Top); + } + return new Equation<Key, Value>(key, result); + } + + final Equation<Key, Value> outContractEquation(boolean stable) { + final Key key = new Key(method, new Out(), stable); + final Result<Key, Value> result; + if (exception) { + result = new Final<Key, Value>(Value.Bot); + } + else if (FalseValue == returnValue) { + result = new Final<Key, Value>(Value.False); + } + else if (TrueValue == returnValue) { + result = new Final<Key, Value>(Value.True); + } + else if (NullValue == returnValue) { + result = new Final<Key, Value>(Value.Null); + } + else if (returnValue instanceof NotNullValue) { + result = new Final<Key, Value>(Value.NotNull); + } + else if (returnValue instanceof CombinedCall) { + CombinedCall call = (CombinedCall)returnValue; + Key callKey = new Key(call.method, new Out(), call.stableCall); + Set<Key> keys = new SingletonSet<Key>(callKey); + result = new Pending<Key, Value>(new SingletonSet<Product<Key, Value>>(new Product<Key, Value>(Value.Top, keys))); + } + else { + result = new Final<Key, Value>(Value.Top); + } + return new Equation<Key, Value>(key, result); + } + + final Frame<BasicValue> createStartFrame() { + Frame<BasicValue> frame = new Frame<BasicValue>(methodNode.maxLocals, methodNode.maxStack); + Type returnType = Type.getReturnType(methodNode.desc); + BasicValue returnValue = Type.VOID_TYPE.equals(returnType) ? null : new BasicValue(returnType); + frame.setReturn(returnValue); + + Type[] args = Type.getArgumentTypes(methodNode.desc); + int local = 0; + if ((methodNode.access & Opcodes.ACC_STATIC) == 0) { + frame.setLocal(local++, new AbstractValues.NotNullValue(Type.getObjectType(controlFlow.className))); + } + for (int i = 0; i < args.length; i++) { + BasicValue value = new NParamValue(args[i], i); + frame.setLocal(local++, value); + if (args[i].getSize() == 2) { + frame.setLocal(local++, BasicValue.UNINITIALIZED_VALUE); + } + } + while (local < methodNode.maxLocals) { + frame.setLocal(local++, BasicValue.UNINITIALIZED_VALUE); + } + return frame; + } +} + +final class CombinedInterpreter extends BasicInterpreter { + final boolean[] dereferenced; + final boolean[] notNullable; + final Set<ParamKey>[] callDerefs; + + CombinedInterpreter(int arity) { + dereferenced = new boolean[arity]; + notNullable = new boolean[arity]; + callDerefs = new Set[arity]; + } + + @Override + public BasicValue newOperation(AbstractInsnNode insn) throws AnalyzerException { + switch (insn.getOpcode()) { + case ICONST_0: + return FalseValue; + case ICONST_1: + return TrueValue; + case ACONST_NULL: + return NullValue; + case LDC: + Object cst = ((LdcInsnNode)insn).cst; + if (cst instanceof Type) { + Type type = (Type)cst; + if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) { + return CLASS_VALUE; + } + if (type.getSort() == Type.METHOD) { + return METHOD_VALUE; + } + } + else if (cst instanceof String) { + return STRING_VALUE; + } + else if (cst instanceof Handle) { + return METHOD_HANDLE_VALUE; + } + break; + case NEW: + return new NotNullValue(Type.getObjectType(((TypeInsnNode)insn).desc)); + default: + } + return super.newOperation(insn); + } + + @Override + public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { + switch (insn.getOpcode()) { + case GETFIELD: + case ARRAYLENGTH: + case MONITORENTER: + if (value instanceof NParamValue) { + dereferenced[((NParamValue)value).n] = true; + } + return super.unaryOperation(insn, value); + case CHECKCAST: + if (value instanceof NParamValue) { + return new NParamValue(Type.getObjectType(((TypeInsnNode)insn).desc), ((NParamValue)value).n); + } + break; + case NEWARRAY: + case ANEWARRAY: + return new NotNullValue(super.unaryOperation(insn, value).getType()); + default: + } + return super.unaryOperation(insn, value); + } + + @Override + public BasicValue binaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2) throws AnalyzerException { + switch (insn.getOpcode()) { + case IALOAD: + case LALOAD: + case FALOAD: + case DALOAD: + case AALOAD: + case BALOAD: + case CALOAD: + case SALOAD: + if (value1 instanceof NParamValue) { + dereferenced[((NParamValue)value1).n] = true; + } + break; + case PUTFIELD: + if (value1 instanceof NParamValue) { + dereferenced[((NParamValue)value1).n] = true; + } + if (value2 instanceof NParamValue) { + notNullable[((NParamValue)value2).n] = true; + } + break; + default: + } + return super.binaryOperation(insn, value1, value2); + } + + @Override + public BasicValue ternaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2, BasicValue value3) + throws AnalyzerException { + switch (insn.getOpcode()) { + case IASTORE: + case LASTORE: + case FASTORE: + case DASTORE: + case BASTORE: + case CASTORE: + case SASTORE: + if (value1 instanceof NParamValue) { + dereferenced[((NParamValue)value1).n] = true; + } + break; + case AASTORE: + if (value1 instanceof NParamValue) { + dereferenced[((NParamValue)value1).n] = true; + } + if (value3 instanceof NParamValue) { + notNullable[((NParamValue)value3).n] = true; + } + break; + default: + } + return super.ternaryOperation(insn, value1, value2, value3); + } + + @Override + public BasicValue naryOperation(AbstractInsnNode insn, List<? extends BasicValue> values) throws AnalyzerException { + int opCode = insn.getOpcode(); + int shift = opCode == INVOKESTATIC ? 0 : 1; + + switch (opCode) { + case INVOKESPECIAL: + case INVOKEINTERFACE: + case INVOKEVIRTUAL: + if (values.get(0) instanceof NParamValue) { + dereferenced[((NParamValue)values.get(0)).n] = true; + } + } + + switch (opCode) { + case INVOKESTATIC: + case INVOKESPECIAL: + case INVOKEVIRTUAL: + case INVOKEINTERFACE: + boolean stable = opCode == INVOKESTATIC || opCode == INVOKESPECIAL; + MethodInsnNode mNode = (MethodInsnNode)insn; + Method method = new Method(mNode.owner, mNode.name, mNode.desc); + Type retType = Type.getReturnType(mNode.desc); + + for (int i = shift; i < values.size(); i++) { + if (values.get(i) instanceof NParamValue) { + int n = ((NParamValue)values.get(i)).n; + if (opCode == INVOKEINTERFACE) { + notNullable[n] = true; + } + else { + Set<ParamKey> npKeys = callDerefs[n]; + if (npKeys == null) { + npKeys = new HashSet<ParamKey>(); + callDerefs[n] = npKeys; + } + npKeys.add(new ParamKey(method, i - shift, stable)); + } + } + } + if (shift == 1) { + values.remove(0); + } + return new CombinedCall(retType, method, stable, values); + case MULTIANEWARRAY: + return new NotNullValue(super.naryOperation(insn, values).getType()); + default: + } + return super.naryOperation(insn, values); + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Contracts.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Contracts.java index 7b6c52e75a63..c382148abb05 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Contracts.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Contracts.java @@ -15,7 +15,10 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; -import gnu.trove.TIntHashSet; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ASMUtils; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph.Edge; +import com.intellij.codeInspection.bytecodeAnalysis.asm.RichControlFlow; +import org.jetbrains.annotations.NotNull; import org.jetbrains.org.objectweb.asm.Handle; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.tree.*; @@ -24,75 +27,104 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter; import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue; import org.jetbrains.org.objectweb.asm.tree.analysis.Frame; -import java.util.*; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import static com.intellij.codeInspection.bytecodeAnalysis.AbstractValues.*; import static org.jetbrains.org.objectweb.asm.Opcodes.*; class InOutAnalysis extends Analysis<Result<Key, Value>> { - final ResultUtil<Key, Value> resultUtil = + static final ResultUtil<Key, Value> resultUtil = new ResultUtil<Key, Value>(new ELattice<Value>(Value.Bot, Value.Top)); + final private State[] pending = ourPendingStates.get(); private final InOutInterpreter interpreter; private final Value inValue; + private final int generalizeShift; + private Result<Key, Value> internalResult; + private int id = 0; + private int pendingTop = 0; - protected InOutAnalysis(RichControlFlow richControlFlow, Direction direction, TIntHashSet resultOrigins, boolean stable) { + protected InOutAnalysis(RichControlFlow richControlFlow, Direction direction, boolean[] resultOrigins, boolean stable) { super(richControlFlow, direction, stable); interpreter = new InOutInterpreter(direction, richControlFlow.controlFlow.methodNode.instructions, resultOrigins); inValue = direction instanceof InOut ? ((InOut)direction).inValue : null; + generalizeShift = (methodNode.access & ACC_STATIC) == 0 ? 1 : 0; + internalResult = new Final<Key, Value>(Value.Bot); } - @Override - Result<Key, Value> identity() { - return new Final<Key, Value>(Value.Bot); + @NotNull + Equation<Key, Value> mkEquation(Result<Key, Value> res) { + return new Equation<Key, Value>(aKey, res); } - @Override - Result<Key, Value> combineResults(Result<Key, Value> delta, List<Result<Key, Value>> subResults) throws AnalyzerException { - Result<Key, Value> result = null; - for (Result<Key, Value> subResult : subResults) { - if (result == null) { - result = subResult; - } else { - result = resultUtil.join(result, subResult); + @NotNull + protected Equation<Key, Value> analyze() throws AnalyzerException { + pendingPush(createStartState()); + int steps = 0; + while (pendingTop > 0 && earlyResult == null) { + steps ++; + if (steps >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached, steps: " + steps + " in method " + method); + } + State state = pending[--pendingTop]; + int insnIndex = state.conf.insnIndex; + Conf conf = state.conf; + List<Conf> history = state.history; + + boolean fold = false; + if (dfsTree.loopEnters[insnIndex]) { + for (Conf prev : history) { + if (AbstractValues.isInstance(conf, prev)) { + fold = true; + break; + } + } + } + if (fold) { + addComputed(insnIndex, state); + } + else { + State baseState = null; + List<State> thisComputed = computed[insnIndex]; + if (thisComputed != null) { + for (State prevState : thisComputed) { + if (stateEquiv(state, prevState)) { + baseState = prevState; + break; + } + } + } + if (baseState == null) { + processState(state); + } } } - return result; - } - - @Override - boolean isEarlyResult(Result<Key, Value> res) { - if (res instanceof Final) { - return ((Final<?, Value>)res).value == Value.Top; + if (earlyResult != null) { + return mkEquation(earlyResult); + } else { + return mkEquation(internalResult); } - return false; - } - - @Override - Equation<Key, Value> mkEquation(Result<Key, Value> res) { - return new Equation<Key, Value>(aKey, res); } - private int id = 0; - - @Override void processState(State state) throws AnalyzerException { - int stateIndex = state.index; Conf preConf = state.conf; int insnIndex = preConf.insnIndex; - boolean loopEnter = dfsTree.loopEnters.contains(insnIndex); + boolean loopEnter = dfsTree.loopEnters[insnIndex]; Conf conf = loopEnter ? generalize(preConf) : preConf; List<Conf> history = state.history; boolean taken = state.taken; Frame<BasicValue> frame = conf.frame; AbstractInsnNode insnNode = methodNode.instructions.get(insnIndex); - List<Conf> nextHistory = dfsTree.loopEnters.contains(insnIndex) ? append(history, conf) : history; + List<Conf> nextHistory = loopEnter ? append(history, conf) : history; Frame<BasicValue> nextFrame = execute(frame, insnNode); + addComputed(insnIndex, state); + if (interpreter.deReferenced) { - results.put(stateIndex, new Final<Key, Value>(Value.Bot)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); return; } @@ -105,38 +137,36 @@ class InOutAnalysis extends Analysis<Result<Key, Value>> { case DRETURN: case RETURN: BasicValue stackTop = popValue(frame); + Result<Key, Value> subResult; if (FalseValue == stackTop) { - results.put(stateIndex, new Final<Key, Value>(Value.False)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Final<Key, Value>(Value.False); } else if (TrueValue == stackTop) { - results.put(stateIndex, new Final<Key, Value>(Value.True)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Final<Key, Value>(Value.True); } else if (NullValue == stackTop) { - results.put(stateIndex, new Final<Key, Value>(Value.Null)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Final<Key, Value>(Value.Null); } else if (stackTop instanceof NotNullValue) { - results.put(stateIndex, new Final<Key, Value>(Value.NotNull)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Final<Key, Value>(Value.NotNull); } else if (stackTop instanceof ParamValue) { - results.put(stateIndex, new Final<Key, Value>(inValue)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Final<Key, Value>(inValue); } else if (stackTop instanceof CallResultValue) { Set<Key> keys = ((CallResultValue) stackTop).inters; - results.put(stateIndex, new Pending<Key, Value>(Collections.singleton(new Product<Key, Value>(Value.Top, keys)))); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + subResult = new Pending<Key, Value>(Collections.singleton(new Product<Key, Value>(Value.Top, keys))); } else { earlyResult = new Final<Key, Value>(Value.Top); + return; + } + internalResult = resultUtil.join(internalResult, subResult); + if (internalResult instanceof Final && ((Final<?, Value>)internalResult).value == Value.Top) { + earlyResult = internalResult; } return; case ATHROW: - results.put(stateIndex, new Final<Key, Value>(Value.Bot)); - computed.put(insnIndex, append(computed.get(insnIndex), state)); return; default: } @@ -144,72 +174,62 @@ class InOutAnalysis extends Analysis<Result<Key, Value>> { if (opcode == IFNONNULL && popValue(frame) instanceof ParamValue) { int nextInsnIndex = inValue == Value.Null ? insnIndex + 1 : methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } if (opcode == IFNULL && popValue(frame) instanceof ParamValue) { int nextInsnIndex = inValue == Value.NotNull ? insnIndex + 1 : methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } if (opcode == IFEQ && popValue(frame) == InstanceOfCheckValue && inValue == Value.Null) { int nextInsnIndex = methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } if (opcode == IFNE && popValue(frame) == InstanceOfCheckValue && inValue == Value.Null) { int nextInsnIndex = insnIndex + 1; State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } if (opcode == IFEQ && popValue(frame) instanceof ParamValue) { int nextInsnIndex = inValue == Value.True ? insnIndex + 1 : methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } if (opcode == IFNE && popValue(frame) instanceof ParamValue) { int nextInsnIndex = inValue == Value.False ? insnIndex + 1 : methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false); - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, new int[]{nextState.index})); - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + pendingPush(nextState); return; } // general case - int[] nextInsnIndices = controlFlow.transitions[insnIndex]; - List<State> nextStates = new ArrayList<State>(nextInsnIndices.length); - int[] subIndices = new int[nextInsnIndices.length]; - - for (int i = 0; i < nextInsnIndices.length; i++) { - int nextInsnIndex = nextInsnIndices[i]; + for (int nextInsnIndex : controlFlow.transitions[insnIndex]) { Frame<BasicValue> nextFrame1 = nextFrame; - if (controlFlow.errorTransitions.contains(new Edge(insnIndex, nextInsnIndex))) { + if (controlFlow.errors[nextInsnIndex] && controlFlow.errorTransitions.contains(new Edge(insnIndex, nextInsnIndex))) { nextFrame1 = new Frame<BasicValue>(frame); nextFrame1.clearStack(); - nextFrame1.push(new BasicValue(Type.getType("java/lang/Throwable"))); + nextFrame1.push(ASMUtils.THROWABLE_VALUE); } - nextStates.add(new State(++id, new Conf(nextInsnIndex, nextFrame1), nextHistory, taken, false)); - subIndices[i] = id; + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame1), nextHistory, taken, false)); } + } - pending.push(new MakeResult<Result<Key, Value>>(state, myIdentity, subIndices)); - for (State nextState : nextStates) { - pending.push(new ProceedState<Result<Key, Value>>(nextState)); + private void pendingPush(State st) throws AnalyzerException { + if (pendingTop >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached in method " + method); } + pending[pendingTop++] = st; } private Frame<BasicValue> execute(Frame<BasicValue> frame, AbstractInsnNode insnNode) throws AnalyzerException { @@ -226,9 +246,9 @@ class InOutAnalysis extends Analysis<Result<Key, Value>> { } } - private static Conf generalize(Conf conf) { + private Conf generalize(Conf conf) { Frame<BasicValue> frame = new Frame<BasicValue>(conf.frame); - for (int i = 0; i < frame.getLocals(); i++) { + for (int i = generalizeShift; i < frame.getLocals(); i++) { BasicValue value = frame.getLocal(i); Class<?> valueClass = value.getClass(); if (valueClass != BasicValue.class && valueClass != ParamValue.class) { @@ -258,12 +278,12 @@ class InOutAnalysis extends Analysis<Result<Key, Value>> { class InOutInterpreter extends BasicInterpreter { final Direction direction; final InsnList insns; - final TIntHashSet resultOrigins; + final boolean[] resultOrigins; final boolean nullAnalysis; boolean deReferenced = false; - InOutInterpreter(Direction direction, InsnList insns, TIntHashSet resultOrigins) { + InOutInterpreter(Direction direction, InsnList insns, boolean[] resultOrigins) { this.direction = direction; this.insns = insns; this.resultOrigins = resultOrigins; @@ -272,7 +292,7 @@ class InOutInterpreter extends BasicInterpreter { @Override public BasicValue newOperation(AbstractInsnNode insn) throws AnalyzerException { - boolean propagate = resultOrigins.contains(insns.indexOf(insn)); + boolean propagate = resultOrigins[insns.indexOf(insn)]; if (propagate) { switch (insn.getOpcode()) { case ICONST_0: @@ -286,17 +306,17 @@ class InOutInterpreter extends BasicInterpreter { if (cst instanceof Type) { Type type = (Type)cst; if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) { - return new NotNullValue(Type.getObjectType("java/lang/Class")); + return CLASS_VALUE; } if (type.getSort() == Type.METHOD) { - return new NotNullValue(Type.getObjectType("java/lang/invoke/MethodType")); + return METHOD_VALUE; } } else if (cst instanceof String) { - return new NotNullValue(Type.getObjectType("java/lang/String")); + return STRING_VALUE; } else if (cst instanceof Handle) { - return new NotNullValue(Type.getObjectType("java/lang/invoke/MethodHandle")); + return METHOD_HANDLE_VALUE; } break; case NEW: @@ -309,7 +329,7 @@ class InOutInterpreter extends BasicInterpreter { @Override public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { - boolean propagate = resultOrigins.contains(insns.indexOf(insn)); + boolean propagate = resultOrigins[insns.indexOf(insn)]; switch (insn.getOpcode()) { case GETFIELD: case ARRAYLENGTH: @@ -381,7 +401,7 @@ class InOutInterpreter extends BasicInterpreter { @Override public BasicValue naryOperation(AbstractInsnNode insn, List<? extends BasicValue> values) throws AnalyzerException { - boolean propagate = resultOrigins.contains(insns.indexOf(insn)); + boolean propagate = resultOrigins[insns.indexOf(insn)]; int opCode = insn.getOpcode(); int shift = opCode == INVOKESTATIC ? 0 : 1; diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ControlFlow.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ControlFlow.java deleted file mode 100644 index 910d75b9a57f..000000000000 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ControlFlow.java +++ /dev/null @@ -1,1030 +0,0 @@ -/* - * Copyright 2000-2014 JetBrains s.r.o. - * - * 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.intellij.codeInspection.bytecodeAnalysis; - -import gnu.trove.TIntArrayList; -import gnu.trove.TIntHashSet; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.org.objectweb.asm.Opcodes; -import org.jetbrains.org.objectweb.asm.Type; -import org.jetbrains.org.objectweb.asm.tree.*; -import org.jetbrains.org.objectweb.asm.tree.analysis.*; -import org.jetbrains.org.objectweb.asm.tree.analysis.Value; - -import java.util.*; - -import static org.jetbrains.org.objectweb.asm.Opcodes.*; - -final class cfg { - static ControlFlowGraph buildControlFlowGraph(String className, MethodNode methodNode) throws AnalyzerException { - return new ControlFlowBuilder(className, methodNode).buildCFG(); - } - - static TIntHashSet resultOrigins(String className, MethodNode methodNode) throws AnalyzerException { - Frame<SourceValue>[] frames = new Analyzer<SourceValue>(MININAL_ORIGIN_INTERPRETER).analyze(className, methodNode); - InsnList insns = methodNode.instructions; - TIntHashSet result = new TIntHashSet(); - for (int i = 0; i < frames.length; i++) { - AbstractInsnNode insnNode = insns.get(i); - Frame<SourceValue> frame = frames[i]; - if (frame != null) { - switch (insnNode.getOpcode()) { - case ARETURN: - case IRETURN: - case LRETURN: - case FRETURN: - case DRETURN: - for (AbstractInsnNode sourceInsn : frame.pop().insns) { - result.add(insns.indexOf(sourceInsn)); - } - break; - - default: - break; - } - } - } - return result; - } - - static boolean[] leakingParameters(String className, MethodNode methodNode) throws AnalyzerException { - Frame<ParamsValue>[] frames = new Analyzer<ParamsValue>(new ParametersUsage(methodNode)).analyze(className, methodNode); - InsnList insns = methodNode.instructions; - LeakingParametersCollector collector = new LeakingParametersCollector(methodNode); - for (int i = 0; i < frames.length; i++) { - AbstractInsnNode insnNode = insns.get(i); - Frame<ParamsValue> frame = frames[i]; - if (frame != null) { - switch (insnNode.getType()) { - case AbstractInsnNode.LABEL: - case AbstractInsnNode.LINE: - case AbstractInsnNode.FRAME: - break; - default: - frame.execute(insnNode, collector); - } - } - } - return collector.leaking; - } - - static final Interpreter<SourceValue> MININAL_ORIGIN_INTERPRETER = new SourceInterpreter() { - final SourceValue[] sourceVals = {new SourceValue(1), new SourceValue(2)}; - - @Override - public SourceValue newOperation(AbstractInsnNode insn) { - SourceValue result = super.newOperation(insn); - switch (insn.getOpcode()) { - case ICONST_0: - case ICONST_1: - case ACONST_NULL: - case LDC: - case NEW: - return result; - default: - return sourceVals[result.getSize() - 1]; - } - } - - @Override - public SourceValue unaryOperation(AbstractInsnNode insn, SourceValue value) { - SourceValue result = super.unaryOperation(insn, value); - switch (insn.getOpcode()) { - case CHECKCAST: - case NEWARRAY: - case ANEWARRAY: - return result; - default: - return sourceVals[result.getSize() - 1]; - } - } - - @Override - public SourceValue binaryOperation(AbstractInsnNode insn, SourceValue value1, SourceValue value2) { - switch (insn.getOpcode()) { - case LALOAD: - case DALOAD: - case LADD: - case DADD: - case LSUB: - case DSUB: - case LMUL: - case DMUL: - case LDIV: - case DDIV: - case LREM: - case LSHL: - case LSHR: - case LUSHR: - case LAND: - case LOR: - case LXOR: - return sourceVals[1]; - default: - return sourceVals[0]; - } - } - - @Override - public SourceValue ternaryOperation(AbstractInsnNode insn, SourceValue value1, SourceValue value2, SourceValue value3) { - return sourceVals[0]; - } - - @Override - public SourceValue copyOperation(AbstractInsnNode insn, SourceValue value) { - return value; - } - - }; - - private interface Action {} - private static class MarkScanned implements Action { - final int node; - private MarkScanned(int node) { - this.node = node; - } - } - private static class ExamineEdge implements Action { - final int from; - final int to; - - private ExamineEdge(int from, int to) { - this.from = from; - this.to = to; - } - } - - // Graphs: Theory and Algorithms. by K. Thulasiraman , M. N. S. Swamy (1992) - // 11.7.2 DFS of a directed graph - static DFSTree buildDFSTree(int[][] transitions) { - Set<Edge> tree = new HashSet<Edge>(); - Set<Edge> forward = new HashSet<Edge>(); - Set<Edge> back = new HashSet<Edge>(); - Set<Edge> cross = new HashSet<Edge>(); - - boolean[] marked = new boolean[transitions.length]; - boolean[] scanned = new boolean[transitions.length]; - int[] preOrder = new int[transitions.length]; - int[] postOrder = new int[transitions.length]; - - int entered = 0; - int completed = 0; - - Deque<Action> stack = new LinkedList<Action>(); - Set<Integer> loopEnters = new HashSet<Integer>(); - - // enter 0 - entered ++; - preOrder[0] = entered; - marked[0] = true; - stack.push(new MarkScanned(0)); - for (int to : transitions[0]) { - stack.push(new ExamineEdge(0, to)); - } - - while (!stack.isEmpty()) { - Action action = stack.pop(); - if (action instanceof MarkScanned) { - MarkScanned markScannedAction = (MarkScanned) action; - completed ++; - postOrder[markScannedAction.node] = completed; - scanned[markScannedAction.node] = true; - } - else { - ExamineEdge examineEdgeAction = (ExamineEdge) action; - int from = examineEdgeAction.from; - int to = examineEdgeAction.to; - if (!marked[to]) { - tree.add(new Edge(from, to)); - // enter to - entered ++; - preOrder[to] = entered; - marked[to] = true; - stack.push(new MarkScanned(to)); - for (int to1 : transitions[to]) { - stack.push(new ExamineEdge(to, to1)); - } - } - else if (preOrder[to] > preOrder[from]) { - forward.add(new Edge(from, to)); - } - else if (preOrder[to] < preOrder[from] && !scanned[to]) { - back.add(new Edge(from, to)); - loopEnters.add(to); - } else { - cross.add(new Edge(from, to)); - } - } - } - - return new DFSTree(preOrder, postOrder, tree, forward, back, cross, loopEnters); - } - - // Tarjan. Testing flow graph reducibility. - // Journal of Computer and System Sciences 9.3 (1974): 355-365. - static boolean reducible(ControlFlowGraph cfg, DFSTree dfs) { - int size = cfg.transitions.length; - HashSet<Integer>[] cycles = new HashSet[size]; - HashSet<Integer>[] nonCycles = new HashSet[size]; - int[] collapsedTo = new int[size]; - for (int i = 0; i < size; i++) { - cycles[i] = new HashSet<Integer>(); - nonCycles[i] = new HashSet<Integer>(); - collapsedTo[i] = i; - } - - for (Edge edge : dfs.back) { - cycles[edge.to].add(edge.from); - } - for (Edge edge : dfs.tree) { - nonCycles[edge.to].add(edge.from); - } - for (Edge edge : dfs.forward) { - nonCycles[edge.to].add(edge.from); - } - for (Edge edge : dfs.cross) { - nonCycles[edge.to].add(edge.from); - } - - for (int w = size - 1; w >= 0 ; w--) { - HashSet<Integer> p = new HashSet<Integer>(cycles[w]); - Queue<Integer> queue = new LinkedList<Integer>(cycles[w]); - - while (!queue.isEmpty()) { - int x = queue.remove(); - for (int y : nonCycles[x]) { - int y1 = collapsedTo[y]; - if (!dfs.isDescendant(y1, w)) { - return false; - } - if (y1 != w && p.add(y1)) { - queue.add(y1); - } - } - } - - for (int x : p) { - collapsedTo[x] = w; - } - } - - return true; - } - -} - -final class Edge { - final int from, to; - - Edge(int from, int to) { - this.from = from; - this.to = to; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof Edge)) { - return false; - } - Edge edge = (Edge) o; - return from == edge.from && to == edge.to; - } - - @Override - public int hashCode() { - return 31 * from + to; - } - - @Override - public String toString() { - return "(" + from + "," + to + ")"; - } -} - -final class ControlFlowGraph { - final String className; - final MethodNode methodNode; - final int[][] transitions; - final Set<Edge> errorTransitions; - - ControlFlowGraph(String className, MethodNode methodNode, int[][] transitions, Set<Edge> errorTransitions) { - this.className = className; - this.methodNode = methodNode; - this.transitions = transitions; - this.errorTransitions = errorTransitions; - } - - @Override - public String toString() { - return "CFG(" + - Arrays.toString(transitions) + "," + - errorTransitions + - ')'; - } -} - -final class RichControlFlow { - final ControlFlowGraph controlFlow; - final DFSTree dfsTree; - - RichControlFlow(ControlFlowGraph controlFlow, DFSTree dfsTree) { - this.controlFlow = controlFlow; - this.dfsTree = dfsTree; - } -} - -final class ControlFlowBuilder extends CfgAnalyzer { - final String className; - final MethodNode methodNode; - final TIntArrayList[] transitions; - final Set<Edge> errorTransitions; - - ControlFlowBuilder(String className, MethodNode methodNode) { - this.className = className; - this.methodNode = methodNode; - transitions = new TIntArrayList[methodNode.instructions.size()]; - for (int i = 0; i < transitions.length; i++) { - transitions[i] = new TIntArrayList(); - } - errorTransitions = new HashSet<Edge>(); - } - - final ControlFlowGraph buildCFG() throws AnalyzerException { - if ((methodNode.access & (ACC_ABSTRACT | ACC_NATIVE)) == 0) { - analyze(methodNode); - } - int[][] resultTransitions = new int[transitions.length][]; - for (int i = 0; i < resultTransitions.length; i++) { - resultTransitions[i] = transitions[i].toNativeArray(); - } - return new ControlFlowGraph(className, methodNode, resultTransitions, errorTransitions); - } - - @Override - protected final void newControlFlowEdge(int insn, int successor) { - if (!transitions[insn].contains(successor)) { - transitions[insn].add(successor); - } - } - - @Override - protected final boolean newControlFlowExceptionEdge(int insn, int successor) { - if (!transitions[insn].contains(successor)) { - transitions[insn].add(successor); - errorTransitions.add(new Edge(insn, successor)); - } - return true; - } -} - -final class DFSTree { - final int[] preOrder, postOrder; - final Set<Edge> tree, forward, back, cross; - final Set<Integer> loopEnters; - - DFSTree(int[] preOrder, - int[] postOrder, - Set<Edge> tree, - Set<Edge> forward, - Set<Edge> back, - Set<Edge> cross, - Set<Integer> loopEnters) { - this.preOrder = preOrder; - this.postOrder = postOrder; - this.tree = tree; - this.forward = forward; - this.back = back; - this.cross = cross; - this.loopEnters = loopEnters; - } - - final boolean isDescendant(int child, int parent) { - return preOrder[parent] <= preOrder[child] && postOrder[child] <= postOrder[parent]; - } -} - -final class ParamsValue implements Value { - @NotNull final boolean[] params; - final int size; - - ParamsValue(@NotNull boolean[] params, int size) { - this.params = params; - this.size = size; - } - - @Override - public int getSize() { - return size; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null) return false; - ParamsValue that = (ParamsValue)o; - return (this.size == that.size && Arrays.equals(this.params, that.params)); - } - - @Override - public int hashCode() { - return 31 * Arrays.hashCode(params) + size; - } -} - -class ParametersUsage extends Interpreter<ParamsValue> { - final ParamsValue val1; - final ParamsValue val2; - int called = -1; - final int rangeStart; - final int rangeEnd; - final int arity; - final int shift; - - ParametersUsage(MethodNode methodNode) { - super(ASM5); - arity = Type.getArgumentTypes(methodNode.desc).length; - boolean[] emptyParams = new boolean[arity]; - val1 = new ParamsValue(emptyParams, 1); - val2 = new ParamsValue(emptyParams, 2); - - shift = (methodNode.access & ACC_STATIC) == 0 ? 2 : 1; - rangeStart = shift; - rangeEnd = arity + shift; - } - - @Override - public ParamsValue newValue(Type type) { - if (type == null) return val1; - called++; - if (type == Type.VOID_TYPE) return null; - if (called < rangeEnd && rangeStart <= called) { - boolean[] params = new boolean[arity]; - params[called - shift] = true; - return type.getSize() == 1 ? new ParamsValue(params, 1) : new ParamsValue(params, 2); - } - else { - return type.getSize() == 1 ? val1 : val2; - } - } - - @Override - public ParamsValue newOperation(final AbstractInsnNode insn) { - int size; - switch (insn.getOpcode()) { - case LCONST_0: - case LCONST_1: - case DCONST_0: - case DCONST_1: - size = 2; - break; - case LDC: - Object cst = ((LdcInsnNode) insn).cst; - size = cst instanceof Long || cst instanceof Double ? 2 : 1; - break; - case GETSTATIC: - size = Type.getType(((FieldInsnNode) insn).desc).getSize(); - break; - default: - size = 1; - } - return size == 1 ? val1 : val2; - } - - @Override - public ParamsValue copyOperation(AbstractInsnNode insn, ParamsValue value) { - return value; - } - - @Override - public ParamsValue unaryOperation(AbstractInsnNode insn, ParamsValue value) { - int size; - switch (insn.getOpcode()) { - case CHECKCAST: - return new ParamsValue(value.params, Type.getObjectType(((TypeInsnNode)insn).desc).getSize()); - case LNEG: - case DNEG: - case I2L: - case I2D: - case L2D: - case F2L: - case F2D: - case D2L: - size = 2; - break; - case GETFIELD: - size = Type.getType(((FieldInsnNode) insn).desc).getSize(); - break; - default: - size = 1; - } - return size == 1 ? val1 : val2; - } - - @Override - public ParamsValue binaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2) { - int size; - switch (insn.getOpcode()) { - case LALOAD: - case DALOAD: - case LADD: - case DADD: - case LSUB: - case DSUB: - case LMUL: - case DMUL: - case LDIV: - case DDIV: - case LREM: - case DREM: - case LSHL: - case LSHR: - case LUSHR: - case LAND: - case LOR: - case LXOR: - size = 2; - break; - default: - size = 1; - } - return size == 1 ? val1 : val2; - } - - @Override - public ParamsValue ternaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2, ParamsValue value3) { - return val1; - } - - @Override - public ParamsValue naryOperation(AbstractInsnNode insn, List<? extends ParamsValue> values) { - int size; - int opcode = insn.getOpcode(); - if (opcode == MULTIANEWARRAY) { - size = 1; - } else { - String desc = (opcode == INVOKEDYNAMIC) ? ((InvokeDynamicInsnNode) insn).desc : ((MethodInsnNode) insn).desc; - size = Type.getReturnType(desc).getSize(); - } - return size == 1 ? val1 : val2; - } - - @Override - public void returnOperation(AbstractInsnNode insn, ParamsValue value, ParamsValue expected) {} - - @Override - public ParamsValue merge(ParamsValue v1, ParamsValue v2) { - if (v1.equals(v2)) return v1; - boolean[] params = new boolean[arity]; - boolean[] params1 = v1.params; - boolean[] params2 = v2.params; - for (int i = 0; i < arity; i++) { - params[i] = params1[i] || params2[i]; - } - return new ParamsValue(params, Math.min(v1.size, v2.size)); - } -} - -class LeakingParametersCollector extends ParametersUsage { - final boolean[] leaking; - LeakingParametersCollector(MethodNode methodNode) { - super(methodNode); - leaking = new boolean[arity]; - } - - @Override - public ParamsValue unaryOperation(AbstractInsnNode insn, ParamsValue value) { - switch (insn.getOpcode()) { - case GETFIELD: - case ARRAYLENGTH: - case MONITORENTER: - case INSTANCEOF: - case IRETURN: - case ARETURN: - case IFNONNULL: - case IFNULL: - case IFEQ: - case IFNE: - boolean[] params = value.params; - for (int i = 0; i < arity; i++) { - leaking[i] |= params[i]; - } - break; - default: - } - return super.unaryOperation(insn, value); - } - - @Override - public ParamsValue binaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2) { - switch (insn.getOpcode()) { - case IALOAD: - case LALOAD: - case FALOAD: - case DALOAD: - case AALOAD: - case BALOAD: - case CALOAD: - case SALOAD: - case PUTFIELD: - boolean[] params = value1.params; - for (int i = 0; i < arity; i++) { - leaking[i] |= params[i]; - } - break; - default: - } - return super.binaryOperation(insn, value1, value2); - } - - @Override - public ParamsValue ternaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2, ParamsValue value3) { - switch (insn.getOpcode()) { - case IASTORE: - case LASTORE: - case FASTORE: - case DASTORE: - case AASTORE: - case BASTORE: - case CASTORE: - case SASTORE: - boolean[] params = value1.params; - for (int i = 0; i < arity; i++) { - leaking[i] |= params[i]; - } - break; - default: - } - return super.ternaryOperation(insn, value1, value2, value3); - } - - @Override - public ParamsValue naryOperation(AbstractInsnNode insn, List<? extends ParamsValue> values) { - switch (insn.getOpcode()) { - case INVOKESTATIC: - case INVOKESPECIAL: - case INVOKEVIRTUAL: - case INVOKEINTERFACE: - for (ParamsValue value : values) { - boolean[] params = value.params; - for (int i = 0; i < arity; i++) { - leaking[i] |= params[i]; - } - } - break; - default: - } - return super.naryOperation(insn, values); - } -} - -/** - * Specialized lite version of {@link org.jetbrains.org.objectweb.asm.tree.analysis.Analyzer}. - * Calculation of fix-point of frames is removed, since frames are not needed to build control flow graph. - * So, the main point here is handling of subroutines (jsr) and try-catch-finally blocks. - */ -class CfgAnalyzer implements Opcodes { - static class Subroutine { - - LabelNode start; - - boolean[] access; - - List<JumpInsnNode> callers; - - private Subroutine() { - } - - Subroutine(final LabelNode start, final int maxLocals, - final JumpInsnNode caller) { - this.start = start; - this.access = new boolean[maxLocals]; - this.callers = new ArrayList<JumpInsnNode>(); - callers.add(caller); - } - - public Subroutine copy() { - Subroutine result = new Subroutine(); - result.start = start; - result.access = new boolean[access.length]; - System.arraycopy(access, 0, result.access, 0, access.length); - result.callers = new ArrayList<JumpInsnNode>(callers); - return result; - } - - public boolean merge(final Subroutine subroutine) throws AnalyzerException { - boolean changes = false; - for (int i = 0; i < access.length; ++i) { - if (subroutine.access[i] && !access[i]) { - access[i] = true; - changes = true; - } - } - if (subroutine.start == start) { - for (int i = 0; i < subroutine.callers.size(); ++i) { - JumpInsnNode caller = subroutine.callers.get(i); - if (!callers.contains(caller)) { - callers.add(caller); - changes = true; - } - } - } - return changes; - } - } - private int n; - private InsnList insns; - private List<TryCatchBlockNode>[] handlers; - private Subroutine[] subroutines; - private boolean[] wasQueued; - private boolean[] queued; - private int[] queue; - private int top; - - public void analyze(final MethodNode m) throws AnalyzerException { - n = m.instructions.size(); - insns = m.instructions; - handlers = (List<TryCatchBlockNode>[]) new List<?>[n]; - subroutines = new Subroutine[n]; - queued = new boolean[n]; - wasQueued = new boolean[n]; - queue = new int[n]; - top = 0; - - // computes exception handlers for each instruction - for (int i = 0; i < m.tryCatchBlocks.size(); ++i) { - TryCatchBlockNode tcb = m.tryCatchBlocks.get(i); - int begin = insns.indexOf(tcb.start); - int end = insns.indexOf(tcb.end); - for (int j = begin; j < end; ++j) { - List<TryCatchBlockNode> insnHandlers = handlers[j]; - if (insnHandlers == null) { - insnHandlers = new ArrayList<TryCatchBlockNode>(); - handlers[j] = insnHandlers; - } - insnHandlers.add(tcb); - } - } - - // computes the subroutine for each instruction: - Subroutine main = new Subroutine(null, m.maxLocals, null); - List<AbstractInsnNode> subroutineCalls = new ArrayList<AbstractInsnNode>(); - Map<LabelNode, Subroutine> subroutineHeads = new HashMap<LabelNode, Subroutine>(); - - findSubroutine(0, main, subroutineCalls); - while (!subroutineCalls.isEmpty()) { - JumpInsnNode jsr = (JumpInsnNode) subroutineCalls.remove(0); - Subroutine sub = subroutineHeads.get(jsr.label); - if (sub == null) { - sub = new Subroutine(jsr.label, m.maxLocals, jsr); - subroutineHeads.put(jsr.label, sub); - findSubroutine(insns.indexOf(jsr.label), sub, subroutineCalls); - } else { - sub.callers.add(jsr); - } - } - for (int i = 0; i < n; ++i) { - if (subroutines[i] != null && subroutines[i].start == null) { - subroutines[i] = null; - } - } - - merge(0, null); - // control flow analysis - while (top > 0) { - int insn = queue[--top]; - Subroutine subroutine = subroutines[insn]; - queued[insn] = false; - - AbstractInsnNode insnNode = null; - try { - insnNode = m.instructions.get(insn); - int insnOpcode = insnNode.getOpcode(); - int insnType = insnNode.getType(); - - if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) { - merge(insn + 1, subroutine); - newControlFlowEdge(insn, insn + 1); - } else { - subroutine = subroutine == null ? null : subroutine.copy(); - - if (insnNode instanceof JumpInsnNode) { - JumpInsnNode j = (JumpInsnNode) insnNode; - if (insnOpcode != GOTO && insnOpcode != JSR) { - merge(insn + 1, subroutine); - newControlFlowEdge(insn, insn + 1); - } - int jump = insns.indexOf(j.label); - if (insnOpcode == JSR) { - merge(jump, new Subroutine(j.label, m.maxLocals, j)); - } else { - merge(jump, subroutine); - } - newControlFlowEdge(insn, jump); - } else if (insnNode instanceof LookupSwitchInsnNode) { - LookupSwitchInsnNode lsi = (LookupSwitchInsnNode) insnNode; - int jump = insns.indexOf(lsi.dflt); - merge(jump, subroutine); - newControlFlowEdge(insn, jump); - for (int j = 0; j < lsi.labels.size(); ++j) { - LabelNode label = lsi.labels.get(j); - jump = insns.indexOf(label); - merge(jump, subroutine); - newControlFlowEdge(insn, jump); - } - } else if (insnNode instanceof TableSwitchInsnNode) { - TableSwitchInsnNode tsi = (TableSwitchInsnNode) insnNode; - int jump = insns.indexOf(tsi.dflt); - merge(jump, subroutine); - newControlFlowEdge(insn, jump); - for (int j = 0; j < tsi.labels.size(); ++j) { - LabelNode label = tsi.labels.get(j); - jump = insns.indexOf(label); - merge(jump, subroutine); - newControlFlowEdge(insn, jump); - } - } else if (insnOpcode == RET) { - if (subroutine == null) { - throw new AnalyzerException(insnNode, "RET instruction outside of a sub routine"); - } - for (int i = 0; i < subroutine.callers.size(); ++i) { - JumpInsnNode caller = subroutine.callers.get(i); - int call = insns.indexOf(caller); - if (wasQueued[call]) { - merge(call + 1, subroutines[call], subroutine.access); - newControlFlowEdge(insn, call + 1); - } - } - } else if (insnOpcode != ATHROW && (insnOpcode < IRETURN || insnOpcode > RETURN)) { - if (subroutine != null) { - if (insnNode instanceof VarInsnNode) { - int var = ((VarInsnNode) insnNode).var; - subroutine.access[var] = true; - if (insnOpcode == LLOAD || insnOpcode == DLOAD - || insnOpcode == LSTORE - || insnOpcode == DSTORE) { - subroutine.access[var + 1] = true; - } - } else if (insnNode instanceof IincInsnNode) { - int var = ((IincInsnNode) insnNode).var; - subroutine.access[var] = true; - } - } - merge(insn + 1, subroutine); - newControlFlowEdge(insn, insn + 1); - } - } - - List<TryCatchBlockNode> insnHandlers = handlers[insn]; - if (insnHandlers != null) { - for (TryCatchBlockNode tcb : insnHandlers) { - newControlFlowExceptionEdge(insn, tcb); - merge(insns.indexOf(tcb.handler), subroutine); - } - } - } catch (AnalyzerException e) { - throw new AnalyzerException(e.node, "Error at instruction " - + insn + ": " + e.getMessage(), e); - } catch (Exception e) { - throw new AnalyzerException(insnNode, "Error at instruction " - + insn + ": " + e.getMessage(), e); - } - } - } - - private void findSubroutine(int insn, final Subroutine sub, - final List<AbstractInsnNode> calls) throws AnalyzerException { - while (true) { - if (insn < 0 || insn >= n) { - throw new AnalyzerException(null, "Execution can fall off end of the code"); - } - if (subroutines[insn] != null) { - return; - } - subroutines[insn] = sub.copy(); - AbstractInsnNode node = insns.get(insn); - - // calls findSubroutine recursively on normal successors - if (node instanceof JumpInsnNode) { - if (node.getOpcode() == JSR) { - // do not follow a JSR, it leads to another subroutine! - calls.add(node); - } else { - JumpInsnNode jnode = (JumpInsnNode) node; - findSubroutine(insns.indexOf(jnode.label), sub, calls); - } - } else if (node instanceof TableSwitchInsnNode) { - TableSwitchInsnNode tsnode = (TableSwitchInsnNode) node; - findSubroutine(insns.indexOf(tsnode.dflt), sub, calls); - for (int i = tsnode.labels.size() - 1; i >= 0; --i) { - LabelNode l = tsnode.labels.get(i); - findSubroutine(insns.indexOf(l), sub, calls); - } - } else if (node instanceof LookupSwitchInsnNode) { - LookupSwitchInsnNode lsnode = (LookupSwitchInsnNode) node; - findSubroutine(insns.indexOf(lsnode.dflt), sub, calls); - for (int i = lsnode.labels.size() - 1; i >= 0; --i) { - LabelNode l = lsnode.labels.get(i); - findSubroutine(insns.indexOf(l), sub, calls); - } - } - - // calls findSubroutine recursively on exception handler successors - List<TryCatchBlockNode> insnHandlers = handlers[insn]; - if (insnHandlers != null) { - for (int i = 0; i < insnHandlers.size(); ++i) { - TryCatchBlockNode tcb = insnHandlers.get(i); - findSubroutine(insns.indexOf(tcb.handler), sub, calls); - } - } - - // if insn does not falls through to the next instruction, return. - switch (node.getOpcode()) { - case GOTO: - case RET: - case TABLESWITCH: - case LOOKUPSWITCH: - case IRETURN: - case LRETURN: - case FRETURN: - case DRETURN: - case ARETURN: - case RETURN: - case ATHROW: - return; - } - insn++; - } - } - - protected void newControlFlowEdge(final int insn, final int successor) {} - - protected boolean newControlFlowExceptionEdge(final int insn, - final int successor) { - return true; - } - - protected boolean newControlFlowExceptionEdge(final int insn, - final TryCatchBlockNode tcb) { - return newControlFlowExceptionEdge(insn, insns.indexOf(tcb.handler)); - } - - // ------------------------------------------------------------------------- - - private void merge(final int insn, final Subroutine subroutine) throws AnalyzerException { - Subroutine oldSubroutine = subroutines[insn]; - boolean changes = false; - - if (!wasQueued[insn]) { - wasQueued[insn] = true; - changes = true; - } - - if (oldSubroutine == null) { - if (subroutine != null) { - subroutines[insn] = subroutine.copy(); - changes = true; - } - } else { - if (subroutine != null) { - changes |= oldSubroutine.merge(subroutine); - } - } - if (changes && !queued[insn]) { - queued[insn] = true; - queue[top++] = insn; - } - } - - private void merge(final int insn, final Subroutine subroutineBeforeJSR, final boolean[] access) throws AnalyzerException { - Subroutine oldSubroutine = subroutines[insn]; - boolean changes = false; - - if (!wasQueued[insn]) { - wasQueued[insn] = true; - changes = true; - } - - if (oldSubroutine != null && subroutineBeforeJSR != null) { - changes |= oldSubroutine.merge(subroutineBeforeJSR); - } - if (changes && !queued[insn]) { - queued[insn] = true; - queue[top++] = insn; - } - } -} - diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Data.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Data.java index 132c5643b2d6..55a842af684c 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Data.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Data.java @@ -52,20 +52,17 @@ enum Value { Bot, NotNull, Null, True, False, Top } -interface Direction { - static final int OUT_DIRECTION = 0; - static final int IN_DIRECTION = 1; - static final int INOUT_DIRECTION = 2; - int directionId(); - int paramId(); - int valueId(); -} +interface Direction {} final class In implements Direction { + static final int NOT_NULL = 0; + static final int NULLABLE = 1; final int paramIndex; + final int nullityMask; - In(int paramIndex) { + In(int paramIndex, int nullityMask) { this.paramIndex = paramIndex; + this.nullityMask = nullityMask; } @Override @@ -79,28 +76,19 @@ final class In implements Direction { if (o == null || getClass() != o.getClass()) return false; In in = (In) o; if (paramIndex != in.paramIndex) return false; + if (nullityMask != in.nullityMask) return false; return true; } @Override public int hashCode() { - return paramIndex; + return 31*paramIndex + nullityMask; } - @Override - public int directionId() { - return IN_DIRECTION; - } - - @Override public int paramId() { return paramIndex; } - @Override - public int valueId() { - return 0; - } } final class InOut implements Direction { @@ -137,17 +125,10 @@ final class InOut implements Direction { return "InOut " + paramIndex + " " + inValue.toString(); } - @Override - public int directionId() { - return INOUT_DIRECTION; - } - - @Override public int paramId() { return paramIndex; } - @Override public int valueId() { return inValue.ordinal(); } @@ -168,21 +149,6 @@ final class Out implements Direction { public boolean equals(Object obj) { return obj instanceof Out; } - - @Override - public int directionId() { - return OUT_DIRECTION; - } - - @Override - public int paramId() { - return 0; - } - - @Override - public int valueId() { - return 0; - } } final class Key { @@ -219,8 +185,6 @@ final class Key { @Override public String toString() { - return "" + method + ' ' + direction + ' ' + stable; + return method + " " + direction + " " + stable; } } - - diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/HData.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/HData.java new file mode 100644 index 000000000000..7c938347ccb9 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/HData.java @@ -0,0 +1,311 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis; + +import org.jetbrains.annotations.NotNull; + +import java.util.Arrays; +import java.util.List; + +/** + * Small size key, constructed by hashing method signature. + * @see com.intellij.codeInspection.bytecodeAnalysis.BytecodeAnalysisConverter for details of construction. + */ +final class HKey { + @NotNull + final byte[] key; + final int dirKey; + final boolean stable; + + HKey(@NotNull byte[] key, int dirKey, boolean stable) { + this.key = key; + this.dirKey = dirKey; + this.stable = stable; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + HKey hKey = (HKey)o; + if (dirKey != hKey.dirKey) return false; + if (stable != hKey.stable) return false; + if (!Arrays.equals(key, hKey.key)) return false; + return true; + } + + @Override + public int hashCode() { + int result = Arrays.hashCode(key); + result = 31 * result + dirKey; + result = 31 * result + (stable ? 1 : 0); + return result; + } + + HKey negate() { + return new HKey(key, dirKey, !stable); + } + + HKey mkStable() { + return stable ? this : new HKey(key, dirKey, true); + } + + HKey mkUnstable() { + return stable ? new HKey(key, dirKey, false) : this; + } + + public HKey mkBase() { + return dirKey == 0 ? this : new HKey(key, 0, stable); + } + + HKey updateDirection(int newDirKey) { + return new HKey(key, newDirKey, stable); + } +} + +final class HComponent { + @NotNull Value value; + @NotNull final HKey[] ids; + + HComponent(@NotNull Value value, @NotNull HKey[] ids) { + this.value = value; + this.ids = ids; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + HComponent that = (HComponent)o; + + if (!Arrays.equals(ids, that.ids)) return false; + if (value != that.value) return false; + + return true; + } + + @Override + public int hashCode() { + int result = value.hashCode(); + result = 31 * result + Arrays.hashCode(ids); + return result; + } + + public boolean remove(@NotNull HKey id) { + return HUtils.remove(ids, id); + } + + public boolean isEmpty() { + return HUtils.isEmpty(ids); + } + + @NotNull + public HComponent copy() { + return new HComponent(value, ids.clone()); + } +} + +class HUtils { + + static boolean isEmpty(HKey[] ids) { + for (HKey id : ids) { + if (id != null) return false; + } + return true; + } + + static boolean remove(HKey[] ids, @NotNull HKey id) { + boolean removed = false; + for (int i = 0; i < ids.length; i++) { + if (id.equals(ids[i])) { + ids[i] = null; + removed = true; + } + } + return removed; + } +} + +final class HEquation { + @NotNull final HKey key; + @NotNull final HResult result; + + HEquation(@NotNull HKey key, @NotNull HResult result) { + this.key = key; + this.result = result; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + HEquation hEquation = (HEquation)o; + if (!key.equals(hEquation.key)) return false; + if (!result.equals(hEquation.result)) return false; + return true; + } + + @Override + public int hashCode() { + int result1 = key.hashCode(); + result1 = 31 * result1 + result.hashCode(); + return result1; + } +} +class Bytes { + @NotNull + final byte[] bytes; + Bytes(@NotNull byte[] bytes) { + this.bytes = bytes; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Bytes bytes1 = (Bytes)o; + + if (!Arrays.equals(bytes, bytes1.bytes)) return false; + + return true; + } + + @Override + public int hashCode() { + return Arrays.hashCode(bytes); + } +} + +class HEquations { + @NotNull final List<DirectionResultPair> results; + final boolean stable; + + HEquations(@NotNull List<DirectionResultPair> results, boolean stable) { + this.results = results; + this.stable = stable; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + HEquations that = (HEquations)o; + + if (stable != that.stable) return false; + if (!results.equals(that.results)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = results.hashCode(); + result = 31 * result + (stable ? 1 : 0); + return result; + } +} + +class DirectionResultPair { + final int directionKey; + @NotNull + final HResult hResult; + + DirectionResultPair(int directionKey, @NotNull HResult hResult) { + this.directionKey = directionKey; + this.hResult = hResult; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + DirectionResultPair that = (DirectionResultPair)o; + + if (directionKey != that.directionKey) return false; + if (!hResult.equals(that.hResult)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = directionKey; + result = 31 * result + hResult.hashCode(); + return result; + } +} + +interface HResult {} +final class HFinal implements HResult { + @NotNull final Value value; + + HFinal(@NotNull Value value) { + this.value = value; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + HFinal hFinal = (HFinal)o; + + if (value != hFinal.value) return false; + + return true; + } + + @Override + public int hashCode() { + return value.ordinal(); + } +} + +final class HPending implements HResult { + @NotNull final HComponent[] delta; + + HPending(@NotNull HComponent[] delta) { + this.delta = delta; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + HPending hPending = (HPending)o; + if (!Arrays.equals(delta, hPending.delta)) return false; + return true; + } + + @Override + public int hashCode() { + return Arrays.hashCode(delta); + } + + @NotNull + HPending copy() { + HComponent[] delta1 = new HComponent[delta.length]; + for (int i = 0; i < delta.length; i++) { + delta1[i] = delta[i].copy(); + + } + return new HPending(delta1); + } +}
\ No newline at end of file diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Parameters.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Parameters.java index 625eb8eed977..a7c25782d48b 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Parameters.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Parameters.java @@ -15,6 +15,10 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ASMUtils; +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph.Edge; +import com.intellij.codeInspection.bytecodeAnalysis.asm.RichControlFlow; +import org.jetbrains.annotations.NotNull; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode; import org.jetbrains.org.objectweb.asm.tree.JumpInsnNode; @@ -25,7 +29,9 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter; import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue; import org.jetbrains.org.objectweb.asm.tree.analysis.Frame; -import java.util.*; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import static com.intellij.codeInspection.bytecodeAnalysis.AbstractValues.InstanceOfCheckValue; import static com.intellij.codeInspection.bytecodeAnalysis.AbstractValues.ParamValue; @@ -101,6 +107,18 @@ abstract class PResults { } } + static PResult combineNullable(PResult r1, PResult r2) throws AnalyzerException { + if (Identity == r1) return r2; + if (Identity == r2) return r1; + if (Return == r1) return r2; + if (Return == r2) return r1; + if (NPE == r1) return NPE; + if (NPE == r2) return NPE; + ConditionalNPE cnpe1 = (ConditionalNPE) r1; + ConditionalNPE cnpe2 = (ConditionalNPE) r2; + return new ConditionalNPE(join(cnpe1.sop, cnpe2.sop)); + } + static PResult join(PResult r1, PResult r2) throws AnalyzerException { if (Identity == r1) return r2; if (Identity == r2) return r1; @@ -127,34 +145,62 @@ abstract class PResults { } +interface PendingAction {} +class ProceedState implements PendingAction { + final State state; + + ProceedState(State state) { + this.state = state; + } +} +class MakeResult implements PendingAction { + final State state; + final PResult subResult; + final int[] indices; + + MakeResult(State state, PResult subResult, int[] indices) { + this.state = state; + this.subResult = subResult; + this.indices = indices; + } +} + class NonNullInAnalysis extends Analysis<PResult> { + private static final ThreadLocal<PendingAction[]> ourPending = new ThreadLocal<PendingAction[]>() { + @Override + protected PendingAction[] initialValue() { + return new PendingAction[Analysis.STEPS_LIMIT]; + } + }; + private static final ThreadLocal<PResult[]> ourResults = new ThreadLocal<PResult[]>() { + @Override + protected PResult[] initialValue() { + return new PResult[Analysis.STEPS_LIMIT]; + } + }; + + final private PendingAction[] pending = ourPending.get(); - private final NonNullInInterpreter interpreter = new NonNullInInterpreter(); + private final NotNullInterpreter interpreter = new NotNullInterpreter(); + private PResult[] results; + + // Flag saying that at some branch NPE was found. Used later as an evidence that this param is *NOT* @Nullable (optimization). + boolean possibleNPE; protected NonNullInAnalysis(RichControlFlow richControlFlow, Direction direction, boolean stable) { super(richControlFlow, direction, stable); + results = ourResults.get(); } - @Override - PResult identity() { - return Identity; - } - - @Override - PResult combineResults(PResult delta, List<PResult> subResults) throws AnalyzerException { - PResult subResult = Identity; - for (PResult sr : subResults) { - subResult = join(subResult, sr); + PResult combineResults(PResult delta, int[] subResults) throws AnalyzerException { + PResult result = Identity; + for (int subResult : subResults) { + result = join(result, results[subResult]); } - return meet(delta, subResult); + return meet(delta, result); } - @Override - boolean isEarlyResult(PResult result) { - return false; - } - - @Override + @NotNull Equation<Key, Value> mkEquation(PResult result) { if (Identity == result || Return == result) { return new Equation<Key, Value>(aKey, new Final<Key, Value>(Value.Top)); @@ -176,8 +222,73 @@ class NonNullInAnalysis extends Analysis<PResult> { private Frame<BasicValue> nextFrame = null; private PResult subResult = null; - @Override - void processState(State state) throws AnalyzerException { + @NotNull + protected Equation<Key, Value> analyze() throws AnalyzerException { + pendingPush(new ProceedState(createStartState())); + int steps = 0; + while (pendingTop > 0 && earlyResult == null) { + steps ++; + if (steps >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached, steps: " + steps + " in method " + method); + } + PendingAction action = pending[--pendingTop]; + if (action instanceof MakeResult) { + MakeResult makeResult = (MakeResult) action; + PResult result = combineResults(makeResult.subResult, makeResult.indices); + State state = makeResult.state; + int insnIndex = state.conf.insnIndex; + results[state.index] = result; + addComputed(insnIndex, state); + } + else if (action instanceof ProceedState) { + ProceedState proceedState = (ProceedState) action; + State state = proceedState.state; + int insnIndex = state.conf.insnIndex; + Conf conf = state.conf; + List<Conf> history = state.history; + + boolean fold = false; + if (dfsTree.loopEnters[insnIndex]) { + for (Conf prev : history) { + if (AbstractValues.isInstance(conf, prev)) { + fold = true; + break; + } + } + } + if (fold) { + results[state.index] = Identity; + addComputed(insnIndex, state); + } + else { + State baseState = null; + List<State> thisComputed = computed[insnIndex]; + if (thisComputed != null) { + for (State prevState : thisComputed) { + if (stateEquiv(state, prevState)) { + baseState = prevState; + break; + } + } + } + if (baseState != null) { + results[state.index] = results[baseState.index]; + } else { + // the main call + processState(state); + } + + } + } + } + if (earlyResult != null) { + return mkEquation(earlyResult); + } else { + return mkEquation(results[0]); + } + } + + private void processState(State state) throws AnalyzerException { int stateIndex = state.index; Conf conf = state.conf; int insnIndex = conf.insnIndex; @@ -185,15 +296,16 @@ class NonNullInAnalysis extends Analysis<PResult> { boolean taken = state.taken; Frame<BasicValue> frame = conf.frame; AbstractInsnNode insnNode = methodNode.instructions.get(insnIndex); - List<Conf> nextHistory = dfsTree.loopEnters.contains(insnIndex) ? append(history, conf) : history; + List<Conf> nextHistory = dfsTree.loopEnters[insnIndex] ? append(history, conf) : history; boolean hasCompanions = state.hasCompanions; execute(frame, insnNode); boolean notEmptySubResult = subResult != Identity; if (subResult == NPE) { - results.put(stateIndex, NPE); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + results[stateIndex] = NPE; + possibleNPE = true; + addComputed(insnIndex, state); return; } @@ -208,8 +320,8 @@ class NonNullInAnalysis extends Analysis<PResult> { if (!hasCompanions) { earlyResult = Return; } else { - results.put(stateIndex, Return); - computed.put(insnIndex, append(computed.get(insnIndex), state)); + results[stateIndex] = Return; + addComputed(insnIndex, state); } return; default: @@ -217,70 +329,265 @@ class NonNullInAnalysis extends Analysis<PResult> { if (opcode == ATHROW) { if (taken) { - results.put(stateIndex, NPE); + results[stateIndex] = NPE; + possibleNPE = true; } else { - results.put(stateIndex, Identity); + results[stateIndex] = Identity; } - computed.put(insnIndex, append(computed.get(insnIndex), state)); + addComputed(insnIndex, state); return; } if (opcode == IFNONNULL && popValue(frame) instanceof ParamValue) { int nextInsnIndex = insnIndex + 1; State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, hasCompanions || notEmptySubResult); - pending.push(new MakeResult<PResult>(state, subResult, new int[]{nextState.index})); - pending.push(new ProceedState<PResult>(nextState)); + pendingPush(new MakeResult(state, subResult, new int[]{nextState.index})); + pendingPush(new ProceedState(nextState)); return; } if (opcode == IFNULL && popValue(frame) instanceof ParamValue) { int nextInsnIndex = methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, hasCompanions || notEmptySubResult); - pending.push(new MakeResult<PResult>(state, subResult, new int[]{nextState.index})); - pending.push(new ProceedState<PResult>(nextState)); + pendingPush(new MakeResult(state, subResult, new int[]{nextState.index})); + pendingPush(new ProceedState(nextState)); return; } if (opcode == IFEQ && popValue(frame) == InstanceOfCheckValue) { int nextInsnIndex = methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, hasCompanions || notEmptySubResult); - pending.push(new MakeResult<PResult>(state, subResult, new int[]{nextState.index})); - pending.push(new ProceedState<PResult>(nextState)); + pendingPush(new MakeResult(state, subResult, new int[]{nextState.index})); + pendingPush(new ProceedState(nextState)); return; } if (opcode == IFNE && popValue(frame) == InstanceOfCheckValue) { int nextInsnIndex = insnIndex + 1; State nextState = new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, hasCompanions || notEmptySubResult); - pending.push(new MakeResult<PResult>(state, subResult, new int[]{nextState.index})); - pending.push(new ProceedState<PResult>(nextState)); + pendingPush(new MakeResult(state, subResult, new int[]{nextState.index})); + pendingPush(new ProceedState(nextState)); return; } // general case int[] nextInsnIndices = controlFlow.transitions[insnIndex]; - List<State> nextStates = new ArrayList<State>(nextInsnIndices.length); int[] subIndices = new int[nextInsnIndices.length]; - + for (int i = 0; i < nextInsnIndices.length; i++) { + subIndices[i] = ++id; + } + pendingPush(new MakeResult(state, subResult, subIndices)); for (int i = 0; i < nextInsnIndices.length; i++) { int nextInsnIndex = nextInsnIndices[i]; Frame<BasicValue> nextFrame1 = nextFrame; - if (controlFlow.errorTransitions.contains(new Edge(insnIndex, nextInsnIndex))) { + if (controlFlow.errors[nextInsnIndex] && controlFlow.errorTransitions.contains(new Edge(insnIndex, nextInsnIndex))) { nextFrame1 = new Frame<BasicValue>(frame); nextFrame1.clearStack(); - nextFrame1.push(new BasicValue(Type.getType("java/lang/Throwable"))); + nextFrame1.push(ASMUtils.THROWABLE_VALUE); + } + pendingPush(new ProceedState(new State(subIndices[i], new Conf(nextInsnIndex, nextFrame1), nextHistory, taken, hasCompanions || notEmptySubResult))); + } + + } + + private int pendingTop = 0; + + private void pendingPush(PendingAction action) throws AnalyzerException { + if (pendingTop >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached in method " + method); + } + pending[pendingTop++] = action; + } + + private void execute(Frame<BasicValue> frame, AbstractInsnNode insnNode) throws AnalyzerException { + switch (insnNode.getType()) { + case AbstractInsnNode.LABEL: + case AbstractInsnNode.LINE: + case AbstractInsnNode.FRAME: + nextFrame = frame; + subResult = Identity; + break; + default: + nextFrame = new Frame<BasicValue>(frame); + interpreter.reset(); + nextFrame.execute(insnNode, interpreter); + subResult = interpreter.getSubResult(); + } + } +} + +class NullableInAnalysis extends Analysis<PResult> { + final private State[] pending = ourPendingStates.get(); + + private final NullableInterpreter interpreter = new NullableInterpreter(); + + protected NullableInAnalysis(RichControlFlow richControlFlow, Direction direction, boolean stable) { + super(richControlFlow, direction, stable); + } + + @NotNull + Equation<Key, Value> mkEquation(PResult result) { + if (NPE == result) { + return new Equation<Key, Value>(aKey, new Final<Key, Value>(Value.Top)); + } + if (Identity == result || Return == result) { + return new Equation<Key, Value>(aKey, new Final<Key, Value>(Value.Null)); + } + else { + ConditionalNPE condNpe = (ConditionalNPE) result; + Set<Product<Key, Value>> components = new HashSet<Product<Key, Value>>(); + for (Set<Key> prod : condNpe.sop) { + components.add(new Product<Key, Value>(Value.Top, prod)); + } + return new Equation<Key, Value>(aKey, new Pending<Key, Value>(components)); + } + } + + private int id = 0; + private Frame<BasicValue> nextFrame = null; + private PResult myResult = Identity; + private PResult subResult = Identity; + private boolean top = false; + + @NotNull + protected Equation<Key, Value> analyze() throws AnalyzerException { + pendingPush(createStartState()); + int steps = 0; + while (pendingTop > 0 && earlyResult == null) { + steps ++; + if (steps >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached, steps: " + steps + " in method " + method); + } + State state = pending[--pendingTop]; + int insnIndex = state.conf.insnIndex; + Conf conf = state.conf; + List<Conf> history = state.history; + + boolean fold = false; + if (dfsTree.loopEnters[insnIndex]) { + for (Conf prev : history) { + if (AbstractValues.isInstance(conf, prev)) { + fold = true; + break; + } + } + } + if (fold) { + addComputed(insnIndex, state); + } + else { + State baseState = null; + List<State> thisComputed = computed[insnIndex]; + if (thisComputed != null) { + for (State prevState : thisComputed) { + if (stateEquiv(state, prevState)) { + baseState = prevState; + break; + } + } + } + if (baseState == null) { + processState(state); + } } - nextStates.add(new State(++id, new Conf(nextInsnIndex, nextFrame1), nextHistory, taken, hasCompanions || notEmptySubResult)); - subIndices[i] = (id); + } + if (earlyResult != null) { + return mkEquation(earlyResult); + } else { + return mkEquation(myResult); + } + } + + private void processState(State state) throws AnalyzerException { + Conf conf = state.conf; + int insnIndex = conf.insnIndex; + List<Conf> history = state.history; + boolean taken = state.taken; + Frame<BasicValue> frame = conf.frame; + AbstractInsnNode insnNode = methodNode.instructions.get(insnIndex); + List<Conf> nextHistory = dfsTree.loopEnters[insnIndex] ? append(history, conf) : history; + + addComputed(insnIndex, state); + execute(frame, insnNode); + + if (subResult == NPE || top) { + earlyResult = NPE; + return; + } + + if (subResult instanceof ConditionalNPE) { + myResult = combineNullable(myResult, subResult); + } + + int opcode = insnNode.getOpcode(); + switch (opcode) { + case ARETURN: + if (popValue(frame) instanceof ParamValue) { + earlyResult = NPE; + } + return; + case IRETURN: + case LRETURN: + case FRETURN: + case DRETURN: + case RETURN: + return; + default: + } + + if (opcode == ATHROW) { + if (taken) { + earlyResult = NPE; + } + return; + } + + if (opcode == IFNONNULL && popValue(frame) instanceof ParamValue) { + int nextInsnIndex = insnIndex + 1; + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false)); + return; + } + + if (opcode == IFNULL && popValue(frame) instanceof ParamValue) { + int nextInsnIndex = methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false)); + return; + } + + if (opcode == IFEQ && popValue(frame) == InstanceOfCheckValue) { + int nextInsnIndex = methodNode.instructions.indexOf(((JumpInsnNode)insnNode).label); + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false)); + return; } - pending.push(new MakeResult<PResult>(state, subResult, subIndices)); - for (State nextState : nextStates) { - pending.push(new ProceedState<PResult>(nextState)); + if (opcode == IFNE && popValue(frame) == InstanceOfCheckValue) { + int nextInsnIndex = insnIndex + 1; + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame), nextHistory, true, false)); + return; + } + + // general case + for (int nextInsnIndex : controlFlow.transitions[insnIndex]) { + Frame<BasicValue> nextFrame1 = nextFrame; + if (controlFlow.errors[nextInsnIndex] && controlFlow.errorTransitions.contains(new Edge(insnIndex, nextInsnIndex))) { + nextFrame1 = new Frame<BasicValue>(frame); + nextFrame1.clearStack(); + nextFrame1.push(ASMUtils.THROWABLE_VALUE); + } + pendingPush(new State(++id, new Conf(nextInsnIndex, nextFrame1), nextHistory, taken, false)); } } + private int pendingTop = 0; + + private void pendingPush(State state) throws AnalyzerException { + if (pendingTop >= STEPS_LIMIT) { + throw new AnalyzerException(null, "limit is reached in method " + method); + } + pending[pendingTop++] = state; + } + private void execute(Frame<BasicValue> frame, AbstractInsnNode insnNode) throws AnalyzerException { switch (insnNode.getType()) { case AbstractInsnNode.LABEL: @@ -288,23 +595,37 @@ class NonNullInAnalysis extends Analysis<PResult> { case AbstractInsnNode.FRAME: nextFrame = frame; subResult = Identity; + top = false; break; default: nextFrame = new Frame<BasicValue>(frame); interpreter.reset(); nextFrame.execute(insnNode, interpreter); subResult = interpreter.getSubResult(); + top = interpreter.top; } } } -class NonNullInInterpreter extends BasicInterpreter { +abstract class NullityInterpreter extends BasicInterpreter { + boolean top = false; + final boolean nullableAnalysis; + final int nullityMask; private PResult subResult = Identity; + + NullityInterpreter(boolean nullableAnalysis, int nullityMask) { + this.nullableAnalysis = nullableAnalysis; + this.nullityMask = nullityMask; + } + + abstract PResult combine(PResult res1, PResult res2) throws AnalyzerException; + public PResult getSubResult() { return subResult; } void reset() { subResult = Identity; + top = false; } @Override @@ -344,10 +665,17 @@ class NonNullInInterpreter extends BasicInterpreter { case BALOAD: case CALOAD: case SALOAD: + if (value1 instanceof ParamValue) { + subResult = NPE; + } + break; case PUTFIELD: if (value1 instanceof ParamValue) { subResult = NPE; } + if (nullableAnalysis && value2 instanceof ParamValue) { + subResult = NPE; + } break; default: } @@ -361,13 +689,21 @@ class NonNullInInterpreter extends BasicInterpreter { case LASTORE: case FASTORE: case DASTORE: - case AASTORE: case BASTORE: case CASTORE: case SASTORE: if (value1 instanceof ParamValue) { subResult = NPE; } + break; + case AASTORE: + if (value1 instanceof ParamValue) { + subResult = NPE; + } + if (nullableAnalysis && value3 instanceof ParamValue) { + subResult = NPE; + } + break; default: } return super.ternaryOperation(insn, value1, value2, value3); @@ -382,20 +718,54 @@ class NonNullInInterpreter extends BasicInterpreter { subResult = NPE; } switch (opcode) { + case INVOKEINTERFACE: + if (nullableAnalysis) { + for (int i = shift; i < values.size(); i++) { + if (values.get(i) instanceof ParamValue) { + top = true; + return super.naryOperation(insn, values); + } + } + } + break; case INVOKESTATIC: case INVOKESPECIAL: case INVOKEVIRTUAL: - case INVOKEINTERFACE: boolean stable = opcode == INVOKESTATIC || opcode == INVOKESPECIAL; MethodInsnNode methodNode = (MethodInsnNode) insn; + Method method = new Method(methodNode.owner, methodNode.name, methodNode.desc); for (int i = shift; i < values.size(); i++) { if (values.get(i) instanceof ParamValue) { - Method method = new Method(methodNode.owner, methodNode.name, methodNode.desc); - subResult = meet(subResult, new ConditionalNPE(new Key(method, new In(i - shift), stable))); + subResult = combine(subResult, new ConditionalNPE(new Key(method, new In(i - shift, nullityMask), stable))); } } + break; default: } return super.naryOperation(insn, values); } } + +class NotNullInterpreter extends NullityInterpreter { + + NotNullInterpreter() { + super(false, In.NOT_NULL); + } + + @Override + PResult combine(PResult res1, PResult res2) throws AnalyzerException { + return meet(res1, res2); + } +} + +class NullableInterpreter extends NullityInterpreter { + + NullableInterpreter() { + super(true, In.NULLABLE); + } + + @Override + PResult combine(PResult res1, PResult res2) throws AnalyzerException { + return join(res1, res2); + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ProjectBytecodeAnalysis.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ProjectBytecodeAnalysis.java index 23d9d5a9e1c5..aa44951961ad 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ProjectBytecodeAnalysis.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/ProjectBytecodeAnalysis.java @@ -30,16 +30,14 @@ import com.intellij.psi.util.CachedValueProvider; import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.PsiFormatUtil; import com.intellij.util.IncorrectOperationException; -import com.intellij.util.containers.LongStack; +import com.intellij.util.containers.Stack; import com.intellij.util.indexing.FileBasedIndex; -import gnu.trove.TLongArrayList; -import gnu.trove.TLongHashSet; -import gnu.trove.TLongObjectHashMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.io.IOException; -import java.util.List; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.*; /** * @author lambdamix @@ -63,7 +61,7 @@ public class ProjectBytecodeAnalysis { if (!(listOwner instanceof PsiCompiledElement)) { return null; } - if (annotationFQN.equals(AnnotationUtil.NOT_NULL) || annotationFQN.equals(ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT)) { + if (annotationFQN.equals(AnnotationUtil.NOT_NULL) || annotationFQN.equals(AnnotationUtil.NULLABLE) || annotationFQN.equals(ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT)) { PsiAnnotation[] annotations = findInferredAnnotations(listOwner); for (PsiAnnotation annotation : annotations) { if (annotationFQN.equals(annotation.getQualifiedName())) { @@ -94,37 +92,45 @@ public class ProjectBytecodeAnalysis { @NotNull private PsiAnnotation[] collectInferredAnnotations(PsiModifierListOwner listOwner) { try { - long ownerKey = getKey(listOwner); - if (ownerKey == -1) { + MessageDigest md = BytecodeAnalysisConverter.getMessageDigest(); + HKey primaryKey = getKey(listOwner, md); + if (primaryKey == null) { return PsiAnnotation.EMPTY_ARRAY; } - TLongArrayList allKeys = contractKeys(listOwner, ownerKey); - Annotations annotations = loadAnnotations(listOwner, ownerKey, allKeys); - boolean notNull = annotations.notNulls.contains(ownerKey); - String contractValue = annotations.contracts.get(ownerKey); - - if (notNull && contractValue != null) { - return new PsiAnnotation[]{ - getNotNullAnnotation(), - createAnnotationFromText("@" + ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT + "(" + contractValue + ")") - }; - } - else if (notNull) { - return new PsiAnnotation[]{ - getNotNullAnnotation() - }; - } - else if (contractValue != null) { - return new PsiAnnotation[]{ - createAnnotationFromText("@" + ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT + "(" + contractValue + ")") - }; - } - else { - return PsiAnnotation.EMPTY_ARRAY; + if (listOwner instanceof PsiMethod) { + ArrayList<HKey> allKeys = contractKeys((PsiMethod)listOwner, primaryKey); + MethodAnnotations methodAnnotations = loadMethodAnnotations((PsiMethod)listOwner, primaryKey, allKeys); + boolean notNull = methodAnnotations.notNulls.contains(primaryKey); + String contractValue = methodAnnotations.contracts.get(primaryKey); + if (notNull && contractValue != null) { + return new PsiAnnotation[]{ + getNotNullAnnotation(), + createAnnotationFromText("@" + ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT + "(" + contractValue + ")") + }; + } + else if (notNull) { + return new PsiAnnotation[]{ + getNotNullAnnotation() + }; + } + else if (contractValue != null) { + return new PsiAnnotation[]{ + createAnnotationFromText("@" + ControlFlowAnalyzer.ORG_JETBRAINS_ANNOTATIONS_CONTRACT + "(" + contractValue + ")") + }; + } + } else if (listOwner instanceof PsiParameter) { + ParameterAnnotations parameterAnnotations = loadParameterAnnotations(primaryKey); + if (parameterAnnotations.notNull) { + return new PsiAnnotation[]{ + getNotNullAnnotation() + }; + } + else if (parameterAnnotations.nullable) { + return new PsiAnnotation[]{ + getNullableAnnotation() + }; + } } - } - catch (IOException e) { - LOG.debug(e); return PsiAnnotation.EMPTY_ARRAY; } catch (EquationsLimitException e) { @@ -132,6 +138,10 @@ public class ProjectBytecodeAnalysis { LOG.info("Too many equations for " + externalName); return PsiAnnotation.EMPTY_ARRAY; } + catch (NoSuchAlgorithmException e) { + LOG.error(e); + return PsiAnnotation.EMPTY_ARRAY; + } } private PsiAnnotation getNotNullAnnotation() { @@ -144,14 +154,25 @@ public class ProjectBytecodeAnalysis { }); } + private PsiAnnotation getNullableAnnotation() { + return CachedValuesManager.getManager(myProject).getCachedValue(myProject, new CachedValueProvider<PsiAnnotation>() { + @Nullable + @Override + public Result<PsiAnnotation> compute() { + return Result.create(createAnnotationFromText("@" + AnnotationUtil.NULLABLE), ModificationTracker.NEVER_CHANGED); + } + }); + } + public PsiAnnotation createContractAnnotation(String contractValue) { return createAnnotationFromText("@org.jetbrains.annotations.Contract(" + contractValue + ")"); } - public static long getKey(@NotNull PsiModifierListOwner owner) throws IOException { + @Nullable + public static HKey getKey(@NotNull PsiModifierListOwner owner, MessageDigest md) { LOG.assertTrue(owner instanceof PsiCompiledElement, owner); if (owner instanceof PsiMethod) { - return BytecodeAnalysisConverter.getInstance().mkPsiKey((PsiMethod)owner, new Out()); + return BytecodeAnalysisConverter.psiKey((PsiMethod)owner, new Out(), md); } if (owner instanceof PsiParameter) { PsiElement parent = owner.getParent(); @@ -159,80 +180,93 @@ public class ProjectBytecodeAnalysis { PsiElement gParent = parent.getParent(); if (gParent instanceof PsiMethod) { final int index = ((PsiParameterList)parent).getParameterIndex((PsiParameter)owner); - return BytecodeAnalysisConverter.getInstance().mkPsiKey((PsiMethod)gParent, new In(index)); + return BytecodeAnalysisConverter.psiKey((PsiMethod)gParent, new In(index, In.NOT_NULL), md); } } } - - return -1; + return null; } - public static TLongArrayList contractKeys(@NotNull PsiModifierListOwner owner, long primaryKey) throws IOException { - if (owner instanceof PsiMethod) { - TLongArrayList result = BytecodeAnalysisConverter.getInstance().mkInOutKeys((PsiMethod)owner, primaryKey); - result.add(primaryKey); - return result; - } - TLongArrayList result = new TLongArrayList(1); + public static ArrayList<HKey> contractKeys(@NotNull PsiMethod owner, HKey primaryKey) { + ArrayList<HKey> result = BytecodeAnalysisConverter.mkInOutKeys(owner, primaryKey); result.add(primaryKey); return result; } - private Annotations loadAnnotations(@NotNull PsiModifierListOwner owner, long key, TLongArrayList allKeys) - throws IOException, EquationsLimitException { - Annotations result = new Annotations(); - if (owner instanceof PsiParameter) { - final Solver solver = new Solver(new ELattice<Value>(Value.NotNull, Value.Top)); - collectEquations(allKeys, solver); - TLongObjectHashMap<Value> solutions = solver.solve(); - BytecodeAnalysisConverter.getInstance().addParameterAnnotations(solutions, result); - } else if (owner instanceof PsiMethod) { - final Solver solver = new Solver(new ELattice<Value>(Value.Bot, Value.Top)); - collectEquations(allKeys, solver); - TLongObjectHashMap<Value> solutions = solver.solve(); - BytecodeAnalysisConverter.getInstance().addMethodAnnotations(solutions, result, key, - ((PsiMethod)owner).getParameterList().getParameters().length); - } + private ParameterAnnotations loadParameterAnnotations(@NotNull HKey notNullKey) + throws EquationsLimitException { + + final Solver notNullSolver = new Solver(new ELattice<Value>(Value.NotNull, Value.Top)); + collectEquations(Collections.singletonList(notNullKey), notNullSolver); + + HashMap<HKey, Value> notNullSolutions = notNullSolver.solve(); + boolean notNull = + (Value.NotNull == notNullSolutions.get(notNullKey)) || (Value.NotNull == notNullSolutions.get(notNullKey.mkUnstable())); + + final Solver nullableSolver = new Solver(new ELattice<Value>(Value.Null, Value.Top)); + final HKey nullableKey = new HKey(notNullKey.key, notNullKey.dirKey + 1, true); + collectEquations(Collections.singletonList(nullableKey), nullableSolver); + HashMap<HKey, Value> nullableSolutions = nullableSolver.solve(); + boolean nullable = + (Value.Null == nullableSolutions.get(nullableKey)) || (Value.Null == nullableSolutions.get(nullableKey.mkUnstable())); + return new ParameterAnnotations(notNull, nullable); + } + + private MethodAnnotations loadMethodAnnotations(@NotNull PsiMethod owner, @NotNull HKey key, ArrayList<HKey> allKeys) + throws EquationsLimitException { + MethodAnnotations result = new MethodAnnotations(); + final Solver solver = new Solver(new ELattice<Value>(Value.Bot, Value.Top)); + collectEquations(allKeys, solver); + HashMap<HKey, Value> solutions = solver.solve(); + int arity = owner.getParameterList().getParameters().length; + BytecodeAnalysisConverter.addMethodAnnotations(solutions, result, key, arity); return result; } - private void collectEquations(TLongArrayList keys, Solver solver) throws EquationsLimitException { + private void collectEquations(List<HKey> keys, Solver solver) throws EquationsLimitException { GlobalSearchScope librariesScope = ProjectScope.getLibrariesScope(myProject); - TLongHashSet queued = new TLongHashSet(); - LongStack queue = new LongStack(); + HashSet<HKey> queued = new HashSet<HKey>(); + Stack<HKey> queue = new Stack<HKey>(); - for (int i = 0; i < keys.size(); i++) { - long key = keys.get(i); + for (HKey key : keys) { queue.push(key); queued.add(key); - // stable/unstable - queue.push(-key); - queued.add(-key); } + HashMap<Bytes, List<HEquations>> cache = new HashMap<Bytes, List<HEquations>>(); FileBasedIndex index = FileBasedIndex.getInstance(); + while (!queue.empty()) { if (queued.size() > EQUATIONS_LIMIT) { throw new EquationsLimitException(); } ProgressManager.checkCanceled(); - List<IdEquation> equations = index.getValues(BytecodeAnalysisIndex.NAME, queue.pop(), librariesScope); - for (IdEquation equation : equations) { - IdResult rhs = equation.rhs; - solver.addEquation(equation); - if (rhs instanceof IdPending) { - IdPending intIdPending = (IdPending)rhs; - for (IntIdComponent component : intIdPending.delta) { - for (long depKey : component.ids) { - if (!queued.contains(depKey)) { - queue.push(depKey); - queued.add(depKey); - } - // stable/unstable - long swapped = -depKey; - if (!queued.contains(swapped)) { - queue.push(swapped); - queued.add(swapped); + HKey hKey = queue.pop(); + Bytes bytes = new Bytes(hKey.key); + + List<HEquations> hEquationss = cache.get(bytes); + if (hEquationss == null) { + hEquationss = index.getValues(BytecodeAnalysisIndex.NAME, bytes, librariesScope); + cache.put(bytes, hEquationss); + } + + for (HEquations hEquations : hEquationss) { + boolean stable = hEquations.stable; + for (DirectionResultPair pair : hEquations.results) { + int dirKey = pair.directionKey; + if (dirKey == hKey.dirKey) { + HResult result = pair.hResult; + + solver.addEquation(new HEquation(new HKey(bytes.bytes, dirKey, stable), result)); + if (result instanceof HPending) { + HPending pending = (HPending)result; + for (HComponent component : pending.delta) { + for (HKey depKey : component.ids) { + if (!queued.contains(depKey)) { + queue.push(depKey); + queued.add(depKey); + } + } } } } @@ -249,11 +283,21 @@ public class ProjectBytecodeAnalysis { } } -class Annotations { +class MethodAnnotations { // @NotNull keys - final TLongHashSet notNulls = new TLongHashSet(); + final HashSet<HKey> notNulls = new HashSet<HKey>(); // @Contracts - final TLongObjectHashMap<String> contracts = new TLongObjectHashMap<String>(); + final HashMap<HKey, String> contracts = new HashMap<HKey, String>(); +} + +class ParameterAnnotations { + final boolean notNull; + final boolean nullable; + + ParameterAnnotations(boolean notNull, boolean nullable) { + this.notNull = notNull; + this.nullable = nullable; + } } class EquationsLimitException extends Exception {} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Solver.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Solver.java index 1dec1de8a606..21e749e12b29 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Solver.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/Solver.java @@ -15,10 +15,8 @@ */ package com.intellij.codeInspection.bytecodeAnalysis; -import com.intellij.util.containers.LongStack; -import gnu.trove.TLongHashSet; -import gnu.trove.TLongIterator; -import gnu.trove.TLongObjectHashMap; +import com.intellij.util.ArrayFactory; +import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; @@ -48,88 +46,6 @@ final class ELattice<T extends Enum<T>> { } } -// component specialized for ints -final class IntIdComponent { - Value value; - final long[] ids; - - IntIdComponent(Value value, long[] ids) { - this.value = value; - this.ids = ids; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - IntIdComponent that = (IntIdComponent)o; - - if (!Arrays.equals(ids, that.ids)) return false; - if (value != that.value) return false; - - return true; - } - - @Override - public int hashCode() { - return value.ordinal() + Arrays.hashCode(ids); - } - - public boolean remove(long id) { - return IdUtils.remove(ids, id); - } - - public boolean isEmpty() { - return IdUtils.isEmpty(ids); - } - - IntIdComponent copy() { - return new IntIdComponent(value, ids.clone()); - } -} - -class IdUtils { - // removed value - static final long nullId = 0; - - static boolean contains(long[] ids, int id) { - for (long id1 : ids) { - if (id1 == id) return true; - } - - return false; - } - - static boolean isEmpty(long[] ids) { - for (long id : ids) { - if (id != nullId) return false; - } - return true; - } - - static IntIdComponent[] toArray(Collection<IntIdComponent> set) { - IntIdComponent[] result = new IntIdComponent[set.size()]; - int i = 0; - for (IntIdComponent intIdComponent : set) { - result[i] = intIdComponent; - i++; - } - - return result; - } - - static boolean remove(long[] ids, long id) { - boolean removed = false; - for (int i = 0; i < ids.length; i++) { - if (ids[i] == id) { - ids[i] = nullId; - removed = true; - } - } - return removed; - } -} class ResultUtil<Id, T extends Enum<T>> { private final ELattice<T> lattice; @@ -183,6 +99,55 @@ class ResultUtil<Id, T extends Enum<T>> { } } +class HResultUtil { + private static final HKey[] EMPTY_PRODUCT = new HKey[0]; + private static final ArrayFactory<HComponent> HCOMPONENT_ARRAY_FACTORY = new ArrayFactory<HComponent>() { + @NotNull + @Override + public HComponent[] create(int count) { + return new HComponent[count]; + } + }; + private final ELattice<Value> lattice; + final Value top; + + HResultUtil(ELattice<Value> lattice) { + this.lattice = lattice; + top = lattice.top; + } + + HResult join(HResult r1, HResult r2) { + if (r1 instanceof HFinal && ((HFinal) r1).value == top) { + return r1; + } + if (r2 instanceof HFinal && ((HFinal) r2).value == top) { + return r2; + } + if (r1 instanceof HFinal && r2 instanceof HFinal) { + return new HFinal(lattice.join(((HFinal) r1).value, ((HFinal) r2).value)); + } + if (r1 instanceof HFinal && r2 instanceof HPending) { + HFinal f1 = (HFinal)r1; + HPending pending = (HPending) r2; + HComponent[] delta = new HComponent[pending.delta.length + 1]; + delta[0] = new HComponent(f1.value, EMPTY_PRODUCT); + System.arraycopy(pending.delta, 0, delta, 1, pending.delta.length); + return new HPending(delta); + } + if (r1 instanceof HPending && r2 instanceof HFinal) { + HFinal f2 = (HFinal)r2; + HPending pending = (HPending) r1; + HComponent[] delta = new HComponent[pending.delta.length + 1]; + delta[0] = new HComponent(f2.value, EMPTY_PRODUCT); + System.arraycopy(pending.delta, 0, delta, 1, pending.delta.length); + return new HPending(delta); + } + HPending pending1 = (HPending) r1; + HPending pending2 = (HPending) r2; + return new HPending(ArrayUtil.mergeArrays(pending1.delta, pending2.delta, HCOMPONENT_ARRAY_FACTORY)); + } +} + final class Product<K, V> { @NotNull final V value; @NotNull final Set<K> ids; @@ -235,195 +200,150 @@ final class Pending<Id, T> implements Result<Id, T> { } -interface IdResult {} -// this just wrapper, no need for this really -final class IdFinal implements IdResult { - final Value value; - public IdFinal(Value value) { - this.value = value; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - IdFinal that = (IdFinal)o; - - if (value != that.value) return false; - - return true; - } - - @Override - public int hashCode() { - return value.ordinal(); - } +final class Solution<Id, Val> { + final Id id; + final Val value; - @Override - public String toString() { - return super.toString(); + Solution(Id id, Val value) { + this.id = id; + this.value = value; } } -final class IdPending implements IdResult { - final IntIdComponent[] delta; - - IdPending(IntIdComponent[] delta) { - this.delta = delta; - } +final class Equation<Id, T> { + final Id id; + final Result<Id, T> rhs; - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof IdPending)) return false; - IdPending pending = (IdPending)o; - return Arrays.equals(delta, pending.delta); + Equation(Id id, Result<Id, T> rhs) { + this.id = id; + this.rhs = rhs; } @Override - public int hashCode() { - return Arrays.hashCode(delta); - } - - IdPending copy() { - IntIdComponent[] delta1 = new IntIdComponent[delta.length]; - for (int i = 0; i < delta.length; i++) { - delta1[i] = delta[i].copy(); - } - return new IdPending(delta1); + public String toString() { + return "Equation{" + "id=" + id + ", rhs=" + rhs + '}'; } } -final class IdEquation { - final long id; - final IdResult rhs; +final class CoreHKey { + @NotNull + final byte[] key; + final int dirKey; - IdEquation(long id, IdResult rhs) { - this.id = id; - this.rhs = rhs; + CoreHKey(@NotNull byte[] key, int dirKey) { + this.key = key; + this.dirKey = dirKey; } @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof IdEquation)) return false; - - IdEquation equation = (IdEquation)o; + if (o == null || getClass() != o.getClass()) return false; - if (id != equation.id) return false; - if (!rhs.equals(equation.rhs)) return false; + CoreHKey coreHKey = (CoreHKey)o; + if (dirKey != coreHKey.dirKey) return false; + if (!Arrays.equals(key, coreHKey.key)) return false; return true; } @Override public int hashCode() { - return 31 * ((int)(id ^ (id >>> 32))) + rhs.hashCode(); - } -} - -final class Solution<Id, Val> { - final Id id; - final Val value; - - Solution(Id id, Val value) { - this.id = id; - this.value = value; - } -} - -final class Equation<Id, T> { - final Id id; - final Result<Id, T> rhs; - - Equation(Id id, Result<Id, T> rhs) { - this.id = id; - this.rhs = rhs; - } - - @Override - public String toString() { - return "Equation{" + "id=" + id + ", rhs=" + rhs + '}'; + int result = Arrays.hashCode(key); + result = 31 * result + dirKey; + return result; } } final class Solver { - private int size = 0; private final ELattice<Value> lattice; - private final TLongObjectHashMap<TLongHashSet> dependencies = new TLongObjectHashMap<TLongHashSet>(); - private final TLongObjectHashMap<IdPending> pending = new TLongObjectHashMap<IdPending>(); - private final TLongObjectHashMap<Value> solved = new TLongObjectHashMap<Value>(); - private final LongStack moving = new LongStack(); + private final HashMap<HKey, HashSet<HKey>> dependencies = new HashMap<HKey, HashSet<HKey>>(); + private final HashMap<HKey, HPending> pending = new HashMap<HKey, HPending>(); + private final HashMap<HKey, Value> solved = new HashMap<HKey, Value>(); + private final Stack<HKey> moving = new Stack<HKey>(); - int getSize() { - return size; - } + private final HResultUtil resultUtil; + private final HashMap<CoreHKey, HEquation> equations = new HashMap<CoreHKey, HEquation>(); Solver(ELattice<Value> lattice) { this.lattice = lattice; + resultUtil = new HResultUtil(lattice); + } + + void addEquation(HEquation equation) { + HKey key = equation.key; + CoreHKey coreKey = new CoreHKey(key.key, key.dirKey); + + HEquation previousEquation = equations.get(coreKey); + if (previousEquation == null) { + equations.put(coreKey, equation); + } else { + HKey joinKey = new HKey(coreKey.key, coreKey.dirKey, equation.key.stable && previousEquation.key.stable); + HResult joinResult = resultUtil.join(equation.result, previousEquation.result); + HEquation joinEquation = new HEquation(joinKey, joinResult); + equations.put(coreKey, joinEquation); + } } - void addEquation(IdEquation equation) { - size ++; - IdResult rhs = equation.rhs; - if (rhs instanceof IdFinal) { - solved.put(equation.id, ((IdFinal) rhs).value); - moving.push(equation.id); - } else if (rhs instanceof IdPending) { - IdPending pendResult = ((IdPending)rhs).copy(); - IdResult norm = normalize(pendResult.delta); - if (norm instanceof IdFinal) { - solved.put(equation.id, ((IdFinal) norm).value); - moving.push(equation.id); + void queueEquation(HEquation equation) { + HResult rhs = equation.result; + if (rhs instanceof HFinal) { + solved.put(equation.key, ((HFinal) rhs).value); + moving.push(equation.key); + } else if (rhs instanceof HPending) { + HPending pendResult = ((HPending)rhs).copy(); + HResult norm = normalize(pendResult.delta); + if (norm instanceof HFinal) { + solved.put(equation.key, ((HFinal) norm).value); + moving.push(equation.key); } else { - IdPending pendResult1 = ((IdPending)rhs).copy(); - for (IntIdComponent component : pendResult1.delta) { - for (long trigger : component.ids) { - TLongHashSet set = dependencies.get(trigger); + HPending pendResult1 = ((HPending)rhs).copy(); + for (HComponent component : pendResult1.delta) { + for (HKey trigger : component.ids) { + HashSet<HKey> set = dependencies.get(trigger); if (set == null) { - set = new TLongHashSet(); + set = new HashSet<HKey>(); dependencies.put(trigger, set); } - set.add(equation.id); + set.add(equation.key); } - pending.put(equation.id, pendResult1); + pending.put(equation.key, pendResult1); } } } } - TLongObjectHashMap<Value> solve() { + HashMap<HKey, Value> solve() { + for (HEquation hEquation : equations.values()) { + queueEquation(hEquation); + } while (!moving.empty()) { - long id = moving.pop(); + HKey id = moving.pop(); Value value = solved.get(id); - boolean stable = id > 0; - long[] pIds = stable ? new long[]{id, -id} : new long[]{-id, id}; - Value[] pVals = stable ? new Value[]{value, value} : new Value[]{value, lattice.top}; + HKey[] pIds = id.stable ? new HKey[]{id, id.negate()} : new HKey[]{id.negate(), id}; + Value[] pVals = id.stable ? new Value[]{value, value} : new Value[]{value, lattice.top}; for (int i = 0; i < pIds.length; i++) { - long pId = pIds[i]; + HKey pId = pIds[i]; Value pVal = pVals[i]; - TLongHashSet dIds = dependencies.get(pId); + HashSet<HKey> dIds = dependencies.get(pId); if (dIds == null) { continue; } - TLongIterator dIdsIterator = dIds.iterator(); - while (dIdsIterator.hasNext()) { - long dId = dIdsIterator.next(); - IdPending pend = pending.remove(dId); + for (HKey dId : dIds) { + HPending pend = pending.remove(dId); if (pend != null) { - IdResult pend1 = substitute(pend, pId, pVal); - if (pend1 instanceof IdFinal) { - IdFinal fi = (IdFinal)pend1; + HResult pend1 = substitute(pend, pId, pVal); + if (pend1 instanceof HFinal) { + HFinal fi = (HFinal)pend1; solved.put(dId, fi.value); moving.push(dId); } else { - pending.put(dId, (IdPending)pend1); + pending.put(dId, (HPending)pend1); } } } @@ -434,9 +354,9 @@ final class Solver { } // substitute id -> value into pending - IdResult substitute(IdPending pending, long id, Value value) { - IntIdComponent[] sum = pending.delta; - for (IntIdComponent intIdComponent : sum) { + HResult substitute(@NotNull HPending pending, @NotNull HKey id, @NotNull Value value) { + HComponent[] sum = pending.delta; + for (HComponent intIdComponent : sum) { if (intIdComponent.remove(id)) { intIdComponent.value = lattice.meet(intIdComponent.value, value); } @@ -444,17 +364,17 @@ final class Solver { return normalize(sum); } - IdResult normalize(IntIdComponent[] sum) { + @NotNull HResult normalize(@NotNull HComponent[] sum) { Value acc = lattice.bot; boolean computableNow = true; - for (IntIdComponent prod : sum) { + for (HComponent prod : sum) { if (prod.isEmpty() || prod.value == lattice.bot) { acc = lattice.join(acc, prod.value); } else { computableNow = false; } } - return (acc == lattice.top || computableNow) ? new IdFinal(acc) : new IdPending(sum); + return (acc == lattice.top || computableNow) ? new HFinal(acc) : new HPending(sum); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ASMUtils.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ASMUtils.java new file mode 100644 index 000000000000..a6bfdc38732e --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ASMUtils.java @@ -0,0 +1,57 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue; + +/** + * @author lambdamix + */ +public class ASMUtils { + public static final Type THROWABLE_TYPE = Type.getType("java/lang/Throwable"); + public static final BasicValue THROWABLE_VALUE = new BasicValue(THROWABLE_TYPE); + + public static boolean isReferenceType(Type tp) { + int sort = tp.getSort(); + return sort == Type.OBJECT || sort == Type.ARRAY; + } + + public static boolean isBooleanType(Type tp) { + return Type.BOOLEAN_TYPE.equals(tp); + } + + public static int getSizeFast(String desc) { + switch (desc.charAt(0)) { + case 'J': + case 'D': + return 2; + default: + return 1; + } + } + + public static int getReturnSizeFast(String methodDesc) { + switch (methodDesc.charAt(methodDesc.indexOf(')') + 1)) { + case 'J': + case 'D': + return 2; + default: + return 1; + } + } + +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ControlFlowGraph.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ControlFlowGraph.java new file mode 100644 index 000000000000..40a730190d2e --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/ControlFlowGraph.java @@ -0,0 +1,174 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph.Edge; +import gnu.trove.TIntArrayList; +import org.jetbrains.org.objectweb.asm.tree.MethodNode; +import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; + +import java.util.HashSet; +import java.util.Set; + +/** + * @author lambdamix + */ +public final class ControlFlowGraph { + public static final class Edge { + public final int from, to; + + public Edge(int from, int to) { + this.from = from; + this.to = to; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Edge)) { + return false; + } + Edge edge = (Edge) o; + return from == edge.from && to == edge.to; + } + + @Override + public int hashCode() { + return 31 * from + to; + } + } + + public final String className; + public final MethodNode methodNode; + public final int[][] transitions; + public final int edgeCount; + public final boolean[] errors; + public final Set<Edge> errorTransitions; + + ControlFlowGraph(String className, MethodNode methodNode, int[][] transitions, int edgeCount, boolean[] errors, Set<Edge> errorTransitions) { + this.className = className; + this.methodNode = methodNode; + this.transitions = transitions; + this.edgeCount = edgeCount; + this.errors = errors; + this.errorTransitions = errorTransitions; + } + + public static ControlFlowGraph build(String className, MethodNode methodNode, boolean jsr) throws AnalyzerException { + return jsr ? new ControlFlowBuilder(className, methodNode).buildCFG() : new LiteControlFlowBuilder(className, methodNode).buildCFG(); + } +} + +final class ControlFlowBuilder extends FramelessAnalyzer { + final String className; + final MethodNode methodNode; + final TIntArrayList[] transitions; + final Set<ControlFlowGraph.Edge> errorTransitions; + private final boolean[] errors; + private int edgeCount; + + ControlFlowBuilder(String className, MethodNode methodNode) { + this.className = className; + this.methodNode = methodNode; + transitions = new TIntArrayList[methodNode.instructions.size()]; + errors = new boolean[methodNode.instructions.size()]; + for (int i = 0; i < transitions.length; i++) { + transitions[i] = new TIntArrayList(); + } + errorTransitions = new HashSet<Edge>(); + } + + final ControlFlowGraph buildCFG() throws AnalyzerException { + if ((methodNode.access & (ACC_ABSTRACT | ACC_NATIVE)) == 0) { + analyze(methodNode); + } + int[][] resultTransitions = new int[transitions.length][]; + for (int i = 0; i < resultTransitions.length; i++) { + resultTransitions[i] = transitions[i].toNativeArray(); + } + return new ControlFlowGraph(className, methodNode, resultTransitions, edgeCount, errors, errorTransitions); + } + + @Override + protected final void newControlFlowEdge(int insn, int successor) { + if (!transitions[insn].contains(successor)) { + transitions[insn].add(successor); + edgeCount++; + } + } + + @Override + protected final boolean newControlFlowExceptionEdge(int insn, int successor) { + if (!transitions[insn].contains(successor)) { + transitions[insn].add(successor); + edgeCount++; + errorTransitions.add(new Edge(insn, successor)); + errors[successor] = true; + } + return true; + } +} + +final class LiteControlFlowBuilder extends LiteFramelessAnalyzer { + final String className; + final MethodNode methodNode; + final TIntArrayList[] transitions; + final Set<ControlFlowGraph.Edge> errorTransitions; + private final boolean[] errors; + private int edgeCount; + + LiteControlFlowBuilder(String className, MethodNode methodNode) { + this.className = className; + this.methodNode = methodNode; + transitions = new TIntArrayList[methodNode.instructions.size()]; + errors = new boolean[methodNode.instructions.size()]; + for (int i = 0; i < transitions.length; i++) { + transitions[i] = new TIntArrayList(); + } + errorTransitions = new HashSet<Edge>(); + } + + final ControlFlowGraph buildCFG() throws AnalyzerException { + if ((methodNode.access & (ACC_ABSTRACT | ACC_NATIVE)) == 0) { + analyze(methodNode); + } + int[][] resultTransitions = new int[transitions.length][]; + for (int i = 0; i < resultTransitions.length; i++) { + resultTransitions[i] = transitions[i].toNativeArray(); + } + return new ControlFlowGraph(className, methodNode, resultTransitions, edgeCount, errors, errorTransitions); + } + + @Override + protected final void newControlFlowEdge(int insn, int successor) { + if (!transitions[insn].contains(successor)) { + transitions[insn].add(successor); + edgeCount++; + } + } + + @Override + protected final boolean newControlFlowExceptionEdge(int insn, int successor) { + if (!transitions[insn].contains(successor)) { + transitions[insn].add(successor); + edgeCount++; + errorTransitions.add(new Edge(insn, successor)); + errors[successor] = true; + } + return true; + } +} + diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/DFSTree.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/DFSTree.java new file mode 100644 index 000000000000..85bc13fbda96 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/DFSTree.java @@ -0,0 +1,134 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph.Edge; + +import java.util.HashSet; +import java.util.Set; + +/** + * @author lambdamix + */ +public final class DFSTree { + public final int[] preOrder, postOrder; + public final Set<Edge> nonBack, back; + public final boolean[] loopEnters; + + DFSTree(int[] preOrder, + int[] postOrder, + Set<Edge> nonBack, + Set<Edge> back, + boolean[] loopEnters) { + this.preOrder = preOrder; + this.postOrder = postOrder; + this.nonBack = nonBack; + this.back = back; + this.loopEnters = loopEnters; + } + + public final boolean isDescendant(int child, int parent) { + return preOrder[parent] <= preOrder[child] && postOrder[child] <= postOrder[parent]; + } + + // Graphs: Theory and Algorithms. by K. Thulasiraman , M. N. S. Swamy (1992) + // 11.7.2 DFS of a directed graph + public static DFSTree build(int[][] transitions, int edgeCount) { + HashSet<Edge> nonBack = new HashSet<Edge>(); + HashSet<Edge> back = new HashSet<Edge>(); + + boolean[] marked = new boolean[transitions.length]; + boolean[] scanned = new boolean[transitions.length]; + int[] preOrder = new int[transitions.length]; + int[] postOrder = new int[transitions.length]; + + int entered = 0; + int completed = 0; + + boolean[] loopEnters = new boolean[transitions.length]; + + // enter 0 + entered ++; + preOrder[0] = entered; + marked[0] = true; + + boolean[] stackFlag = new boolean[edgeCount*2 + 1]; + int[] stackFrom = new int[edgeCount*2 + 1]; + int[] stackTo = new int[edgeCount*2 + 1]; + + int top = 0; + + // stack.push(new MarkScanned(0)); + stackFlag[top] = true; + stackTo[top] = 0; + top++; + + for (int to : transitions[0]) { + //stack.push(new ExamineEdge(0, to)); + stackFlag[top] = false; + stackFrom[top] = 0; + stackTo[top] = to; + top++; + } + + while (top > 0) { + top--; + //Action action = stack.pop(); + // markScanned + if (stackFlag[top]) { + completed ++; + postOrder[stackTo[top]] = completed; + scanned[stackTo[top]] = true; + } + else { + //ExamineEdge examineEdgeAction = (ExamineEdge) action; + int from = stackFrom[top]; + int to = stackTo[top]; + if (!marked[to]) { + nonBack.add(new Edge(from, to)); + // enter to + entered ++; + preOrder[to] = entered; + marked[to] = true; + + //stack.push(new MarkScanned(to)); + stackFlag[top] = true; + stackTo[top] = to; + top++; + + for (int to1 : transitions[to]) { + //stack.push(new ExamineEdge(to, to1)); + stackFlag[top] = false; + stackFrom[top] = to; + stackTo[top] = to1; + top++; + } + } + else if (preOrder[to] > preOrder[from]) { + nonBack.add(new Edge(from, to)); + } + else if (preOrder[to] < preOrder[from] && !scanned[to]) { + back.add(new Edge(from, to)); + loopEnters[to] = true; + } else { + nonBack.add(new Edge(from, to)); + } + } + } + + return new DFSTree(preOrder, postOrder, nonBack, back, loopEnters); + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/FramelessAnalyzer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/FramelessAnalyzer.java new file mode 100644 index 000000000000..5804723e9ec1 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/FramelessAnalyzer.java @@ -0,0 +1,362 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import org.jetbrains.annotations.Nullable; +import org.jetbrains.org.objectweb.asm.Opcodes; +import org.jetbrains.org.objectweb.asm.tree.*; +import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Specialized version of {@link org.jetbrains.org.objectweb.asm.tree.analysis.Analyzer}. + * Calculation of fix-point of frames is removed, since frames are not needed to build control flow graph. + * So, the main point here is handling of subroutines (jsr) and try-catch-finally blocks. + */ +public class FramelessAnalyzer implements Opcodes { + static class Subroutine { + + LabelNode start; + boolean[] access; + List<JumpInsnNode> callers; + + private Subroutine() { + } + + Subroutine(@Nullable final LabelNode start, final int maxLocals, + @Nullable final JumpInsnNode caller) { + this.start = start; + this.access = new boolean[maxLocals]; + this.callers = new ArrayList<JumpInsnNode>(); + callers.add(caller); + } + + public Subroutine copy() { + Subroutine result = new Subroutine(); + result.start = start; + result.access = new boolean[access.length]; + System.arraycopy(access, 0, result.access, 0, access.length); + result.callers = new ArrayList<JumpInsnNode>(callers); + return result; + } + + public boolean merge(final Subroutine subroutine) throws AnalyzerException { + boolean changes = false; + for (int i = 0; i < access.length; ++i) { + if (subroutine.access[i] && !access[i]) { + access[i] = true; + changes = true; + } + } + if (subroutine.start == start) { + for (int i = 0; i < subroutine.callers.size(); ++i) { + JumpInsnNode caller = subroutine.callers.get(i); + if (!callers.contains(caller)) { + callers.add(caller); + changes = true; + } + } + } + return changes; + } + } + private int n; + private InsnList insns; + private List<TryCatchBlockNode>[] handlers; + private Subroutine[] subroutines; + protected boolean[] wasQueued; + protected boolean[] queued; + protected int[] queue; + protected int top; + + public void analyze(final MethodNode m) throws AnalyzerException { + n = m.instructions.size(); + if ((m.access & (ACC_ABSTRACT | ACC_NATIVE)) != 0 || n == 0) { + return; + } + insns = m.instructions; + handlers = (List<TryCatchBlockNode>[]) new List<?>[n]; + subroutines = new Subroutine[n]; + queued = new boolean[n]; + wasQueued = new boolean[n]; + queue = new int[n]; + top = 0; + + // computes exception handlers for each instruction + for (int i = 0; i < m.tryCatchBlocks.size(); ++i) { + TryCatchBlockNode tcb = m.tryCatchBlocks.get(i); + int begin = insns.indexOf(tcb.start); + int end = insns.indexOf(tcb.end); + for (int j = begin; j < end; ++j) { + List<TryCatchBlockNode> insnHandlers = handlers[j]; + if (insnHandlers == null) { + insnHandlers = new ArrayList<TryCatchBlockNode>(); + handlers[j] = insnHandlers; + } + insnHandlers.add(tcb); + } + } + + // computes the subroutine for each instruction: + Subroutine main = new Subroutine(null, m.maxLocals, null); + List<AbstractInsnNode> subroutineCalls = new ArrayList<AbstractInsnNode>(); + Map<LabelNode, Subroutine> subroutineHeads = new HashMap<LabelNode, Subroutine>(); + + findSubroutine(0, main, subroutineCalls); + while (!subroutineCalls.isEmpty()) { + JumpInsnNode jsr = (JumpInsnNode) subroutineCalls.remove(0); + Subroutine sub = subroutineHeads.get(jsr.label); + if (sub == null) { + sub = new Subroutine(jsr.label, m.maxLocals, jsr); + subroutineHeads.put(jsr.label, sub); + findSubroutine(insns.indexOf(jsr.label), sub, subroutineCalls); + } else { + sub.callers.add(jsr); + } + } + for (int i = 0; i < n; ++i) { + if (subroutines[i] != null && subroutines[i].start == null) { + subroutines[i] = null; + } + } + + merge(0, null); + // control flow analysis + while (top > 0) { + int insn = queue[--top]; + Subroutine subroutine = subroutines[insn]; + queued[insn] = false; + + AbstractInsnNode insnNode = null; + try { + insnNode = m.instructions.get(insn); + int insnOpcode = insnNode.getOpcode(); + int insnType = insnNode.getType(); + + if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) { + merge(insn + 1, subroutine); + newControlFlowEdge(insn, insn + 1); + } else { + subroutine = subroutine == null ? null : subroutine.copy(); + + if (insnNode instanceof JumpInsnNode) { + JumpInsnNode j = (JumpInsnNode) insnNode; + if (insnOpcode != GOTO && insnOpcode != JSR) { + merge(insn + 1, subroutine); + newControlFlowEdge(insn, insn + 1); + } + int jump = insns.indexOf(j.label); + if (insnOpcode == JSR) { + merge(jump, new Subroutine(j.label, m.maxLocals, j)); + } else { + merge(jump, subroutine); + } + newControlFlowEdge(insn, jump); + } else if (insnNode instanceof LookupSwitchInsnNode) { + LookupSwitchInsnNode lsi = (LookupSwitchInsnNode) insnNode; + int jump = insns.indexOf(lsi.dflt); + merge(jump, subroutine); + newControlFlowEdge(insn, jump); + for (int j = 0; j < lsi.labels.size(); ++j) { + LabelNode label = lsi.labels.get(j); + jump = insns.indexOf(label); + merge(jump, subroutine); + newControlFlowEdge(insn, jump); + } + } else if (insnNode instanceof TableSwitchInsnNode) { + TableSwitchInsnNode tsi = (TableSwitchInsnNode) insnNode; + int jump = insns.indexOf(tsi.dflt); + merge(jump, subroutine); + newControlFlowEdge(insn, jump); + for (int j = 0; j < tsi.labels.size(); ++j) { + LabelNode label = tsi.labels.get(j); + jump = insns.indexOf(label); + merge(jump, subroutine); + newControlFlowEdge(insn, jump); + } + } else if (insnOpcode == RET) { + if (subroutine == null) { + throw new AnalyzerException(insnNode, "RET instruction outside of a sub routine"); + } + for (int i = 0; i < subroutine.callers.size(); ++i) { + JumpInsnNode caller = subroutine.callers.get(i); + int call = insns.indexOf(caller); + if (wasQueued[call]) { + merge(call + 1, subroutines[call], subroutine.access); + newControlFlowEdge(insn, call + 1); + } + } + } else if (insnOpcode != ATHROW && (insnOpcode < IRETURN || insnOpcode > RETURN)) { + if (subroutine != null) { + if (insnNode instanceof VarInsnNode) { + int var = ((VarInsnNode) insnNode).var; + subroutine.access[var] = true; + if (insnOpcode == LLOAD || insnOpcode == DLOAD + || insnOpcode == LSTORE + || insnOpcode == DSTORE) { + subroutine.access[var + 1] = true; + } + } else if (insnNode instanceof IincInsnNode) { + int var = ((IincInsnNode) insnNode).var; + subroutine.access[var] = true; + } + } + merge(insn + 1, subroutine); + newControlFlowEdge(insn, insn + 1); + } + } + + List<TryCatchBlockNode> insnHandlers = handlers[insn]; + if (insnHandlers != null) { + for (TryCatchBlockNode tcb : insnHandlers) { + newControlFlowExceptionEdge(insn, tcb); + merge(insns.indexOf(tcb.handler), subroutine); + } + } + } catch (AnalyzerException e) { + throw new AnalyzerException(e.node, "Error at instruction " + + insn + ": " + e.getMessage(), e); + } catch (Exception e) { + throw new AnalyzerException(insnNode, "Error at instruction " + + insn + ": " + e.getMessage(), e); + } + } + } + + protected void findSubroutine(int insn, final Subroutine sub, + final List<AbstractInsnNode> calls) throws AnalyzerException { + while (true) { + if (insn < 0 || insn >= n) { + throw new AnalyzerException(null, "Execution can fall off end of the code"); + } + if (subroutines[insn] != null) { + return; + } + subroutines[insn] = sub.copy(); + AbstractInsnNode node = insns.get(insn); + + // calls findSubroutine recursively on normal successors + if (node instanceof JumpInsnNode) { + if (node.getOpcode() == JSR) { + // do not follow a JSR, it leads to another subroutine! + calls.add(node); + } else { + JumpInsnNode jnode = (JumpInsnNode) node; + findSubroutine(insns.indexOf(jnode.label), sub, calls); + } + } else if (node instanceof TableSwitchInsnNode) { + TableSwitchInsnNode tsnode = (TableSwitchInsnNode) node; + findSubroutine(insns.indexOf(tsnode.dflt), sub, calls); + for (int i = tsnode.labels.size() - 1; i >= 0; --i) { + LabelNode l = tsnode.labels.get(i); + findSubroutine(insns.indexOf(l), sub, calls); + } + } else if (node instanceof LookupSwitchInsnNode) { + LookupSwitchInsnNode lsnode = (LookupSwitchInsnNode) node; + findSubroutine(insns.indexOf(lsnode.dflt), sub, calls); + for (int i = lsnode.labels.size() - 1; i >= 0; --i) { + LabelNode l = lsnode.labels.get(i); + findSubroutine(insns.indexOf(l), sub, calls); + } + } + + // calls findSubroutine recursively on exception handler successors + List<TryCatchBlockNode> insnHandlers = handlers[insn]; + if (insnHandlers != null) { + for (int i = 0; i < insnHandlers.size(); ++i) { + TryCatchBlockNode tcb = insnHandlers.get(i); + findSubroutine(insns.indexOf(tcb.handler), sub, calls); + } + } + + // if insn does not falls through to the next instruction, return. + switch (node.getOpcode()) { + case GOTO: + case RET: + case TABLESWITCH: + case LOOKUPSWITCH: + case IRETURN: + case LRETURN: + case FRETURN: + case DRETURN: + case ARETURN: + case RETURN: + case ATHROW: + return; + } + insn++; + } + } + + protected void newControlFlowEdge(final int insn, final int successor) {} + + protected boolean newControlFlowExceptionEdge(final int insn, final int successor) { + return true; + } + + protected boolean newControlFlowExceptionEdge(final int insn, final TryCatchBlockNode tcb) { + return newControlFlowExceptionEdge(insn, insns.indexOf(tcb.handler)); + } + + // ------------------------------------------------------------------------- + + protected void merge(final int insn, @Nullable final Subroutine subroutine) throws AnalyzerException { + Subroutine oldSubroutine = subroutines[insn]; + boolean changes = false; + + if (!wasQueued[insn]) { + wasQueued[insn] = true; + changes = true; + } + + if (oldSubroutine == null) { + if (subroutine != null) { + subroutines[insn] = subroutine.copy(); + changes = true; + } + } else { + if (subroutine != null) { + changes |= oldSubroutine.merge(subroutine); + } + } + if (changes && !queued[insn]) { + queued[insn] = true; + queue[top++] = insn; + } + } + + protected void merge(final int insn, final Subroutine subroutineBeforeJSR, final boolean[] access) throws AnalyzerException { + Subroutine oldSubroutine = subroutines[insn]; + boolean changes = false; + + if (!wasQueued[insn]) { + wasQueued[insn] = true; + changes = true; + } + + if (oldSubroutine != null && subroutineBeforeJSR != null) { + changes |= oldSubroutine.merge(subroutineBeforeJSR); + } + if (changes && !queued[insn]) { + queued[insn] = true; + queue[top++] = insn; + } + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LeakingParameters.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LeakingParameters.java new file mode 100644 index 000000000000..1a7ab15722f9 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LeakingParameters.java @@ -0,0 +1,610 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.tree.*; +import org.jetbrains.org.objectweb.asm.tree.analysis.*; + +import java.util.Arrays; +import java.util.List; + +import static org.jetbrains.org.objectweb.asm.Opcodes.*; + +/** + * @author lambdamix + */ +public class LeakingParameters { + public final Frame<Value>[] frames; + public final boolean[] parameters; + public final boolean[] nullableParameters; + + public LeakingParameters(Frame<Value>[] frames, boolean[] parameters, boolean[] nullableParameters) { + this.frames = frames; + this.parameters = parameters; + this.nullableParameters = nullableParameters; + } + + public static LeakingParameters build(String className, MethodNode methodNode, boolean jsr) throws AnalyzerException { + Frame<ParamsValue>[] frames = jsr ? + new Analyzer<ParamsValue>(new ParametersUsage(methodNode)).analyze(className, methodNode) : + new LiteAnalyzer<ParamsValue>(new ParametersUsage(methodNode)).analyze(className, methodNode); + InsnList insns = methodNode.instructions; + LeakingParametersCollector collector = new LeakingParametersCollector(methodNode); + for (int i = 0; i < frames.length; i++) { + AbstractInsnNode insnNode = insns.get(i); + Frame<ParamsValue> frame = frames[i]; + if (frame != null) { + switch (insnNode.getType()) { + case AbstractInsnNode.LABEL: + case AbstractInsnNode.LINE: + case AbstractInsnNode.FRAME: + break; + default: + new Frame<ParamsValue>(frame).execute(insnNode, collector); + } + } + } + boolean[] notNullParameters = collector.leaking; + boolean[] nullableParameters = collector.nullableLeaking; + for (int i = 0; i < nullableParameters.length; i++) { + nullableParameters[i] |= notNullParameters[i]; + } + return new LeakingParameters((Frame<Value>[])(Frame<?>[])frames, notNullParameters, nullableParameters); + } + + public static LeakingParameters buildFast(String className, MethodNode methodNode, boolean jsr) throws AnalyzerException { + IParametersUsage parametersUsage = new IParametersUsage(methodNode); + Frame<?>[] frames = jsr ? + new Analyzer<IParamsValue>(parametersUsage).analyze(className, methodNode) : + new LiteAnalyzer<IParamsValue>(parametersUsage).analyze(className, methodNode); + int leakingMask = parametersUsage.leaking; + int nullableLeakingMask = parametersUsage.nullableLeaking; + boolean[] notNullParameters = new boolean[parametersUsage.arity]; + boolean[] nullableParameters = new boolean[parametersUsage.arity]; + for (int i = 0; i < notNullParameters.length; i++) { + notNullParameters[i] = (leakingMask & (1 << i)) != 0; + nullableParameters[i] = ((leakingMask | nullableLeakingMask) & (1 << i)) != 0; + } + return new LeakingParameters((Frame<Value>[])frames, notNullParameters, nullableParameters); + } +} + +final class ParamsValue implements Value { + @NotNull final boolean[] params; + final int size; + + ParamsValue(@NotNull boolean[] params, int size) { + this.params = params; + this.size = size; + } + + @Override + public int getSize() { + return size; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null) return false; + ParamsValue that = (ParamsValue)o; + return (this.size == that.size && Arrays.equals(this.params, that.params)); + } + + @Override + public int hashCode() { + return 31 * Arrays.hashCode(params) + size; + } +} + +// specialized version +final class IParamsValue implements Value { + final int params; + final int size; + + IParamsValue(int params, int size) { + this.params = params; + this.size = size; + } + + @Override + public int getSize() { + return size; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null) return false; + IParamsValue that = (IParamsValue)o; + return (this.size == that.size && this.params == that.params); + } + + @Override + public int hashCode() { + return 31 * params + size; + } +} + +class ParametersUsage extends Interpreter<ParamsValue> { + final ParamsValue val1; + final ParamsValue val2; + int called = -1; + final int rangeStart; + final int rangeEnd; + final int arity; + final int shift; + + ParametersUsage(MethodNode methodNode) { + super(ASM5); + arity = Type.getArgumentTypes(methodNode.desc).length; + boolean[] emptyParams = new boolean[arity]; + val1 = new ParamsValue(emptyParams, 1); + val2 = new ParamsValue(emptyParams, 2); + + shift = (methodNode.access & ACC_STATIC) == 0 ? 2 : 1; + rangeStart = shift; + rangeEnd = arity + shift; + } + + @Override + public ParamsValue newValue(Type type) { + if (type == null) return val1; + called++; + if (type == Type.VOID_TYPE) return null; + if (called < rangeEnd && rangeStart <= called && (ASMUtils.isReferenceType(type) || ASMUtils.isBooleanType(type))) { + boolean[] params = new boolean[arity]; + params[called - shift] = true; + return type.getSize() == 1 ? new ParamsValue(params, 1) : new ParamsValue(params, 2); + } + else { + return type.getSize() == 1 ? val1 : val2; + } + } + + @Override + public ParamsValue newOperation(final AbstractInsnNode insn) { + int size; + switch (insn.getOpcode()) { + case LCONST_0: + case LCONST_1: + case DCONST_0: + case DCONST_1: + size = 2; + break; + case LDC: + Object cst = ((LdcInsnNode) insn).cst; + size = cst instanceof Long || cst instanceof Double ? 2 : 1; + break; + case GETSTATIC: + size = Type.getType(((FieldInsnNode) insn).desc).getSize(); + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public ParamsValue copyOperation(AbstractInsnNode insn, ParamsValue value) { + return value; + } + + @Override + public ParamsValue unaryOperation(AbstractInsnNode insn, ParamsValue value) { + int size; + switch (insn.getOpcode()) { + case CHECKCAST: + return value; + case LNEG: + case DNEG: + case I2L: + case I2D: + case L2D: + case F2L: + case F2D: + case D2L: + size = 2; + break; + case GETFIELD: + size = Type.getType(((FieldInsnNode) insn).desc).getSize(); + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public ParamsValue binaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2) { + int size; + switch (insn.getOpcode()) { + case LALOAD: + case DALOAD: + case LADD: + case DADD: + case LSUB: + case DSUB: + case LMUL: + case DMUL: + case LDIV: + case DDIV: + case LREM: + case DREM: + case LSHL: + case LSHR: + case LUSHR: + case LAND: + case LOR: + case LXOR: + size = 2; + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public ParamsValue ternaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2, ParamsValue value3) { + return val1; + } + + @Override + public ParamsValue naryOperation(AbstractInsnNode insn, List<? extends ParamsValue> values) { + int size; + int opcode = insn.getOpcode(); + if (opcode == MULTIANEWARRAY) { + size = 1; + } else { + String desc = (opcode == INVOKEDYNAMIC) ? ((InvokeDynamicInsnNode) insn).desc : ((MethodInsnNode) insn).desc; + size = Type.getReturnType(desc).getSize(); + } + return size == 1 ? val1 : val2; + } + + @Override + public void returnOperation(AbstractInsnNode insn, ParamsValue value, ParamsValue expected) {} + + @Override + public ParamsValue merge(ParamsValue v1, ParamsValue v2) { + if (v1.equals(v2)) return v1; + boolean[] params = new boolean[arity]; + boolean[] params1 = v1.params; + boolean[] params2 = v2.params; + for (int i = 0; i < arity; i++) { + params[i] = params1[i] || params2[i]; + } + return new ParamsValue(params, Math.min(v1.size, v2.size)); + } +} + +class IParametersUsage extends Interpreter<IParamsValue> { + static final IParamsValue val1 = new IParamsValue(0, 1); + static final IParamsValue val2 = new IParamsValue(0, 2); + int leaking = 0; + int nullableLeaking = 0; + int called = -1; + final int rangeStart; + final int rangeEnd; + final int arity; + final int shift; + + IParametersUsage(MethodNode methodNode) { + super(ASM5); + arity = Type.getArgumentTypes(methodNode.desc).length; + shift = (methodNode.access & ACC_STATIC) == 0 ? 2 : 1; + rangeStart = shift; + rangeEnd = arity + shift; + } + + @Override + public IParamsValue newValue(Type type) { + if (type == null) return val1; + called++; + if (type == Type.VOID_TYPE) return null; + if (called < rangeEnd && rangeStart <= called && (ASMUtils.isReferenceType(type) || ASMUtils.isBooleanType(type))) { + int n = called - shift; + return type.getSize() == 1 ? new IParamsValue(1 << n, 1) : new IParamsValue(1 << n, 2); + } + else { + return type.getSize() == 1 ? val1 : val2; + } + } + + @Override + public IParamsValue newOperation(final AbstractInsnNode insn) { + int size; + switch (insn.getOpcode()) { + case LCONST_0: + case LCONST_1: + case DCONST_0: + case DCONST_1: + size = 2; + break; + case LDC: + Object cst = ((LdcInsnNode) insn).cst; + size = cst instanceof Long || cst instanceof Double ? 2 : 1; + break; + case GETSTATIC: + size = ASMUtils.getSizeFast(((FieldInsnNode)insn).desc); + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public IParamsValue copyOperation(AbstractInsnNode insn, IParamsValue value) { + return value; + } + + @Override + public IParamsValue unaryOperation(AbstractInsnNode insn, IParamsValue value) { + int size; + switch (insn.getOpcode()) { + case CHECKCAST: + return value; + case LNEG: + case DNEG: + case I2L: + case I2D: + case L2D: + case F2L: + case F2D: + case D2L: + size = 2; + break; + case GETFIELD: + size = ASMUtils.getSizeFast(((FieldInsnNode)insn).desc); + leaking |= value.params; + break; + case ARRAYLENGTH: + case MONITORENTER: + case INSTANCEOF: + case IRETURN: + case ARETURN: + case IFNONNULL: + case IFNULL: + case IFEQ: + case IFNE: + size = 1; + leaking |= value.params; + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public IParamsValue binaryOperation(AbstractInsnNode insn, IParamsValue value1, IParamsValue value2) { + int size; + switch (insn.getOpcode()) { + case LALOAD: + case DALOAD: + size = 2; + leaking |= value1.params; + break; + case LADD: + case DADD: + case LSUB: + case DSUB: + case LMUL: + case DMUL: + case LDIV: + case DDIV: + case LREM: + case DREM: + case LSHL: + case LSHR: + case LUSHR: + case LAND: + case LOR: + case LXOR: + size = 2; + break; + case IALOAD: + case FALOAD: + case AALOAD: + case BALOAD: + case CALOAD: + case SALOAD: + leaking |= value1.params; + size = 1; + break; + case PUTFIELD: + leaking |= value1.params; + nullableLeaking |= value2.params; + size = 1; + break; + default: + size = 1; + } + return size == 1 ? val1 : val2; + } + + @Override + public IParamsValue ternaryOperation(AbstractInsnNode insn, IParamsValue value1, IParamsValue value2, IParamsValue value3) { + switch (insn.getOpcode()) { + case IASTORE: + case LASTORE: + case FASTORE: + case DASTORE: + case BASTORE: + case CASTORE: + case SASTORE: + leaking |= value1.params; + break; + case AASTORE: + leaking |= value1.params; + nullableLeaking |= value3.params; + break; + default: + } + return val1; + } + + @Override + public IParamsValue naryOperation(AbstractInsnNode insn, List<? extends IParamsValue> values) { + int opcode = insn.getOpcode(); + switch (opcode) { + case INVOKESTATIC: + case INVOKESPECIAL: + case INVOKEVIRTUAL: + case INVOKEINTERFACE: + for (IParamsValue value : values) { + leaking |= value.params; + } + break; + default: + } + int size; + if (opcode == MULTIANEWARRAY) { + size = 1; + } else { + String desc = (opcode == INVOKEDYNAMIC) ? ((InvokeDynamicInsnNode) insn).desc : ((MethodInsnNode) insn).desc; + size = ASMUtils.getReturnSizeFast(desc); + } + return size == 1 ? val1 : val2; + } + + @Override + public void returnOperation(AbstractInsnNode insn, IParamsValue value, IParamsValue expected) {} + + @Override + public IParamsValue merge(IParamsValue v1, IParamsValue v2) { + if (v1.equals(v2)) return v1; + return new IParamsValue(v1.params | v2.params, Math.min(v1.size, v2.size)); + } +} + +class LeakingParametersCollector extends ParametersUsage { + final boolean[] leaking; + final boolean[] nullableLeaking; + LeakingParametersCollector(MethodNode methodNode) { + super(methodNode); + leaking = new boolean[arity]; + nullableLeaking = new boolean[arity]; + } + + @Override + public ParamsValue unaryOperation(AbstractInsnNode insn, ParamsValue value) { + switch (insn.getOpcode()) { + case GETFIELD: + case ARRAYLENGTH: + case MONITORENTER: + case INSTANCEOF: + case IRETURN: + case ARETURN: + case IFNONNULL: + case IFNULL: + case IFEQ: + case IFNE: + boolean[] params = value.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + break; + default: + } + return super.unaryOperation(insn, value); + } + + @Override + public ParamsValue binaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2) { + switch (insn.getOpcode()) { + case IALOAD: + case LALOAD: + case FALOAD: + case DALOAD: + case AALOAD: + case BALOAD: + case CALOAD: + case SALOAD: + boolean[] params = value1.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + break; + case PUTFIELD: + params = value1.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + params = value2.params; + for (int i = 0; i < arity; i++) { + nullableLeaking[i] |= params[i]; + } + break; + default: + } + return super.binaryOperation(insn, value1, value2); + } + + @Override + public ParamsValue ternaryOperation(AbstractInsnNode insn, ParamsValue value1, ParamsValue value2, ParamsValue value3) { + switch (insn.getOpcode()) { + case IASTORE: + case LASTORE: + case FASTORE: + case DASTORE: + case BASTORE: + case CASTORE: + case SASTORE: + boolean[] params = value1.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + break; + case AASTORE: + params = value1.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + params = value3.params; + for (int i = 0; i < arity; i++) { + nullableLeaking[i] |= params[i]; + } + break; + default: + } + return super.ternaryOperation(insn, value1, value2, value3); + } + + @Override + public ParamsValue naryOperation(AbstractInsnNode insn, List<? extends ParamsValue> values) { + switch (insn.getOpcode()) { + case INVOKESTATIC: + case INVOKESPECIAL: + case INVOKEVIRTUAL: + case INVOKEINTERFACE: + for (ParamsValue value : values) { + boolean[] params = value.params; + for (int i = 0; i < arity; i++) { + leaking[i] |= params[i]; + } + } + break; + default: + } + return super.naryOperation(insn, values); + } +} + diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteAnalyzer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteAnalyzer.java new file mode 100644 index 000000000000..22961208076b --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteAnalyzer.java @@ -0,0 +1,189 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import org.jetbrains.org.objectweb.asm.Opcodes; +import org.jetbrains.org.objectweb.asm.Type; +import org.jetbrains.org.objectweb.asm.tree.*; +import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; +import org.jetbrains.org.objectweb.asm.tree.analysis.Frame; +import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter; +import org.jetbrains.org.objectweb.asm.tree.analysis.Value; + +import java.util.ArrayList; +import java.util.List; + +/** + * Specialized lite version of {@link org.objectweb.asm.tree.analysis.Analyzer}. + * No processing of Subroutines. May be used for methods without JSR/RET instructions. + * + * @author lambdamix + */ +public class LiteAnalyzer<V extends Value> implements Opcodes { + + private final Interpreter<V> interpreter; + + private Frame<V>[] frames; + + private boolean[] queued; + + private int[] queue; + + private int top; + + public LiteAnalyzer(final Interpreter<V> interpreter) { + this.interpreter = interpreter; + } + + public Frame<V>[] analyze(final String owner, final MethodNode m) throws AnalyzerException { + if ((m.access & (ACC_ABSTRACT | ACC_NATIVE)) != 0 || m.instructions.size() == 0) { + frames = (Frame<V>[]) new Frame<?>[0]; + return frames; + } + int n = m.instructions.size(); + InsnList insns = m.instructions; + List<TryCatchBlockNode>[] handlers = (List<TryCatchBlockNode>[]) new List<?>[n]; + frames = (Frame<V>[]) new Frame<?>[n]; + queued = new boolean[n]; + queue = new int[n]; + top = 0; + + // computes exception handlers for each instruction + for (int i = 0; i < m.tryCatchBlocks.size(); ++i) { + TryCatchBlockNode tcb = m.tryCatchBlocks.get(i); + int begin = insns.indexOf(tcb.start); + int end = insns.indexOf(tcb.end); + for (int j = begin; j < end; ++j) { + List<TryCatchBlockNode> insnHandlers = handlers[j]; + if (insnHandlers == null) { + insnHandlers = new ArrayList<TryCatchBlockNode>(); + handlers[j] = insnHandlers; + } + insnHandlers.add(tcb); + } + } + + // initializes the data structures for the control flow analysis + Frame<V> current = new Frame<V>(m.maxLocals, m.maxStack); + Frame<V> handler = new Frame<V>(m.maxLocals, m.maxStack); + current.setReturn(interpreter.newValue(Type.getReturnType(m.desc))); + Type[] args = Type.getArgumentTypes(m.desc); + int local = 0; + if ((m.access & ACC_STATIC) == 0) { + Type ctype = Type.getObjectType(owner); + current.setLocal(local++, interpreter.newValue(ctype)); + } + for (int i = 0; i < args.length; ++i) { + current.setLocal(local++, interpreter.newValue(args[i])); + if (args[i].getSize() == 2) { + current.setLocal(local++, interpreter.newValue(null)); + } + } + while (local < m.maxLocals) { + current.setLocal(local++, interpreter.newValue(null)); + } + merge(0, current); + + // control flow analysis + while (top > 0) { + int insn = queue[--top]; + Frame<V> f = frames[insn]; + queued[insn] = false; + + AbstractInsnNode insnNode = null; + try { + insnNode = m.instructions.get(insn); + int insnOpcode = insnNode.getOpcode(); + int insnType = insnNode.getType(); + + if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) { + merge(insn + 1, f); + } else { + current.init(f).execute(insnNode, interpreter); + + if (insnNode instanceof JumpInsnNode) { + JumpInsnNode j = (JumpInsnNode) insnNode; + if (insnOpcode != GOTO && insnOpcode != JSR) { + merge(insn + 1, current); + } + int jump = insns.indexOf(j.label); + merge(jump, current); + } else if (insnNode instanceof LookupSwitchInsnNode) { + LookupSwitchInsnNode lsi = (LookupSwitchInsnNode) insnNode; + int jump = insns.indexOf(lsi.dflt); + merge(jump, current); + for (int j = 0; j < lsi.labels.size(); ++j) { + LabelNode label = lsi.labels.get(j); + jump = insns.indexOf(label); + merge(jump, current); + } + } else if (insnNode instanceof TableSwitchInsnNode) { + TableSwitchInsnNode tsi = (TableSwitchInsnNode) insnNode; + int jump = insns.indexOf(tsi.dflt); + merge(jump, current); + for (int j = 0; j < tsi.labels.size(); ++j) { + LabelNode label = tsi.labels.get(j); + jump = insns.indexOf(label); + merge(jump, current); + } + } else if (insnOpcode != ATHROW && (insnOpcode < IRETURN || insnOpcode > RETURN)) { + merge(insn + 1, current); + } + } + + List<TryCatchBlockNode> insnHandlers = handlers[insn]; + if (insnHandlers != null) { + for (int i = 0; i < insnHandlers.size(); ++i) { + TryCatchBlockNode tcb = insnHandlers.get(i); + int jump = insns.indexOf(tcb.handler); + handler.init(f); + handler.clearStack(); + handler.push(interpreter.newValue(ASMUtils.THROWABLE_TYPE)); + merge(jump, handler); + } + } + } catch (AnalyzerException e) { + throw new AnalyzerException(e.node, "Error at instruction " + insn + ": " + e.getMessage(), e); + } catch (Exception e) { + throw new AnalyzerException(insnNode, "Error at instruction " + insn + ": " + e.getMessage(), e); + } + } + + return frames; + } + + public Frame<V>[] getFrames() { + return frames; + } + + private void merge(final int insn, final Frame<V> frame) throws AnalyzerException { + Frame<V> oldFrame = frames[insn]; + boolean changes; + + if (oldFrame == null) { + frames[insn] = new Frame<V>(frame); + changes = true; + } else { + changes = oldFrame.merge(frame, interpreter); + } + if (changes && !queued[insn]) { + queued[insn] = true; + queue[top++] = insn; + } + } + +} + diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteFramelessAnalyzer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteFramelessAnalyzer.java new file mode 100644 index 000000000000..0a9721018862 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/LiteFramelessAnalyzer.java @@ -0,0 +1,56 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode; +import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException; + +import java.util.List; + +/** + * Specialized lite version of {@link FramelessAnalyzer}. + * No processing of Subroutines. May be used for methods without JSR/RET instructions. + * + * @author lambdamix + */ +public class LiteFramelessAnalyzer extends FramelessAnalyzer { + + @Override + protected void findSubroutine(int insn, FramelessAnalyzer.Subroutine sub, List<AbstractInsnNode> calls) throws AnalyzerException { + } + + @Override + protected void merge(final int insn, final FramelessAnalyzer.Subroutine subroutine) throws AnalyzerException { + if (!wasQueued[insn]) { + wasQueued[insn] = true; + if (!queued[insn]) { + queued[insn] = true; + queue[top++] = insn; + } + } + } + + @Override + protected void merge(final int insn, final FramelessAnalyzer.Subroutine subroutineBeforeJSR, final boolean[] access) throws AnalyzerException { + if (!wasQueued[insn]) { + wasQueued[insn] = true; + if (!queued[insn]) { + queued[insn] = true; + queue[top++] = insn; + } + } + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/OriginsAnalysis.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/OriginsAnalysis.java new file mode 100644 index 000000000000..e154bf847730 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/OriginsAnalysis.java @@ -0,0 +1,193 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import gnu.trove.TIntArrayList; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.org.objectweb.asm.Opcodes; +import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode; +import org.jetbrains.org.objectweb.asm.tree.InsnList; +import org.jetbrains.org.objectweb.asm.tree.analysis.*; + +import java.util.HashSet; +import java.util.LinkedList; + +/** + * @author lambdamix + */ +public class OriginsAnalysis { + + private static SourceInterpreter ourInterpreter = new SourceInterpreter() { + @Override + public SourceValue copyOperation(AbstractInsnNode insn, SourceValue value) { + return value; + } + }; + + private static class PreValue extends SourceValue { + final boolean local; + final int slot; + + public PreValue(boolean local, int slot, int size) { + super(size); + this.local = local; + this.slot = slot; + } + } + + private static class Location { + final boolean local; + final int slot; + + Location(boolean local, int slot) { + this.local = local; + this.slot = slot; + } + } + + private static class InsnLocation extends Location { + final int insnIndex; + + private InsnLocation(boolean local, int insnIndex, int slot) { + super(local, slot); + this.insnIndex = insnIndex; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null) return false; + InsnLocation insnLocation = (InsnLocation)o; + if (local != insnLocation.local) return false; + if (insnIndex != insnLocation.insnIndex) return false; + if (slot != insnLocation.slot) return false; + return true; + } + + @Override + public int hashCode() { + // +1 is to avoid collisions + int result = 31 * insnIndex + slot + 1; + return local ? result : -result; + } + } + + /** + * + * @param frames fixpoint of frames + * @param instructions method instructions + * @param graph method control flow graph + * @return array, array[i] == true means that the result of a method execution may originate at an i-th instruction + * @throws AnalyzerException + */ + public static boolean[] resultOrigins(Frame<Value>[] frames, InsnList instructions, ControlFlowGraph graph) throws AnalyzerException { + + TIntArrayList[] backTransitions = new TIntArrayList[instructions.size()]; + for (int i = 0; i < backTransitions.length; i++) { + backTransitions[i] = new TIntArrayList(); + } + LinkedList<InsnLocation> queue = new LinkedList<InsnLocation>(); + HashSet<InsnLocation> queued = new HashSet<InsnLocation>(); + for (int from = 0; from < instructions.size(); from++) { + for (int to : graph.transitions[from]) { + TIntArrayList froms = backTransitions[to]; + froms.add(from); + int opcode = instructions.get(to).getOpcode(); + if (opcode >= Opcodes.IRETURN && opcode <= Opcodes.ARETURN) { + InsnLocation sourceLoc = new InsnLocation(false, from, frames[to].getStackSize() - 1); + if (queued.add(sourceLoc)) { + queue.push(sourceLoc); + } + } + } + } + + boolean[] result = new boolean[instructions.size()]; + + while (!queue.isEmpty()) { + InsnLocation resultLocation = queue.pop(); + + int insnIndex = resultLocation.insnIndex; + AbstractInsnNode insn = instructions.get(insnIndex); + int opcode = insn.getOpcode(); + Location preLocation = previousLocation(frames[insnIndex], resultLocation, insn); + if (preLocation == null) { + if (opcode != Opcodes.INVOKEINTERFACE && opcode != Opcodes.GETFIELD && !(opcode >= Opcodes.IALOAD && opcode <= Opcodes.SALOAD)) { + result[insnIndex] = true; + } + } else { + TIntArrayList froms = backTransitions[insnIndex]; + for (int i = 0; i < froms.size(); i++) { + InsnLocation preILoc = new InsnLocation(preLocation.local, froms.getQuick(i), preLocation.slot); + if (queued.add(preILoc)) { + queue.push(preILoc); + } + } + } + } + + return result; + } + + /** + * + * @param frame a start frame with an interesting value + * @param location location of an interesting value *after* execution of an instruction + * @param insn an executed instruction + * @return location of an interesting value *before* execution of an instruction (in the past) or null if it is not traceable + * @throws AnalyzerException + */ + @Nullable + private static Location previousLocation(Frame<Value> frame, Location location, AbstractInsnNode insn) throws AnalyzerException { + int insnType = insn.getType(); + if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) { + return location; + } + int opCode = insn.getOpcode(); + if (location.local && !((opCode >= Opcodes.ISTORE && opCode <= Opcodes.ASTORE) || opCode == Opcodes.IINC)) { + return location; + } + Frame<SourceValue> preFrame = makePreFrame(frame); + preFrame.execute(insn, ourInterpreter); + if (location.local) { + SourceValue preVal = preFrame.getLocal(location.slot); + if (preVal instanceof PreValue) { + PreValue val = (PreValue)preVal; + return new Location(val.local, val.slot); + } + } else { + SourceValue preVal = preFrame.getStack(location.slot); + if (preVal instanceof PreValue) { + PreValue val = (PreValue)preVal; + return new Location(val.local, val.slot); + } + } + return null; + } + + private static Frame<SourceValue> makePreFrame(Frame<Value> frame) { + Frame<SourceValue> preFrame = new Frame<SourceValue>(frame.getLocals(), frame.getMaxStackSize()); + for (int i = 0; i < frame.getLocals(); i++) { + preFrame.setLocal(i, new PreValue(true, i, frame.getLocal(i).getSize())); + } + for (int i = 0; i < frame.getStackSize(); i++) { + preFrame.push(new PreValue(false, i, frame.getStack(i).getSize())); + } + return preFrame; + } +} + + diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/RichControlFlow.java b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/RichControlFlow.java new file mode 100644 index 000000000000..ea8f69c2c870 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/bytecodeAnalysis/asm/RichControlFlow.java @@ -0,0 +1,101 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.bytecodeAnalysis.asm; + +import com.intellij.codeInspection.bytecodeAnalysis.asm.ControlFlowGraph.Edge; + +import gnu.trove.TIntArrayList; +import gnu.trove.TIntHashSet; +import gnu.trove.TIntIterator; + +/** + * @author lambdamix + */ +public final class RichControlFlow { + public final ControlFlowGraph controlFlow; + public final DFSTree dfsTree; + + public RichControlFlow(ControlFlowGraph controlFlow, DFSTree dfsTree) { + this.controlFlow = controlFlow; + this.dfsTree = dfsTree; + } + + // Tarjan. Testing flow graph reducibility. + // Journal of Computer and System Sciences 9.3 (1974): 355-365. + public boolean reducible() { + if (dfsTree.back.isEmpty()) { + return true; + } + int size = controlFlow.transitions.length; + boolean[] loopEnters = dfsTree.loopEnters; + TIntHashSet[] cycleIncomings = new TIntHashSet[size]; + // really this may be array, since dfs already ensures no duplicates + TIntArrayList[] nonCycleIncomings = new TIntArrayList[size]; + int[] collapsedTo = new int[size]; + int[] queue = new int[size]; + int top; + for (int i = 0; i < size; i++) { + if (loopEnters[i]) { + cycleIncomings[i] = new TIntHashSet(); + } + nonCycleIncomings[i] = new TIntArrayList(); + collapsedTo[i] = i; + } + + // from whom back connections + for (Edge edge : dfsTree.back) { + cycleIncomings[edge.to].add(edge.from); + } + // from whom ordinary connections + for (Edge edge : dfsTree.nonBack) { + nonCycleIncomings[edge.to].add(edge.from); + } + + for (int w = size - 1; w >= 0 ; w--) { + top = 0; + // NB - it is modified later! + TIntHashSet p = cycleIncomings[w]; + if (p == null) { + continue; + } + TIntIterator iter = p.iterator(); + while (iter.hasNext()) { + queue[top++] = iter.next(); + } + + while (top > 0) { + int x = queue[--top]; + TIntArrayList incoming = nonCycleIncomings[x]; + for (int i = 0; i < incoming.size(); i++) { + int y1 = collapsedTo[incoming.getQuick(i)]; + if (!dfsTree.isDescendant(y1, w)) { + return false; + } + if (y1 != w && p.add(y1)) { + queue[top++] = y1; + } + } + } + + iter = p.iterator(); + while (iter.hasNext()) { + collapsedTo[iter.next()] = w; + } + } + + return true; + } +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ContractInference.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ContractInference.java index bd207e58a0fe..7037fac8cfea 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ContractInference.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ContractInference.java @@ -27,6 +27,7 @@ import com.intellij.psi.util.CachedValuesManager; import com.intellij.util.Function; import com.intellij.util.NullableFunction; import com.intellij.util.containers.ContainerUtil; +import com.siyeh.ig.psiutils.SideEffectChecker; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -213,6 +214,16 @@ class ContractInferenceInterpreter { } } + if (expr instanceof PsiNewExpression) { + return toContracts(states, NOT_NULL_VALUE); + } + if (expr instanceof PsiMethodCallExpression) { + PsiMethod method = ((PsiMethodCallExpression)expr).resolveMethod(); + if (method != null && NullableNotNullManager.isNotNull(method)) { + return toContracts(states, NOT_NULL_VALUE); + } + } + final ValueConstraint constraint = getLiteralConstraint(expr); if (constraint != null) { return toContracts(states, constraint); @@ -315,7 +326,7 @@ class ContractInferenceInterpreter { private List<MethodContract> visitStatements(List<ValueConstraint[]> states, PsiStatement... statements) { List<MethodContract> result = ContainerUtil.newArrayList(); for (PsiStatement statement : statements) { - if (statement instanceof PsiBlockStatement && ((PsiBlockStatement)statement).getCodeBlock().getStatements().length == 1) { + if (statement instanceof PsiBlockStatement) { result.addAll(visitStatements(states, ((PsiBlockStatement)statement).getCodeBlock().getStatements())); } else if (statement instanceof PsiIfStatement) { @@ -353,12 +364,36 @@ class ContractInferenceInterpreter { List<MethodContract> conditionResults = visitExpression(states, ((PsiAssertStatement)statement).getAssertCondition()); result.addAll(toContracts(antecedentsOf(filterReturning(conditionResults, FALSE_VALUE)), THROW_EXCEPTION)); } + else if (statement instanceof PsiDeclarationStatement && !mayHaveSideEffects((PsiDeclarationStatement)statement)) { + continue; + } + else if (statement instanceof PsiDoWhileStatement) { + result.addAll(visitStatements(states, ((PsiDoWhileStatement)statement).getBody())); + } + else if (statement instanceof PsiTryStatement) { + PsiCodeBlock block = ((PsiTryStatement)statement).getTryBlock(); + if (block != null) { + result.addAll(visitStatements(states, block.getStatements())); + } + } break; // visit only the first statement unless it's 'if' whose 'then' always returns and the next statement is effectively 'else' } return result; } + private static boolean mayHaveSideEffects(PsiDeclarationStatement statement) { + for (PsiElement element : statement.getDeclaredElements()) { + if (element instanceof PsiVariable) { + PsiExpression initializer = ((PsiVariable)element).getInitializer(); + if (initializer != null && SideEffectChecker.mayHaveSideEffects(initializer)) { + return true; + } + } + } + return false; + } + private static boolean alwaysReturns(@Nullable PsiStatement statement) { if (statement instanceof PsiReturnStatement || statement instanceof PsiThrowStatement) return true; if (statement instanceof PsiBlockStatement) { @@ -381,6 +416,7 @@ class ContractInferenceInterpreter { if (expr.textMatches(PsiKeyword.TRUE)) return TRUE_VALUE; if (expr.textMatches(PsiKeyword.FALSE)) return FALSE_VALUE; if (expr.textMatches(PsiKeyword.NULL)) return NULL_VALUE; + if (((PsiLiteralExpression)expr).getValue() instanceof String) return NOT_NULL_VALUE; } return null; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java index 7ef19f2b73d0..7539d7195701 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java @@ -591,12 +591,14 @@ public class ControlFlowAnalyzer extends JavaElementVisitor { generateBoxingUnboxingInstructionFor(caseExpression, PsiType.INT); final PsiClass psiClass = PsiUtil.resolveClassInType(caseExpression.getType()); - if (psiClass != null && psiClass.isEnum()) { + if (psiClass != null) { addInstruction(new FieldReferenceInstruction(caseExpression, "switch statement expression")); - enumValues = new HashSet<PsiEnumConstant>(); - for (PsiField f : psiClass.getFields()) { - if (f instanceof PsiEnumConstant) { - enumValues.add((PsiEnumConstant)f); + if (psiClass.isEnum()) { + enumValues = new HashSet<PsiEnumConstant>(); + for (PsiField f : psiClass.getFields()) { + if (f instanceof PsiEnumConstant) { + enumValues.add((PsiEnumConstant)f); + } } } } else { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java index 1b6d1dfedfec..3f0caf47679e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java @@ -640,6 +640,13 @@ public class DfaMemoryStateImpl implements DfaMemoryState { return true; } + if (dfaLeft == dfaRight) { + if (dfaLeft instanceof DfaVariableValue && ((DfaVariableValue)dfaLeft).containsCalls()) { + return true; + } + return !isNegated; + } + if (isNull(dfaLeft) && isNotNull(dfaRight) || isNull(dfaRight) && isNotNull(dfaLeft)) { return isNegated; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java index ec9e02fce92d..7ebce779c3a8 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java @@ -155,7 +155,7 @@ public class DfaExpressionFactory { @Nullable private PsiVariable getArrayIndexVariable(@Nullable PsiExpression indexExpression) { Object constant = JavaConstantExpressionEvaluator.computeConstantExpression(indexExpression, false); - if (constant instanceof Integer) { + if (constant instanceof Integer && ((Integer)constant).intValue() >= 0) { PsiVariable mockVar = myMockIndices.get(constant); if (mockVar == null) { mockVar = JavaPsiFacade.getElementFactory(indexExpression.getProject()).createField("$array$index$" + constant, PsiType.INT); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaVariableValue.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaVariableValue.java index 3030bef32934..840103f5c993 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaVariableValue.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaVariableValue.java @@ -221,4 +221,8 @@ public class DfaVariableValue extends DfaValue { return true; } + public boolean containsCalls() { + return myVariable instanceof PsiMethod || myQualifier != null && myQualifier.containsCalls(); + } + } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/inheritance/ImplementedAtRuntimeCondition.java b/java/java-analysis-impl/src/com/intellij/codeInspection/inheritance/ImplementedAtRuntimeCondition.java new file mode 100644 index 000000000000..55918450f481 --- /dev/null +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/inheritance/ImplementedAtRuntimeCondition.java @@ -0,0 +1,29 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.codeInspection.inheritance; + +import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.psi.PsiClass; +import org.jetbrains.annotations.NotNull; + +/** + * @author nik + */ +public abstract class ImplementedAtRuntimeCondition { + public static final ExtensionPointName<ImplementedAtRuntimeCondition> EP_NAME = ExtensionPointName.create("com.intellij.codeInsight.implementedAtRuntime"); + + public abstract boolean isImplementedAtRuntime(@NotNull PsiClass psiClass); +} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/javaDoc/JavaDocLocalInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/javaDoc/JavaDocLocalInspectionBase.java index 5d6c4bcb59a1..36d7bc2f17ef 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/javaDoc/JavaDocLocalInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/javaDoc/JavaDocLocalInspectionBase.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -540,7 +540,7 @@ public class JavaDocLocalInspectionBase extends BaseJavaBatchLocalInspectionTool } if (required && superMethods.length == 0 && isTagRequired(psiMethod, "@throws") && psiMethod.getThrowsList().getReferencedTypes().length > 0) { - final Map<PsiClassType, PsiClass> declaredExceptions = new HashMap<PsiClassType, PsiClass>(); + final Map<PsiClassType, PsiClass> declaredExceptions = new LinkedHashMap<PsiClassType, PsiClass>(); final PsiClassType[] classTypes = psiMethod.getThrowsList().getReferencedTypes(); for (PsiClassType classType : classTypes) { final PsiClass psiClass = classType.resolve(); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java index f3884b30efeb..e51101c98460 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java @@ -45,7 +45,7 @@ public class UnnecessaryModuleDependencyInspection extends GlobalInspectionTool if (refEntity instanceof RefModule){ final RefModule refModule = (RefModule)refEntity; final Module module = refModule.getModule(); - if (module.isDisposed()) return CommonProblemDescriptor.EMPTY_ARRAY; + if (module.isDisposed() || !scope.containsModule(module)) return CommonProblemDescriptor.EMPTY_ARRAY; final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module); final OrderEntry[] declaredDependencies = moduleRootManager.getOrderEntries(); final Module[] declaredModuleDependencies = moduleRootManager.getDependencies(); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java index 4db11dc0b0d0..6352731e322f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java @@ -70,7 +70,7 @@ public class UnusedLibrariesInspection extends GlobalInspectionTool { if (refEntity instanceof RefModule) { final RefModule refModule = (RefModule)refEntity; final Module module = refModule.getModule(); - if (module.isDisposed()) return CommonProblemDescriptor.EMPTY_ARRAY; + if (module.isDisposed() || !scope.containsModule(module)) return CommonProblemDescriptor.EMPTY_ARRAY; final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module); final Set<VirtualFile> usedRoots = refModule.getUserData(UnusedLibraryGraphAnnotator.USED_LIBRARY_ROOTS); diff --git a/java/java-impl/src/com/intellij/analysis/BaseClassesAnalysisAction.java b/java/java-impl/src/com/intellij/analysis/BaseClassesAnalysisAction.java index 383e62d40b47..42d3722fbaf3 100644 --- a/java/java-impl/src/com/intellij/analysis/BaseClassesAnalysisAction.java +++ b/java/java-impl/src/com/intellij/analysis/BaseClassesAnalysisAction.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -57,6 +57,9 @@ public abstract class BaseClassesAnalysisAction extends BaseAnalysisAction { ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { + if (project.isDisposed()) { + return; + } if (!upToDate) { final int i = Messages.showYesNoCancelDialog(getProject(), AnalysisScopeBundle.message("recompile.confirmation.message"), AnalysisScopeBundle.message("project.is.out.of.date"), Messages.getWarningIcon()); diff --git a/java/java-impl/src/com/intellij/application/options/JavaIndentOptionsProvider.java b/java/java-impl/src/com/intellij/application/options/JavaIndentOptionsProvider.java deleted file mode 100644 index d71b71819c84..000000000000 --- a/java/java-impl/src/com/intellij/application/options/JavaIndentOptionsProvider.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright 2000-2009 JetBrains s.r.o. - * - * 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.intellij.application.options; - -import com.intellij.psi.codeStyle.CommonCodeStyleSettings; -import com.intellij.psi.codeStyle.FileTypeIndentOptionsProvider; -import com.intellij.psi.PsiFile; -import com.intellij.psi.util.PsiUtil; -import com.intellij.openapi.fileTypes.FileType; -import com.intellij.openapi.fileTypes.StdFileTypes; -import com.intellij.pom.java.LanguageLevel; -import org.jetbrains.annotations.NonNls; - -/** - * @author yole - */ -public class JavaIndentOptionsProvider implements FileTypeIndentOptionsProvider { - public CommonCodeStyleSettings.IndentOptions createIndentOptions() { - return new CommonCodeStyleSettings.IndentOptions(); - } - - public FileType getFileType() { - return StdFileTypes.JAVA; - } - - public IndentOptionsEditor createOptionsEditor() { - return new JavaIndentOptionsEditor(); - } - - @NonNls - public String getPreviewText() { - return "public class Foo {\n" + - " public int[] X = new int[] { 1, 3, 5,\n" + - " 7, 9, 11};\n" + - " public void foo(boolean a, int x,\n" + - " int y, int z) {\n" + - " a = x == 0 &&\n" + - " (y == 0 ||\n" + - " z <= 4) &&\n" + - " z >= 0;" + - " label1: do {\n" + - " try {\n" + - " if(x > 0) {\n" + - " int someVariable = a ? \n" + - " x : \n" + - " y;\n" + - " } else if (x < 0) {\n" + - " int someVariable = (y +\n" + - " z\n" + - " );\n" + - " someVariable = x = \n" + - " x +\n" + - " y;\n" + - " } else {\n" + - " label2:\n" + - " for (int i = 0;\n" + - " i < 5;\n" + - " i++) doSomething(i);\n" + - " }\n" + - " switch(a) {\n" + - " case 0: \n" + - " doCase0();\n" + - " break;\n" + - " default: \n" + - " doDefault();\n" + - " }\n" + - " }\n" + - " catch(Exception e) {\n" + - " processException(e.getMessage(),\n" + - " x + y, z, a);\n" + - " }\n" + - " finally {\n" + - " processFinally();\n" + - " }\n" + - " }while(true);\n" + - "\n" + - " if (2 < 3) return;\n" + - " if (3 < 4)\n" + - " return;\n" + - " do x++ while (x < 10000);\n" + - " while (x < 50000) x++;\n" + - " for (int i = 0; i < 5; i++) System.out.println(i);\n" + - " }\n" + - " private class InnerClass implements I1,\n" + - " I2 {\n" + - " public void bar() throws E1,\n" + - " E2 {\n" + - " }\n" + - " }\n" + - "}"; - } - - public void prepareForReformat(final PsiFile psiFile) { - psiFile.putUserData(PsiUtil.FILE_LANGUAGE_LEVEL_KEY, LanguageLevel.HIGHEST); - } -} diff --git a/java/java-impl/src/com/intellij/codeInsight/CodeInsightUtil.java b/java/java-impl/src/com/intellij/codeInsight/CodeInsightUtil.java index 9f2b486164ce..ca7c26dbc811 100644 --- a/java/java-impl/src/com/intellij/codeInsight/CodeInsightUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/CodeInsightUtil.java @@ -16,6 +16,7 @@ package com.intellij.codeInsight; import com.intellij.codeInsight.completion.AllClassesGetter; +import com.intellij.codeInsight.completion.CompletionUtil; import com.intellij.codeInsight.completion.JavaCompletionUtil; import com.intellij.codeInsight.completion.PrefixMatcher; import com.intellij.lang.Language; @@ -33,21 +34,21 @@ import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.ClassInheritorsSearch; import com.intellij.psi.tree.IElementType; -import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.psi.util.PsiUtil; -import com.intellij.psi.util.PsiUtilCore; -import com.intellij.psi.util.TypeConversionUtil; +import com.intellij.psi.util.*; import com.intellij.psi.util.proximity.PsiProximityComparator; import com.intellij.refactoring.util.RefactoringUtil; import com.intellij.util.Consumer; import com.intellij.util.FilteredQuery; import com.intellij.util.Processor; import com.intellij.util.Query; -import com.intellij.psi.util.FileTypeUtils; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Set; public class CodeInsightUtil { @Nullable @@ -283,6 +284,11 @@ public class CodeInsightUtil { final Processor<PsiClass> inheritorsProcessor = createInheritorsProcessor(context, baseType, arrayDim, getRawSubtypes, consumer, baseClass, baseSubstitutor); + + addContextTypeArguments(context, baseType, inheritorsProcessor); + + if (baseClass.hasModifierProperty(PsiModifier.FINAL)) return; + if (matcher.getPrefix().length() > 2) { AllClassesGetter.processJavaClasses(matcher, context.getProject(), scope, new Processor<PsiClass>() { @Override @@ -307,6 +313,30 @@ public class CodeInsightUtil { } + private static void addContextTypeArguments(final PsiElement context, + final PsiClassType baseType, + final Processor<PsiClass> inheritorsProcessor) { + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + Set<String> usedNames = ContainerUtil.newHashSet(); + PsiElementFactory factory = JavaPsiFacade.getElementFactory(context.getProject()); + PsiElement each = context; + while (true) { + PsiTypeParameterListOwner typed = PsiTreeUtil.getParentOfType(each, PsiTypeParameterListOwner.class); + if (typed == null) break; + for (PsiTypeParameter parameter : typed.getTypeParameters()) { + if (baseType.isAssignableFrom(factory.createType(parameter)) && usedNames.add(parameter.getName())) { + inheritorsProcessor.process(CompletionUtil.getOriginalOrSelf(parameter)); + } + } + + each = typed; + } + } + }); + } + public static Processor<PsiClass> createInheritorsProcessor(final PsiElement context, final PsiClassType baseType, final int arrayDim, final boolean getRawSubtypes, diff --git a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsLineMarkerProvider.java b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsLineMarkerProvider.java index 182f79c94bce..e373207222ea 100644 --- a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsLineMarkerProvider.java +++ b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsLineMarkerProvider.java @@ -91,10 +91,27 @@ public class ExternalAnnotationsLineMarkerProvider implements LineMarkerProvider private static boolean hasNonCodeAnnotations(@NotNull PsiModifierListOwner element) { Project project = element.getProject(); PsiAnnotation[] externalAnnotations = ExternalAnnotationsManager.getInstance(project).findExternalAnnotations(element); - if (externalAnnotations != null && externalAnnotations.length > 0) { - return true; + if (externalAnnotations != null) { + for (PsiAnnotation annotation : externalAnnotations) { + if (isVisibleAnnotation(annotation)) { + return true; + } + } + } + for (PsiAnnotation annotation : InferredAnnotationsManager.getInstance(project).findInferredAnnotations(element)) { + if (isVisibleAnnotation(annotation)) { + return true; + } } - return InferredAnnotationsManager.getInstance(project).findInferredAnnotations(element).length > 0; + return false; + } + + private static boolean isVisibleAnnotation(@NotNull PsiAnnotation annotation) { + PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement(); + if (ref == null) return true; + + PsiElement target = ref.resolve(); + return !(target instanceof PsiClass) || JavaDocInfoGenerator.isDocumentedAnnotationType((PsiClass)target); } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionData.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionData.java index 5ac14956fe4c..f5e43aa7bcec 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionData.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionData.java @@ -484,7 +484,7 @@ public class JavaCompletionData extends JavaAwareCompletionData { } } - if ((isInsideParameterList(position) || isAtResourceVariableStart(position)) && + if ((isInsideParameterList(position) || isAtResourceVariableStart(position) || isAtCatchVariableStart(position)) && !psiElement().afterLeaf(PsiKeyword.FINAL).accepts(position) && !AFTER_DOT.accepts(position)) { result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE_BEFORE_WORD)); @@ -673,6 +673,10 @@ public class JavaCompletionData extends JavaAwareCompletionData { return psiElement().insideStarting(psiElement(PsiTypeElement.class).withParent(PsiResourceList.class)).accepts(position); } + private static boolean isAtCatchVariableStart(PsiElement position) { + return psiElement().insideStarting(psiElement(PsiTypeElement.class).withParent(PsiCatchSection.class)).accepts(position); + } + private static void addBreakContinue(CompletionResultSet result, PsiElement position) { PsiLoopStatement loop = PsiTreeUtil.getParentOfType(position, PsiLoopStatement.class); diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java index d144a67fcb69..5a18a4b42826 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java @@ -278,10 +278,12 @@ public class JavaCompletionSorting { @NotNull @Override - public Comparable weigh(@NotNull LookupElement item) { + public MyResult weigh(@NotNull LookupElement item) { final Object object = item.getObject(); if (object instanceof PsiClass) { + if (object instanceof PsiTypeParameter) return MyResult.typeParameter; + if (myTypeParameter != null && object.equals(PsiUtil.resolveClassInType(TypeConversionUtil.typeParameterErasure(myTypeParameter)))) { return MyResult.exactlyExpected; } @@ -340,6 +342,7 @@ public class JavaCompletionSorting { private enum MyResult { expectedNoSelect, + typeParameter, exactlyDefault, ofDefaultType, exactlyExpected, diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java index 1112738c5464..8cc9d06aed04 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionUtil.java @@ -55,6 +55,7 @@ import com.intellij.util.NullableFunction; import com.intellij.util.PairConsumer; import com.intellij.util.PairFunction; import com.intellij.util.containers.ContainerUtil; +import com.siyeh.ig.psiutils.SideEffectChecker; import gnu.trove.THashSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -606,21 +607,7 @@ public class JavaCompletionUtil { } public static boolean mayHaveSideEffects(@Nullable final PsiElement element) { - if (element == null) return false; - if (element instanceof PsiMethodCallExpression || element instanceof PsiNewExpression) return true; - if (element instanceof PsiTypeCastExpression) { - return mayHaveSideEffects(((PsiTypeCastExpression)element).getOperand()); - } - if (element instanceof PsiArrayAccessExpression) { - return mayHaveSideEffects(((PsiArrayAccessExpression)element).getArrayExpression()); - } - if (element instanceof PsiJavaCodeReferenceElement) { - return mayHaveSideEffects(((PsiJavaCodeReferenceElement)element).getQualifier()); - } - if (element instanceof PsiParenthesizedExpression) { - return mayHaveSideEffects(((PsiParenthesizedExpression)element).getExpression()); - } - return true; + return element instanceof PsiExpression && SideEffectChecker.mayHaveSideEffects((PsiExpression)element); } public static void insertClassReference(@NotNull PsiClass psiClass, @NotNull PsiFile file, int offset) { @@ -836,13 +823,16 @@ public class JavaCompletionUtil { //need to shorten references in type argument list public static void shortenReference(final PsiFile file, final int offset) throws IncorrectOperationException { - final PsiDocumentManager manager = PsiDocumentManager.getInstance(file.getProject()); - manager.commitDocument(manager.getDocument(file)); + Project project = file.getProject(); + final PsiDocumentManager manager = PsiDocumentManager.getInstance(project); + Document document = manager.getDocument(file); + manager.commitDocument(document); final PsiReference ref = file.findReferenceAt(offset); if (ref != null) { PsiElement element = ref.getElement(); if (element != null) { - JavaCodeStyleManager.getInstance(file.getProject()).shortenClassReferences(element); + JavaCodeStyleManager.getInstance(project).shortenClassReferences(element); + PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(document); } } } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java index 351eca4857fd..456c06fe8756 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java @@ -26,6 +26,7 @@ import com.intellij.psi.infos.CandidateInfo; import com.intellij.psi.util.MethodSignature; import com.intellij.psi.util.PsiFormatUtil; import com.intellij.psi.util.PsiFormatUtilBase; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.ui.RowIcon; import com.intellij.util.VisibilityUtil; import com.intellij.util.containers.ContainerUtil; @@ -98,13 +99,12 @@ public class JavaGenerateMemberCompletionContributor { PsiClass baseClass = baseMethod.getContainingClass(); PsiSubstitutor substitutor = candidate.getSubstitutor(); if (!baseMethod.isConstructor() && baseClass != null && addedSignatures.add(baseMethod.getSignature(substitutor))) { - result.addElement(createOverridingLookupElement(parent, implemented, baseMethod, baseClass, substitutor)); + result.addElement(createOverridingLookupElement(implemented, baseMethod, baseClass, substitutor)); } } } - private static LookupElementBuilder createOverridingLookupElement(final PsiClass parent, - boolean implemented, + private static LookupElementBuilder createOverridingLookupElement(boolean implemented, final PsiMethod baseMethod, PsiClass baseClass, PsiSubstitutor substitutor) { @@ -117,6 +117,9 @@ public class JavaGenerateMemberCompletionContributor { public void handleInsert(InsertionContext context, LookupElement item) { removeLookupString(context); + final PsiClass parent = PsiTreeUtil.findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), PsiClass.class, false); + if (parent == null) return; + List<PsiMethod> prototypes = OverrideImplementUtil.overrideOrImplementMethod(parent, baseMethod, false); insertGenerationInfos(context, OverrideImplementUtil.convert2GenerationInfos(prototypes)); } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaInheritorsGetter.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaInheritorsGetter.java index 1a14010ec834..a503de4d93a5 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaInheritorsGetter.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaInheritorsGetter.java @@ -229,10 +229,7 @@ public class JavaInheritorsGetter extends CompletionProvider<CompletionParameter //long for (final PsiClassType type : expectedClassTypes) { - final PsiClass psiClass = type.resolve(); - if (psiClass != null && !psiClass.hasModifierProperty(PsiModifier.FINAL)) { - CodeInsightUtil.processSubTypes(type, parameters.getPosition(), false, matcher, consumer); - } + CodeInsightUtil.processSubTypes(type, parameters.getPosition(), false, matcher, consumer); } } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java index a1d4a6f8ac81..bb45d770dea1 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java @@ -414,7 +414,7 @@ public class JavaMemberNameCompletionContributor extends CompletionContributor { outer: for (int i = 0; i < strings.length; i++) { String name = strings[i]; - if (!matcher.prefixMatches(name) || !JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(name, LanguageLevel.HIGHEST)) { + if (!matcher.prefixMatches(name) || !PsiNameHelper.getInstance(project).isIdentifier(name, LanguageLevel.HIGHEST)) { continue; } diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java index 61d8abe18368..d5e04ce3f95a 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaSmartCompletionContributor.java @@ -158,8 +158,9 @@ public class JavaSmartCompletionContributor extends CompletionContributor { @Override public void consume(PsiType type) { final PsiClass psiClass = PsiUtil.resolveClassInType(type); - if (psiClass == null) return; + if (psiClass == null || psiClass instanceof PsiTypeParameter) return; + //noinspection SuspiciousMethodCalls if (expectedClassTypes.contains(type)) return; result.addElement(createInstanceofLookupElement(psiClass, parameterizedTypes)); diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java index dfc7169a2777..f74e4431d451 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java @@ -15,7 +15,6 @@ */ package com.intellij.codeInsight.daemon.impl; -import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.editor.ElementColorProvider; import com.intellij.psi.*; import com.intellij.psi.impl.JavaConstantExpressionEvaluator; @@ -32,7 +31,12 @@ import java.awt.*; public class JavaColorProvider implements ElementColorProvider { @Override public Color getColorFrom(@NotNull PsiElement element) { - if (element instanceof PsiNewExpression && element.getLanguage() == JavaLanguage.INSTANCE) { + return getJavaColorFromExpression(element); + } + + @Nullable + public static Color getJavaColorFromExpression(@Nullable PsiElement element) { + if (element instanceof PsiNewExpression) { final PsiNewExpression expr = (PsiNewExpression)element; final PsiType type = expr.getType(); if (type != null) { diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateAnnotationMethodFromUsageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateAnnotationMethodFromUsageFix.java index 487b6f07c707..5027752e47d0 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateAnnotationMethodFromUsageFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateAnnotationMethodFromUsageFix.java @@ -44,7 +44,7 @@ public class CreateAnnotationMethodFromUsageFix extends CreateFromUsageBaseFix { if (call == null || !call.isValid()) return false; String name = call.getName(); - if (name == null || !JavaPsiFacade.getInstance(call.getProject()).getNameHelper().isIdentifier(name)) return false; + if (name == null || !PsiNameHelper.getInstance(call.getProject()).isIdentifier(name)) return false; if (getAnnotationValueType(call.getValue()) == null) return false; setText(QuickFixBundle.message("create.method.from.usage.text", name)); return true; diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreatePropertyFromUsageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreatePropertyFromUsageFix.java index c36c25f4b47b..d1a6031c8bf8 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreatePropertyFromUsageFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreatePropertyFromUsageFix.java @@ -269,7 +269,7 @@ public class CreatePropertyFromUsageFix extends CreateFromUsageBaseFix implement @Override public void run() { String fieldName = state.getVariableValue(FIELD_VARIABLE).getText(); - if (!JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(fieldName)) return; + if (!PsiNameHelper.getInstance(project).isIdentifier(fieldName)) return; String fieldType = state.getVariableValue(TYPE_VARIABLE).getText(); PsiElement element = file.findElementAt(editor.getCaretModel().getOffset()); diff --git a/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java b/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java index e2dedf5ea3ec..5d2acb275291 100644 --- a/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/editorActions/JavaTypedHandler.java @@ -18,6 +18,9 @@ package com.intellij.codeInsight.editorActions; import com.intellij.codeInsight.AutoPopupController; import com.intellij.codeInsight.CodeInsightSettings; import com.intellij.codeInsight.completion.JavaClassReferenceCompletionContributor; +import com.intellij.codeInsight.editorActions.smartEnter.JavaSmartEnterProcessor; +import com.intellij.openapi.command.CommandProcessor; +import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.editor.EditorModificationUtil; import com.intellij.openapi.editor.ex.EditorEx; @@ -125,11 +128,24 @@ public class JavaTypedHandler extends TypedHandlerDelegate { if (iterator.atEnd() || iterator.getTokenType() == JavaTokenType.RBRACKET || iterator.getTokenType() == JavaTokenType.EQ) { return Result.CONTINUE; } - PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument()); + Document doc = editor.getDocument(); + PsiDocumentManager.getInstance(project).commitDocument(doc); final PsiElement leaf = file.findElementAt(offset); if (PsiTreeUtil.getParentOfType(leaf, PsiArrayInitializerExpression.class, false, PsiCodeBlock.class, PsiMember.class) != null) { return Result.CONTINUE; } + PsiElement st = leaf != null ? leaf.getParent() : null; + PsiElement prev = offset > 1 ? file.findElementAt(offset - 1) : null; + if (CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET && isRparenth(leaf) && + (st instanceof PsiWhileStatement || st instanceof PsiIfStatement) && shouldInsertStatementBody(st, doc, prev)) { + CommandProcessor.getInstance().executeCommand(project, new Runnable() { + @Override + public void run() { + new JavaSmartEnterProcessor().process(project, editor, file); + } + }, "Insert block statement", null); + return Result.STOP; + } if (PsiTreeUtil.getParentOfType(leaf, PsiCodeBlock.class, false, PsiMember.class) != null) { EditorModificationUtil.insertStringAtCaret(editor, "{"); TypedHandler.indentOpenedBrace(project, editor); @@ -140,6 +156,26 @@ public class JavaTypedHandler extends TypedHandlerDelegate { return Result.CONTINUE; } + private static boolean shouldInsertStatementBody(@NotNull PsiElement statement, @NotNull Document doc, @Nullable PsiElement prev) { + PsiStatement block = statement instanceof PsiWhileStatement ? ((PsiWhileStatement)statement).getBody() : ((PsiIfStatement)statement).getThenBranch(); + PsiExpression condition = PsiTreeUtil.getChildOfType(statement, PsiExpression.class); + PsiExpression latestExpression = PsiTreeUtil.getParentOfType(prev, PsiExpression.class); + if (latestExpression instanceof PsiNewExpression && ((PsiNewExpression)latestExpression).getAnonymousClass() == null) return false; + return !(block instanceof PsiBlockStatement) && (block == null || startLine(doc, block) != startLine(doc, statement) || condition == null); + } + + private static boolean isRparenth(@Nullable PsiElement leaf) { + if (leaf == null) return false; + if (leaf.getNode().getElementType() == JavaTokenType.RPARENTH) return true; + PsiElement next = PsiTreeUtil.nextVisibleLeaf(leaf); + if (next == null) return false; + return next.getNode().getElementType() == JavaTokenType.RPARENTH; + } + + private static int startLine(@NotNull Document doc, @NotNull PsiElement psiElement) { + return doc.getLineNumber(psiElement.getTextRange().getStartOffset()); + } + @Override public Result charTyped(final char c, final Project project, @NotNull final Editor editor, @NotNull final PsiFile file) { if (myJavaLTTyped) { diff --git a/java/java-impl/src/com/intellij/codeInsight/folding/impl/JavaElementSignatureProvider.java b/java/java-impl/src/com/intellij/codeInsight/folding/impl/JavaElementSignatureProvider.java index 1d54cca4833b..54a47f54b6ec 100644 --- a/java/java-impl/src/com/intellij/codeInsight/folding/impl/JavaElementSignatureProvider.java +++ b/java/java-impl/src/com/intellij/codeInsight/folding/impl/JavaElementSignatureProvider.java @@ -181,7 +181,7 @@ public class JavaElementSignatureProvider extends AbstractElementSignatureProvid else if (type.equals("class")) { String name = tokenizer.nextToken(); - PsiNameHelper nameHelper = JavaPsiFacade.getInstance(file.getProject()).getNameHelper(); + PsiNameHelper nameHelper = PsiNameHelper.getInstance(file.getProject()); if (nameHelper.isIdentifier(name)) { int index = 0; try { diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersHandlerBase.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersHandlerBase.java index f1652470218c..34008a0a72ea 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersHandlerBase.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersHandlerBase.java @@ -39,11 +39,13 @@ import com.intellij.openapi.util.TextRange; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.search.LocalSearchScope; +import com.intellij.util.Function; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import javax.swing.*; import java.util.ArrayList; import java.util.List; diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java index f7972b82c12b..936f587d5fb7 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java @@ -607,7 +607,7 @@ public class GenerateMembersUtil { } @Nullable - private static PsiMethod annotateOnOverrideImplement(@Nullable PsiClass targetClass, @Nullable PsiMethod generated) { + public static PsiMethod annotateOnOverrideImplement(@Nullable PsiClass targetClass, @Nullable PsiMethod generated) { if (generated == null || targetClass == null) return generated; if (CodeStyleSettingsManager.getSettings(targetClass.getProject()).INSERT_OVERRIDE_ANNOTATION) { diff --git a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExceptionsHandlerFactory.java b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExceptionsHandlerFactory.java index d142161400c9..c7bd10cc2b39 100644 --- a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExceptionsHandlerFactory.java +++ b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExceptionsHandlerFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,11 +16,11 @@ package com.intellij.codeInsight.highlighting; import com.intellij.codeInsight.ExceptionUtil; -import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.featureStatistics.FeatureUsageTracker; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.util.Condition; import com.intellij.psi.*; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; @@ -29,11 +29,9 @@ import java.util.Collection; /** * @author yole */ -public class HighlightExceptionsHandlerFactory implements HighlightUsagesHandlerFactory { +public class HighlightExceptionsHandlerFactory extends HighlightUsagesHandlerFactoryBase { @Override - public HighlightUsagesHandlerBase createHighlightUsagesHandler(final Editor editor, final PsiFile file) { - int offset = TargetElementUtilBase.adjustOffset(file, editor.getDocument(), editor.getCaretModel().getOffset()); - PsiElement target = file.findElementAt(offset); + public HighlightUsagesHandlerBase createHighlightUsagesHandler(@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword) { PsiElement parent = target.getParent(); if (PsiKeyword.TRY.equals(target.getText()) && parent instanceof PsiTryStatement) { diff --git a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExitPointsHandlerFactory.java b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExitPointsHandlerFactory.java index 4a05420dd354..f9f19a4c26ee 100644 --- a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExitPointsHandlerFactory.java +++ b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightExitPointsHandlerFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,20 +15,18 @@ */ package com.intellij.codeInsight.highlighting; -import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.editor.Editor; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiKeyword; +import org.jetbrains.annotations.NotNull; /** * @author yole */ -public class HighlightExitPointsHandlerFactory implements HighlightUsagesHandlerFactory { +public class HighlightExitPointsHandlerFactory extends HighlightUsagesHandlerFactoryBase { @Override - public HighlightUsagesHandlerBase createHighlightUsagesHandler(final Editor editor, final PsiFile file) { - int offset = TargetElementUtilBase.adjustOffset(file, editor.getDocument(), editor.getCaretModel().getOffset()); - PsiElement target = file.findElementAt(offset); + public HighlightUsagesHandlerBase createHighlightUsagesHandler(@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword) { if (PsiKeyword.RETURN.equals(target.getText()) || PsiKeyword.THROW.equals(target.getText())) { return new HighlightExitPointsHandler(editor, file, target); diff --git a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightImportedElementsHandlerFactory.java b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightImportedElementsHandlerFactory.java index def7501d93e5..b096aeb40a89 100644 --- a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightImportedElementsHandlerFactory.java +++ b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightImportedElementsHandlerFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,21 +15,19 @@ */ package com.intellij.codeInsight.highlighting; -import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.editor.Editor; import com.intellij.psi.*; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; /** * @author Bas Leijdekkers */ -public class HighlightImportedElementsHandlerFactory implements HighlightUsagesHandlerFactory { +public class HighlightImportedElementsHandlerFactory extends HighlightUsagesHandlerFactoryBase { @Nullable @Override - public HighlightUsagesHandlerBase createHighlightUsagesHandler(Editor editor, PsiFile file) { - final int offset = TargetElementUtilBase.adjustOffset(file, editor.getDocument(), editor.getCaretModel().getOffset()); - final PsiElement target = file.findElementAt(offset); + public HighlightUsagesHandlerBase createHighlightUsagesHandler(@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (!(target instanceof PsiKeyword) || !PsiKeyword.IMPORT.equals(target.getText())) { return null; } diff --git a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightOverridingMethodsHandlerFactory.java b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightOverridingMethodsHandlerFactory.java index bc9c0a47ce6f..088a17231d33 100644 --- a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightOverridingMethodsHandlerFactory.java +++ b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightOverridingMethodsHandlerFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,18 +15,16 @@ */ package com.intellij.codeInsight.highlighting; -import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.editor.Editor; import com.intellij.psi.*; +import org.jetbrains.annotations.NotNull; /** * @author yole */ -public class HighlightOverridingMethodsHandlerFactory implements HighlightUsagesHandlerFactory { +public class HighlightOverridingMethodsHandlerFactory extends HighlightUsagesHandlerFactoryBase { @Override - public HighlightUsagesHandlerBase createHighlightUsagesHandler(final Editor editor, final PsiFile file) { - int offset = TargetElementUtilBase.adjustOffset(file, editor.getDocument(), editor.getCaretModel().getOffset()); - final PsiElement target = file.findElementAt(offset); + public HighlightUsagesHandlerBase createHighlightUsagesHandler(@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword && (PsiKeyword.EXTENDS.equals(target.getText()) || PsiKeyword.IMPLEMENTS.equals(target.getText()))) { PsiElement parent = target.getParent(); if (!(parent instanceof PsiReferenceList)) return null; diff --git a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightSuppressedWarningsFactory.java b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightSuppressedWarningsFactory.java index df847437854f..4182f003e1bd 100644 --- a/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightSuppressedWarningsFactory.java +++ b/java/java-impl/src/com/intellij/codeInsight/highlighting/HighlightSuppressedWarningsFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,7 +15,6 @@ */ package com.intellij.codeInsight.highlighting; -import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.vfs.VirtualFile; @@ -24,15 +23,14 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; /** * @author yole */ -public class HighlightSuppressedWarningsFactory implements HighlightUsagesHandlerFactory { +public class HighlightSuppressedWarningsFactory extends HighlightUsagesHandlerFactoryBase { @Override - public HighlightUsagesHandlerBase createHighlightUsagesHandler(final Editor editor, final PsiFile file) { - int offset = TargetElementUtilBase.adjustOffset(file, editor.getDocument(), editor.getCaretModel().getOffset()); - final PsiElement target = file.findElementAt(offset); + public HighlightUsagesHandlerBase createHighlightUsagesHandler(@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(target, PsiAnnotation.class); if (annotation != null && Comparing.strEqual(SuppressWarnings.class.getName(), annotation.getQualifiedName())) { final VirtualFile virtualFile = file.getVirtualFile(); diff --git a/java/java-impl/src/com/intellij/codeInsight/hint/actions/ShowSiblingsAction.java b/java/java-impl/src/com/intellij/codeInsight/hint/actions/ShowSiblingsAction.java index 8b839e522c24..f46ebb4005ba 100644 --- a/java/java-impl/src/com/intellij/codeInsight/hint/actions/ShowSiblingsAction.java +++ b/java/java-impl/src/com/intellij/codeInsight/hint/actions/ShowSiblingsAction.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,15 +17,11 @@ package com.intellij.codeInsight.hint.actions; import com.intellij.codeInsight.TargetElementUtilBase; import com.intellij.codeInsight.daemon.impl.PsiElementListNavigator; -import com.intellij.codeInsight.documentation.DocumentationManager; import com.intellij.ide.util.MethodCellRenderer; import com.intellij.ide.util.PsiClassListCellRenderer; -import com.intellij.openapi.actionSystem.*; -import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.actionSystem.CommonDataKeys; +import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.fileEditor.FileEditor; -import com.intellij.openapi.fileEditor.FileEditorManager; -import com.intellij.openapi.fileEditor.TextEditor; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.popup.JBPopup; import com.intellij.psi.*; @@ -36,8 +32,6 @@ import com.intellij.util.Consumer; import org.jetbrains.annotations.Nullable; public class ShowSiblingsAction extends ShowImplementationsAction { - private static final Logger LOG = Logger.getInstance("#" + ShowSiblingsAction.class.getName()); - public ShowSiblingsAction() { super(); } diff --git a/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java b/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java index daf2e3002dd2..34c3ff505af7 100644 --- a/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java @@ -20,6 +20,7 @@ import com.intellij.codeInsight.CodeInsightBundle; import com.intellij.codeInsight.CodeInsightSettings; import com.intellij.codeInsight.completion.JavaCompletionUtil; import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer; +import com.intellij.codeInsight.javadoc.JavaDocInfoGenerator; import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.lang.parameterInfo.*; import com.intellij.openapi.project.DumbAware; @@ -450,12 +451,12 @@ public class MethodParameterInfoHandler implements ParameterInfoHandlerWithTabAc final PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement(); if (element != null) { final PsiElement resolved = element.resolve(); - if (resolved instanceof PsiClass && !AnnotationUtil.isAnnotated((PsiClass)resolved, "java.lang.annotation.Documented", false, true)) { + if (resolved instanceof PsiClass && !JavaDocInfoGenerator.isDocumentedAnnotationType(resolved)) { continue; } String referenceName = element.getReferenceName(); - if (shownAnnotations.add(referenceName) || isRepeatableAnnotation(resolved)) { + if (shownAnnotations.add(referenceName) || JavaDocInfoGenerator.isRepeatableAnnotationType(resolved)) { if (lastSize != buffer.length()) buffer.append(" "); buffer.append("@").append(referenceName); } @@ -464,10 +465,6 @@ public class MethodParameterInfoHandler implements ParameterInfoHandlerWithTabAc if (lastSize != buffer.length()) buffer.append(" "); } - private static boolean isRepeatableAnnotation(PsiElement resolved) { - return resolved instanceof PsiClass && !AnnotationUtil.isAnnotated((PsiModifierListOwner)resolved, CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE, false, true); - } - @Override public void updateUI(final Object p, @NotNull final ParameterInfoUIContext context) { if (p instanceof CandidateInfo) { diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateClassDialog.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateClassDialog.java index a9a6d60b759a..1ab1a5246b54 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateClassDialog.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateClassDialog.java @@ -35,6 +35,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiDirectory; import com.intellij.psi.PsiManager; +import com.intellij.psi.PsiNameHelper; import com.intellij.refactoring.MoveDestination; import com.intellij.refactoring.PackageWrapper; import com.intellij.refactoring.RefactoringBundle; @@ -166,7 +167,7 @@ public class CreateClassDialog extends DialogWrapper { myTfClassName.getDocument().addDocumentListener(new DocumentAdapter() { @Override protected void textChanged(DocumentEvent e) { - getOKAction().setEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(myTfClassName.getText())); + getOKAction().setEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(myTfClassName.getText())); } }); getOKAction().setEnabled(StringUtil.isNotEmpty(myClassName)); diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterDialog.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterDialog.java index 73440ba3d66b..83cb3edabf36 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterDialog.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/CreateFieldFromParameterDialog.java @@ -21,10 +21,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.ComboBox; import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.ui.Messages; -import com.intellij.psi.JavaPsiFacade; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiField; -import com.intellij.psi.PsiType; +import com.intellij.psi.*; import com.intellij.refactoring.ui.TypeSelector; import com.intellij.ui.DocumentAdapter; import org.jetbrains.annotations.NonNls; @@ -273,7 +270,7 @@ public class CreateFieldFromParameterDialog extends DialogWrapper { private void updateOkStatus() { String text = getEnteredName(); - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(text)); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(text)); } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java b/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java index 21e32a3e3aeb..d1d6691fca51 100644 --- a/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java +++ b/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java @@ -3,10 +3,13 @@ package com.intellij.codeInsight.lookup; import com.intellij.codeInsight.AutoPopupController; import com.intellij.codeInsight.TailType; import com.intellij.codeInsight.completion.*; +import com.intellij.codeInsight.daemon.impl.JavaColorProvider; import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil; import com.intellij.featureStatistics.FeatureUsageTracker; import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.RangeMarker; +import com.intellij.openapi.util.Computable; +import com.intellij.openapi.util.RecursionManager; import com.intellij.openapi.util.registry.Registry; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; @@ -15,9 +18,11 @@ import com.intellij.psi.impl.source.PostprocessReformattingAspect; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.util.containers.HashMap; +import com.intellij.util.ui.ColorIcon; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.awt.*; import java.util.Collection; /** @@ -25,10 +30,12 @@ import java.util.Collection; */ public class VariableLookupItem extends LookupItem<PsiVariable> implements TypedLookupItem, StaticallyImportable { @Nullable private final MemberLookupHelper myHelper; + private Color myColor; - public VariableLookupItem(PsiVariable object) { - super(object, object.getName()); + public VariableLookupItem(PsiVariable var) { + super(var, var.getName()); myHelper = null; + myColor = getInitializerColor(var); } public VariableLookupItem(PsiField field, boolean shouldImport) { @@ -37,6 +44,30 @@ public class VariableLookupItem extends LookupItem<PsiVariable> implements Typed if (!shouldImport) { forceQualify(); } + myColor = getInitializerColor(field); + } + + private static Color getInitializerColor(@NotNull PsiVariable var) { + PsiElement navigationElement = var.getNavigationElement(); + if (navigationElement instanceof PsiVariable) { + var = (PsiVariable)navigationElement; + } + return getExpressionColor(var.getInitializer()); + } + + private static Color getExpressionColor(@Nullable PsiExpression expression) { + if (expression instanceof PsiReferenceExpression) { + final PsiElement target = ((PsiReferenceExpression)expression).resolve(); + if (target instanceof PsiVariable) { + return RecursionManager.doPreventingRecursion(expression, true, new Computable<Color>() { + @Override + public Color compute() { + return getExpressionColor(((PsiVariable)target).getInitializer()); + } + }); + } + } + return JavaColorProvider.getJavaColorFromExpression(expression); } @Override @@ -76,6 +107,9 @@ public class VariableLookupItem extends LookupItem<PsiVariable> implements Typed if (myHelper != null) { myHelper.renderElement(presentation, getAttribute(FORCE_QUALIFY) != null ? Boolean.TRUE : null, getSubstitutor()); } + if (myColor != null) { + presentation.setTypeText("", new ColorIcon(12, myColor)); + } } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaMethodParameterUnwrapper.java b/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaMethodParameterUnwrapper.java index 1c1957bcf472..91c2238240ba 100644 --- a/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaMethodParameterUnwrapper.java +++ b/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaMethodParameterUnwrapper.java @@ -31,7 +31,10 @@ public class JavaMethodParameterUnwrapper extends JavaUnwrapper { private static PsiElement adjustElementToTheLeft(PsiElement element) { if (element instanceof PsiJavaToken && ((PsiJavaToken)element).getTokenType() == JavaTokenType.RPARENTH) { - return element.getPrevSibling(); + PsiElement prevSibling = element.getPrevSibling(); + if (prevSibling != null) { + return prevSibling; + } } return element; } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java index 1791fd0d6e8e..5c226b84500b 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java @@ -513,7 +513,9 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ if (!addElementUsages(methods[i], processor, options)) return false; } else { - boolean success = MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters(method, options.searchScope, true, options.fastTrack)) + MethodReferencesSearch.SearchParameters parameters = + new MethodReferencesSearch.SearchParameters(method, options.searchScope, true, options.fastTrack); + boolean success = MethodReferencesSearch.search(parameters) .forEach(new PsiReferenceProcessorAdapter(new PsiReferenceProcessor() { @Override public boolean execute(PsiReference reference) { @@ -663,16 +665,18 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ @NotNull final Processor<UsageInfo> processor, @NotNull final FindUsagesOptions options) { final SearchScope searchScope = options.searchScope; + final PsiClass[] parentClass = new PsiClass[1]; if (element instanceof PsiMethod && ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { @Override public Boolean compute() { - return ((PsiMethod)element).isConstructor(); + PsiMethod method = (PsiMethod)element; + parentClass[0] = method.getContainingClass(); + return method.isConstructor(); } })) { PsiMethod method = (PsiMethod)element; - final PsiClass parentClass = method.getContainingClass(); - if (parentClass != null) { + if (parentClass[0] != null) { boolean strictSignatureSearch = !(options instanceof JavaMethodFindUsagesOptions) || !((JavaMethodFindUsagesOptions)options).isIncludeOverloadUsages; return MethodReferencesSearch diff --git a/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java b/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java index 13c48c2aab77..53fee7a66c0d 100644 --- a/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java +++ b/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java @@ -65,7 +65,7 @@ public class CreateClassAction extends JavaCreateTemplateInPackageAction<PsiClas builder.setValidator(new InputValidatorEx() { @Override public String getErrorText(String inputString) { - if (inputString.length() > 0 && !JavaPsiFacade.getInstance(project).getNameHelper().isQualifiedName(inputString)) { + if (inputString.length() > 0 && !PsiNameHelper.getInstance(project).isQualifiedName(inputString)) { return "This is not a valid Java qualified name"; } return null; diff --git a/java/java-impl/src/com/intellij/ide/actions/CreatePackageInfoAction.java b/java/java-impl/src/com/intellij/ide/actions/CreatePackageInfoAction.java index d2dab9f868d2..64a8c1bcfcb5 100644 --- a/java/java-impl/src/com/intellij/ide/actions/CreatePackageInfoAction.java +++ b/java/java-impl/src/com/intellij/ide/actions/CreatePackageInfoAction.java @@ -92,7 +92,7 @@ public class CreatePackageInfoAction extends CreateFromTemplateActionBase implem } final ProjectFileIndex projectFileIndex = ProjectRootManager.getInstance(project).getFileIndex(); final JavaDirectoryService directoryService = JavaDirectoryService.getInstance(); - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(project).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(project); for (PsiDirectory directory : directories) { if (projectFileIndex.isUnderSourceRootOfType(directory.getVirtualFile(), JavaModuleSourceRootTypes.SOURCES) && PsiUtil.isLanguageLevel5OrHigher(directory)) { diff --git a/java/java-impl/src/com/intellij/ide/actions/JavaCreateTemplateInPackageAction.java b/java/java-impl/src/com/intellij/ide/actions/JavaCreateTemplateInPackageAction.java index b1397f65526d..63ffccb703b6 100644 --- a/java/java-impl/src/com/intellij/ide/actions/JavaCreateTemplateInPackageAction.java +++ b/java/java-impl/src/com/intellij/ide/actions/JavaCreateTemplateInPackageAction.java @@ -37,6 +37,6 @@ public abstract class JavaCreateTemplateInPackageAction<T extends PsiElement> ex } String name = pkg.getQualifiedName(); - return StringUtil.isEmpty(name) || JavaPsiFacade.getInstance(directory.getProject()).getNameHelper().isQualifiedName(name); + return StringUtil.isEmpty(name) || PsiNameHelper.getInstance(directory.getProject()).isQualifiedName(name); } } diff --git a/java/java-impl/src/com/intellij/ide/util/scopeChooser/HierarchyScopeDescriptorProvider.java b/java/java-impl/src/com/intellij/ide/util/scopeChooser/HierarchyScopeDescriptorProvider.java index 36ee6dfcdb36..1eda5c607525 100644 --- a/java/java-impl/src/com/intellij/ide/util/scopeChooser/HierarchyScopeDescriptorProvider.java +++ b/java/java-impl/src/com/intellij/ide/util/scopeChooser/HierarchyScopeDescriptorProvider.java @@ -21,11 +21,17 @@ package com.intellij.ide.util.scopeChooser; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.wm.ToolWindowId; +import com.intellij.openapi.wm.ToolWindowManager; import org.jetbrains.annotations.NotNull; public class HierarchyScopeDescriptorProvider implements ScopeDescriptorProvider { @NotNull public ScopeDescriptor[] getScopeDescriptors(final Project project) { + if (Comparing.strEqual(ToolWindowManager.getInstance(project).getActiveToolWindowId(), ToolWindowId.TODO_VIEW)) { + return EMPTY; + } return new ScopeDescriptor[]{new ClassHierarchyScopeDescriptor(project)}; } }
\ No newline at end of file diff --git a/java/java-impl/src/com/intellij/internal/GenerateVisitorByHierarchyAction.java b/java/java-impl/src/com/intellij/internal/GenerateVisitorByHierarchyAction.java index 5c302e428ce9..0ebb5795d02a 100644 --- a/java/java-impl/src/com/intellij/internal/GenerateVisitorByHierarchyAction.java +++ b/java/java-impl/src/com/intellij/internal/GenerateVisitorByHierarchyAction.java @@ -31,7 +31,6 @@ import com.intellij.openapi.actionSystem.AnAction; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.actionSystem.CommonDataKeys; import com.intellij.openapi.actionSystem.LangDataKeys; -import com.intellij.openapi.actionSystem.PlatformDataKeys; import com.intellij.openapi.application.Result; import com.intellij.openapi.command.WriteCommandAction; import com.intellij.openapi.editor.Document; @@ -74,8 +73,7 @@ public class GenerateVisitorByHierarchyAction extends AnAction { final Ref<PsiClass> parentClassRef = Ref.create(null); final Project project = e.getData(CommonDataKeys.PROJECT); assert project != null; - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiNameHelper helper = psiFacade.getNameHelper(); + final PsiNameHelper helper = PsiNameHelper.getInstance(project); final PackageChooserDialog dialog = new PackageChooserDialog("Choose Target Package and Hierarchy Root Class", project) { @Override diff --git a/java/java-impl/src/com/intellij/internal/StaticIconFieldsAction.java b/java/java-impl/src/com/intellij/internal/StaticIconFieldsAction.java index 2864db6608e6..7fae15f159b7 100644 --- a/java/java-impl/src/com/intellij/internal/StaticIconFieldsAction.java +++ b/java/java-impl/src/com/intellij/internal/StaticIconFieldsAction.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,10 +22,12 @@ package com.intellij.internal; import com.intellij.openapi.actionSystem.AnAction; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.actionSystem.LangDataKeys; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.progress.Task; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Computable; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.ReferencesSearch; @@ -49,19 +51,36 @@ public class StaticIconFieldsAction extends AnAction { ProgressManager.getInstance().run(new Task.Backgroundable(project, "Searching icons usages") { @Override public void run(@NotNull ProgressIndicator indicator) { - JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - GlobalSearchScope all = GlobalSearchScope.allScope(project); - PsiClass allIcons = facade.findClass("com.intellij.icons.AllIcons", all); + final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); + final GlobalSearchScope all = GlobalSearchScope.allScope(project); + PsiClass allIcons = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() { + @Override + public PsiClass compute() { + return facade.findClass("com.intellij.icons.AllIcons", all); + } + }); searchFields(allIcons, view, indicator); - for (PsiClass iconsClass : facade.findPackage("icons").getClasses(all)) { + PsiClass[] classes = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass[]>() { + @Override + public PsiClass[] compute() { + return facade.findPackage("icons").getClasses(all); + } + }); + for (PsiClass iconsClass : classes) { searchFields(iconsClass, view, indicator); } } }); } - private static void searchFields(PsiClass allIcons, final UsageView view, ProgressIndicator indicator) { - indicator.setText("Searching for: " + allIcons.getQualifiedName()); + private static void searchFields(final PsiClass allIcons, final UsageView view, final ProgressIndicator indicator) { + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + indicator.setText("Searching for: " + allIcons.getQualifiedName()); + } + }); + ReferencesSearch.search(allIcons).forEach(new Processor<PsiReference>() { @Override public boolean process(PsiReference reference) { diff --git a/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java b/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java index c59ab2c24cb9..81d1dbcc575a 100644 --- a/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java +++ b/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java @@ -22,6 +22,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiNameHelper; import com.intellij.psi.PsiPackage; import com.intellij.psi.impl.PsiNameHelperImpl; import com.intellij.psi.search.GlobalSearchScope; @@ -41,7 +42,7 @@ public class BasePackageParameterFactory extends ProjectTemplateParameterFactory private static final Condition<PsiPackage> PACKAGE_CONDITION = new Condition<PsiPackage>() { @Override public boolean value(PsiPackage aPackage) { - return JavaPsiFacade.getInstance(aPackage.getProject()).getNameHelper().isQualifiedName(aPackage.getQualifiedName()) && + return PsiNameHelper.getInstance(aPackage.getProject()).isQualifiedName(aPackage.getQualifiedName()) && Character.isLowerCase(aPackage.getName().charAt(0)); } }; diff --git a/java/java-impl/src/com/intellij/packageDependencies/ui/PackagePatternProvider.java b/java/java-impl/src/com/intellij/packageDependencies/ui/PackagePatternProvider.java index c619d2b8e56f..7069d0639267 100644 --- a/java/java-impl/src/com/intellij/packageDependencies/ui/PackagePatternProvider.java +++ b/java/java-impl/src/com/intellij/packageDependencies/ui/PackagePatternProvider.java @@ -29,10 +29,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.ProjectRootManager; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.JavaPsiFacade; -import com.intellij.psi.PsiClassOwner; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; +import com.intellij.psi.*; import com.intellij.psi.search.scope.packageSet.PackageSet; import com.intellij.psi.search.scope.packageSet.PatternPackageSet; import org.jetbrains.annotations.NonNls; @@ -101,7 +98,7 @@ public class PackagePatternProvider extends PatternDialectProvider { final String packageName = ProjectRootManager.getInstance(element.getProject()).getFileIndex().getPackageNameByDirectory(virtualFile.getParent()); final String name = virtualFile.getNameWithoutExtension(); - if (!JavaPsiFacade.getInstance(element.getProject()).getNameHelper().isIdentifier(name)) return null; + if (!PsiNameHelper.getInstance(element.getProject()).isIdentifier(name)) return null; qName = StringUtil.getQualifiedName(packageName, name); } if (qName != null) { diff --git a/java/java-impl/src/com/intellij/psi/RefResolveServiceImpl.java b/java/java-impl/src/com/intellij/psi/RefResolveServiceImpl.java index 3655942f97b7..92c6b4349189 100644 --- a/java/java-impl/src/com/intellij/psi/RefResolveServiceImpl.java +++ b/java/java-impl/src/com/intellij/psi/RefResolveServiceImpl.java @@ -16,18 +16,23 @@ package com.intellij.psi; import com.intellij.concurrency.JobLauncher; +import com.intellij.ide.PowerSaveMode; import com.intellij.openapi.Disposable; import com.intellij.openapi.application.ApplicationAdapter; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.application.RuntimeInterruptedException; import com.intellij.openapi.application.ex.ApplicationEx; import com.intellij.openapi.application.ex.ApplicationUtil; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.fileTypes.StdFileTypes; import com.intellij.openapi.module.Module; +import com.intellij.openapi.progress.EmptyProgressIndicator; import com.intellij.openapi.progress.ProcessCanceledException; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.Task; +import com.intellij.openapi.progress.impl.BackgroundableProcessIndicator; +import com.intellij.openapi.progress.impl.ProgressManagerImpl; +import com.intellij.openapi.progress.util.ProgressIndicatorBase; import com.intellij.openapi.progress.util.ProgressIndicatorUtils; import com.intellij.openapi.project.DumbService; import com.intellij.openapi.project.IndexNotReadyException; @@ -37,6 +42,7 @@ import com.intellij.openapi.roots.ProjectFileIndex; import com.intellij.openapi.startup.StartupManager; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.EmptyRunnable; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.*; @@ -71,7 +77,8 @@ import java.io.FileWriter; import java.io.IOException; import java.text.DateFormat; import java.util.*; -import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @@ -87,7 +94,7 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable private final ApplicationEx myApplication; private volatile boolean myDisposed; private volatile boolean upToDate; - private volatile boolean enabled = true; + private final AtomicInteger enableVetoes = new AtomicInteger(); // number of disable() calls. To enable the service, there should be at least corresponding number of enable() calls. private final FileWriter log; private final ProjectFileIndex myProjectFileIndex; @@ -99,6 +106,7 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable ApplicationEx application, ProjectFileIndex projectFileIndex) throws IOException { super(project); + ((FutureTask)resolveProcess).run(); myApplication = application; myProjectFileIndex = projectFileIndex; if (ResolveScopeManagerImpl.ENABLED_REF_BACK) { @@ -154,8 +162,8 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable return toVfString(list); } - private static String toVfString(@NotNull List<VirtualFile> list) { - List<VirtualFile> sub = list.subList(0, Math.min(list.size(), 100)); + private static String toVfString(@NotNull Collection<VirtualFile> list) { + List<VirtualFile> sub = new ArrayList<VirtualFile>(list).subList(0, Math.min(list.size(), 100)); return list.size() + " files: " + StringUtil.join(sub, new Function<VirtualFile, String>() { @Override public String fun(VirtualFile file) { @@ -205,6 +213,17 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable enable(); } }); + messageBus.connect().subscribe(PowerSaveMode.TOPIC, new PowerSaveMode.Listener() { + @Override + public void powerSaveStateChanged() { + if (PowerSaveMode.isEnabled()) { + enable(); + } + else { + disable(); + } + } + }); myApplication.addApplicationListener(new ApplicationAdapter() { @Override public void beforeWriteActionStart(Object action) { @@ -232,17 +251,16 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable enable(); } }, this); - Disposer.register(this, HeavyProcessLatch.INSTANCE.addListener(new HeavyProcessLatch.HeavyProcessListener() { + HeavyProcessLatch.INSTANCE.addListener(this, new HeavyProcessLatch.HeavyProcessListener() { @Override public void processStarted() { - disable(); } @Override public void processFinished() { - enable(); + wakeUp(); } - })); + }); startThread(); } @@ -368,6 +386,9 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable fileIsResolved.writeTo(new File(getStorageDirectory(), "bitSet")); } + private volatile Future<?> resolveProcess = new FutureTask<Object>(EmptyRunnable.getInstance(), null); // write from EDT only + private volatile ProgressIndicator resolveIndicator = new EmptyProgressIndicator(); + @Override public void run() { while (!myDisposed) { @@ -375,7 +396,7 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable synchronized (filesToResolve) { isEmpty = filesToResolve.isEmpty(); } - if (!enabled || isEmpty) { + if (enableVetoes.get() > 0 || isEmpty || !resolveProcess.isDone() || HeavyProcessLatch.INSTANCE.isRunning()) { try { waitForQueue(); } @@ -384,77 +405,70 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable } continue; } + final Set<VirtualFile> files = countFilesToResolve(); + if (files.isEmpty()) continue; + upToDate = false; - final CountDownLatch batchProcessedLatch = new CountDownLatch(1); - ApplicationManager.getApplication().invokeLater(new Runnable() { + + myApplication.invokeLater(new Runnable() { @Override public void run() { - new Task.Backgroundable(myProject, "Resolving files...", true) { + if (!resolveProcess.isDone()) return; + log("Started to resolve " + files.size() + " files"); + + Task.Backgroundable backgroundable = new Task.Backgroundable(myProject, "Resolving files...", true) { @Override public void run(@NotNull final ProgressIndicator indicator) { - if (ApplicationManager.getApplication().isDisposed()) return; - try { - processBatch(indicator); - } - finally { - batchProcessedLatch.countDown(); + if (!myApplication.isDisposed()) { + try { + processBatch(indicator, files); + } + catch (RuntimeInterruptedException ignore) { + // see future.cancel() in disable() + int i = 0; + } } } - }.queue(); + }; + ProgressIndicator indicator; + if (files.size() > 1) { + //show progress + indicator = new BackgroundableProcessIndicator(backgroundable); + } + else { + indicator = new MyProgress(); + } + resolveIndicator = indicator; + resolveProcess = ProgressManagerImpl.runProcessWithProgressAsynchronously(backgroundable, indicator, null); } }, myProject.getDisposed()); - try { - batchProcessedLatch.await(); - } - catch (InterruptedException e) { - break; - } - - synchronized (filesToResolve) { - upToDate = filesToResolve.isEmpty(); - log("upToDate = " + upToDate); - } flushLog(); } } - private void processBatch(@NotNull final ProgressIndicator indicator) { - Set<VirtualFile> set; - int queuedSize; - synchronized (filesToResolve) { - queuedSize = filesToResolve.size(); - set = new THashSet<VirtualFile>(queuedSize); - // someone might have cleared this bit to mark file as processed - for (VirtualFile file : filesToResolve) { - if (fileIsInQueue.clear(getAbsId(file))) { - set.add(file); - } - } - filesToResolve.clear(); - } + private volatile int resolvedInPreviousBatch; + private void processBatch(@NotNull final ProgressIndicator indicator, @NotNull Set<VirtualFile> files) { + assert !myApplication.isDispatchThread(); + final int resolvedInPreviousBatch = this.resolvedInPreviousBatch; + final int totalSize = files.size() + resolvedInPreviousBatch; final ConcurrentIntObjectMap<int[]> fileToForwardIds = new StripedLockIntObjectConcurrentHashMap<int[]>(); - Set<VirtualFile> files = countAndMarkUnresolved(set, false); - if (files.isEmpty()) return; - final int size = files.size(); final Set<VirtualFile> toProcess = Collections.synchronizedSet(files); - log("Started to resolve "+ size + " files (was queued "+queuedSize+")"); - indicator.setIndeterminate(false); ProgressIndicatorUtils.forceWriteActionPriority(indicator, (Disposable)indicator); long start = System.currentTimeMillis(); Processor<VirtualFile> processor = new Processor<VirtualFile>() { @Override public boolean process(VirtualFile file) { - double fraction = 1 - toProcess.size() * 1.0 / size; + double fraction = 1 - toProcess.size() * 1.0 / totalSize; indicator.setFraction(fraction); try { if (file.isDirectory() || !toResolve(file, myProject)) { return true; } int fileId = getAbsId(file); - int i = size - toProcess.size(); - indicator.setText(i + "/" + size + ": Resolving " + file.getPresentableUrl()); + int i = totalSize - toProcess.size(); + indicator.setText(i + "/" + totalSize + ": Resolving " + file.getPresentableUrl()); int[] forwardIds = processFile(file, fileId, indicator); if (forwardIds == null) { //queueUpdate(file); @@ -475,12 +489,34 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable .getInstance().invokeConcurrentlyUnderProgress(new ArrayList<VirtualFile>(files), indicator, false, false, processor); } finally { + this.resolvedInPreviousBatch = toProcess.isEmpty() ? 0 : totalSize - toProcess.size(); queue(toProcess, "re-added after fail. success=" + success); storeIds(fileToForwardIds); long end = System.currentTimeMillis(); - log("Resolved batch of " + (size - toProcess.size()) + " from " + size + " files in " + ((end - start) / 1000) + "sec. (Gap: " + storage.gap+")"); + log("Resolved batch of " + (totalSize - toProcess.size()) + " from " + totalSize + " files in " + ((end - start) / 1000) + "sec. (Gap: " + storage.gap+")"); + synchronized (filesToResolve) { + upToDate = filesToResolve.isEmpty(); + log("upToDate = " + upToDate); + } + } + } + + @NotNull + private Set<VirtualFile> countFilesToResolve() { + Set<VirtualFile> set; + synchronized (filesToResolve) { + int queuedSize = filesToResolve.size(); + set = new THashSet<VirtualFile>(queuedSize); + // someone might have cleared this bit to mark file as processed + for (VirtualFile file : filesToResolve) { + if (fileIsInQueue.clear(getAbsId(file))) { + set.add(file); + } + } + filesToResolve.clear(); } + return countAndMarkUnresolved(set, false); } private static int getAbsId(@NotNull VirtualFile file) { @@ -528,12 +564,19 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable } private void enable() { - enabled = true; + // decrement but only if it's positive + int vetoes; + do { + vetoes = enableVetoes.get(); + if (vetoes == 0) break; + } while(!enableVetoes.compareAndSet(vetoes, vetoes-1)); wakeUp(); } private void disable() { - enabled = false; + //resolveIndicator.cancel(); + //resolveProcess.cancel(true); + enableVetoes.incrementAndGet(); wakeUp(); } @@ -591,7 +634,7 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable assert forwardSize == backwardSize; // wrap in read action so that sudden quit (in write action) would not interrupt us - ApplicationManager.getApplication().runReadAction(new Runnable() { + myApplication.runReadAction(new Runnable() { @Override public void run() { fileToBackwardIds.forEachEntry(new TIntObjectProcedure<TIntArrayList>() { @@ -644,7 +687,8 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable psiFile.accept(new JavaRecursiveElementWalkingVisitor() { @Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - resolveReference(reference, indicator, resolved); + indicator.checkCanceled(); + resolveReference(reference, resolved); super.visitReferenceElement(reference); } @@ -655,7 +699,8 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable @Override public void visitXmlElement(XmlElement element) { for (PsiReference reference : element.getReferences()) { - resolveReference(reference, indicator, resolved); + indicator.checkCanceled(); + resolveReference(reference, resolved); } super.visitXmlElement(element); } @@ -675,8 +720,7 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable return forward; } - private void resolveReference(@NotNull PsiReference reference, @NotNull ProgressIndicator indicator, @NotNull Set<PsiElement> resolved) { - indicator.checkCanceled(); + private void resolveReference(@NotNull PsiReference reference, @NotNull Set<PsiElement> resolved) { PsiElement element = reference.resolve(); if (element != null) { resolved.add(element); @@ -770,4 +814,10 @@ public class RefResolveServiceImpl extends RefResolveService implements Runnable } return queued; } + + private static class MyProgress extends ProgressIndicatorBase implements Disposable{ + @Override + public void dispose() { + } + } } diff --git a/java/java-impl/src/com/intellij/psi/impl/file/PsiJavaDirectoryFactory.java b/java/java-impl/src/com/intellij/psi/impl/file/PsiJavaDirectoryFactory.java index 83761827f52d..b8823c5b8647 100644 --- a/java/java-impl/src/com/intellij/psi/impl/file/PsiJavaDirectoryFactory.java +++ b/java/java-impl/src/com/intellij/psi/impl/file/PsiJavaDirectoryFactory.java @@ -72,6 +72,6 @@ public class PsiJavaDirectoryFactory extends PsiDirectoryFactory { @Override public boolean isValidPackageName(String name) { - return JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isQualifiedName(name); + return PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(name); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReference.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReference.java index 54812c0928e8..02e08e74aa31 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReference.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReference.java @@ -275,7 +275,7 @@ public class JavaClassReference extends GenericReference implements PsiJavaRefer final GlobalSearchScope scope = getScope(getElement().getContainingFile()); for (final PsiPackage subPackage : aPackage.getSubPackages(scope)) { final String shortName = subPackage.getQualifiedName().substring(startOffset); - if (JavaPsiFacade.getInstance(subPackage.getProject()).getNameHelper().isIdentifier(shortName)) { + if (PsiNameHelper.getInstance(subPackage.getProject()).isIdentifier(shortName)) { list.add(LookupElementBuilder.create(subPackage).withIcon(subPackage.getIcon(Iconable.ICON_FLAG_VISIBILITY))); } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReferenceProvider.java b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReferenceProvider.java index 6e9e92dc4ff9..c43605e55871 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReferenceProvider.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/JavaClassReferenceProvider.java @@ -141,8 +141,8 @@ public class JavaClassReferenceProvider extends GenericReferenceProvider impleme @Override public PsiPackage fun(final PsiPackage psiPackage) { final String packageName = psiPackage.getName(); - return JavaPsiFacade.getInstance(psiPackage.getProject()).getNameHelper() - .isIdentifier(packageName, PsiUtil.getLanguageLevel(psiPackage)) ? psiPackage : null; + return PsiNameHelper.getInstance(psiPackage.getProject()) + .isIdentifier(packageName, PsiUtil.getLanguageLevel(psiPackage)) ? psiPackage : null; } }); } diff --git a/java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java b/java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java index 80201559ef34..ad2a88c025a3 100644 --- a/java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java @@ -153,7 +153,7 @@ class AnonymousToInnerDialog extends DialogWrapper{ errorString = RefactoringBundle.message("anonymousToInner.no.inner.class.name"); } else { - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(innerClassName)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(innerClassName)) { errorString = RefactoringMessageUtil.getIncorrectIdentifierMessage(innerClassName); } else{ diff --git a/java/java-impl/src/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureDialog.java b/java/java-impl/src/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureDialog.java index f8e27c444245..4ed36732bdf2 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureDialog.java @@ -194,7 +194,7 @@ public class ChangeClassSignatureDialog extends RefactoringDialog { final Map<String, TypeParameterInfo> infos = new HashMap<String, TypeParameterInfo>(); for (final TypeParameterInfo info : myTypeParameterInfos) { if (!info.isForExistingParameter() && - !JavaPsiFacade.getInstance(myClass.getProject()).getNameHelper().isIdentifier(info.getNewName())) { + !PsiNameHelper.getInstance(myClass.getProject()).isIdentifier(info.getNewName())) { return RefactoringBundle.message("error.wrong.name.input", info.getNewName()); } final String newName = info.isForExistingParameter() ? parameters[info.getOldParameterIndex()].getName() : info.getNewName(); diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureDialog.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureDialog.java index f86b78d1d17e..80941aabfc9e 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureDialog.java @@ -510,7 +510,7 @@ public class JavaChangeSignatureDialog extends ChangeSignatureDialogBase<Paramet PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); String name = getMethodName(); - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(name)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(name)) { return RefactoringMessageUtil.getIncorrectIdentifierMessage(name); } @@ -534,7 +534,7 @@ public class JavaChangeSignatureDialog extends ChangeSignatureDialogBase<Paramet for (int i = 0; i < newParametersNumber; i++) { final ParameterTableModelItemBase<ParameterInfoImpl> item = parameterInfos.get(i); - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(item.parameter.getName())) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(item.parameter.getName())) { return RefactoringMessageUtil.getIncorrectIdentifierMessage(item.parameter.getName()); } diff --git a/java/java-impl/src/com/intellij/refactoring/copy/CopyClassDialog.java b/java/java-impl/src/com/intellij/refactoring/copy/CopyClassDialog.java index 02ff65e14b2d..f0a4fee2a073 100644 --- a/java/java-impl/src/com/intellij/refactoring/copy/CopyClassDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/copy/CopyClassDialog.java @@ -159,7 +159,7 @@ class CopyClassDialog extends DialogWrapper{ final String[] errorString = new String[1]; final PsiManager manager = PsiManager.getInstance(myProject); - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(manager.getProject()).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(manager.getProject()); if (packageName.length() > 0 && !nameHelper.isQualifiedName(packageName)) { errorString[0] = RefactoringBundle.message("invalid.target.package.name.specified"); } else if (className != null && className.isEmpty()) { diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java index 8905ce202211..6356a17b956c 100644 --- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsDialog.java @@ -472,13 +472,13 @@ public class EncapsulateFieldsDialog extends RefactoringDialog implements Encaps String name; if (isToEncapsulateGet()) { name = myGetterNames[idx]; - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(name)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(name)) { return RefactoringMessageUtil.getIncorrectIdentifierMessage(name); } } if (!myFinalMarks[idx] && isToEncapsulateSet()) { name = mySetterNames[idx]; - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(name)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(name)) { return RefactoringMessageUtil.getIncorrectIdentifierMessage(name); } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodDialog.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodDialog.java index 7bcb0cab6264..f4cfccb496ad 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodDialog.java @@ -221,7 +221,7 @@ public class ExtractMethodDialog extends AbstractExtractDialog { main.add(visibilityAndName, BorderLayout.CENTER); setOKActionEnabled(false); - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(myNameField.getText())); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(myNameField.getText())); final JPanel options = new JPanel(new BorderLayout()); options.add(createOptionsPanel(), BorderLayout.WEST); main.add(options, BorderLayout.SOUTH); @@ -347,7 +347,7 @@ public class ExtractMethodDialog extends AbstractExtractDialog { myMakeStatic.setEnabled(!myStaticFlag && myCanBeStatic && !isChainedConstructor()); } updateSignature(); - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(myNameField.getText()) || + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(myNameField.getText()) || isChainedConstructor()); } diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java index ce52274140bb..c61c29c58ff9 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java @@ -511,7 +511,7 @@ public class ExtractMethodProcessor implements MatchProvider { PsiElement prevSibling = PsiTreeUtil.skipSiblingsBackward(myElements[0], PsiWhiteSpace.class); if (prevSibling instanceof PsiComment && ((PsiComment)prevSibling).getTokenType() == JavaTokenType.END_OF_LINE_COMMENT) { final String text = StringUtil.decapitalize(StringUtil.capitalizeWords(prevSibling.getText().trim().substring(2), true)).replaceAll(" ", ""); - if (JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(text) && text.length() < 20) { + if (PsiNameHelper.getInstance(myProject).isIdentifier(text) && text.length() < 20) { return text; } } diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java index ca64d8d7f954..fddd19bb4630 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectDialog.java @@ -189,7 +189,7 @@ public class ExtractMethodObjectDialog extends AbstractExtractDialog { private void update() { myCbMakeStatic.setEnabled(myCreateInnerClassRb.isSelected() && myCanBeStatic && !myStaticFlag); updateSignature(); - final PsiNameHelper helper = JavaPsiFacade.getInstance(myProject).getNameHelper(); + final PsiNameHelper helper = PsiNameHelper.getInstance(myProject); setOKActionEnabled((myCreateInnerClassRb.isSelected() && helper.isIdentifier(myInnerClassName.getText())) || (!myCreateInnerClassRb.isSelected() && helper.isIdentifier(myMethodName.getText()))); } diff --git a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java index f80af85c471f..86089a95e59d 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractSuperclass/JavaExtractSuperBaseDialog.java @@ -27,7 +27,6 @@ import com.intellij.openapi.util.Pass; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.psi.impl.ElementPresentationUtil; import com.intellij.psi.presentation.java.SymbolPresentationUtil; import com.intellij.refactoring.MoveDestination; import com.intellij.refactoring.PackageWrapper; @@ -131,13 +130,12 @@ public abstract class JavaExtractSuperBaseDialog extends ExtractSuperBaseDialog< @Override protected void preparePackage() throws OperationFailedException { final String targetPackageName = getTargetPackageName(); - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject); final PsiFile containingFile = mySourceClass.getContainingFile(); final boolean fromDefaultPackage = containingFile instanceof PsiClassOwner && ((PsiClassOwner)containingFile).getPackageName().isEmpty(); - if (!(fromDefaultPackage && StringUtil.isEmpty(targetPackageName)) && !psiFacade.getNameHelper().isQualifiedName(targetPackageName)) { + if (!(fromDefaultPackage && StringUtil.isEmpty(targetPackageName)) && !PsiNameHelper.getInstance(myProject).isQualifiedName(targetPackageName)) { throw new OperationFailedException("Invalid package name: " + targetPackageName); } - final PsiPackage aPackage = psiFacade.findPackage(targetPackageName); + final PsiPackage aPackage = JavaPsiFacade.getInstance(myProject).findPackage(targetPackageName); if (aPackage != null) { final PsiDirectory[] directories = aPackage.getDirectories(mySourceClass.getResolveScope()); if (directories.length >= 1) { @@ -173,7 +171,7 @@ public abstract class JavaExtractSuperBaseDialog extends ExtractSuperBaseDialog< @Nullable @Override protected String validateName(String name) { - return JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(name) + return PsiNameHelper.getInstance(myProject).isIdentifier(name) ? null : RefactoringMessageUtil.getIncorrectIdentifierMessage(name); } diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java index 18e53fb6ece5..9089af1e0f93 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassDialog.java @@ -166,7 +166,7 @@ class ExtractClassDialog extends RefactoringDialog implements MemberInfoChangeLi @Override protected void canRun() throws ConfigurationException { final Project project = sourceClass.getProject(); - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(project).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(project); final List<PsiMethod> methods = getMethodsToExtract(); final List<PsiField> fields = getFieldsToExtract(); final List<PsiClass> innerClasses = getClassesToExtract(); diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java index d69352551623..30300db5c322 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java @@ -229,13 +229,13 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor { final String baseName = settings.FIELD_NAME_PREFIX.length() == 0 ? StringUtil.decapitalize(newClassName) : newClassName; String name = settings.FIELD_NAME_PREFIX + baseName + settings.FIELD_NAME_SUFFIX; - if (!existsFieldWithName(name) && !JavaPsiFacade.getInstance(project).getNameHelper().isKeyword(name)) { + if (!existsFieldWithName(name) && !PsiNameHelper.getInstance(project).isKeyword(name)) { return name; } int counter = 1; while (true) { name = settings.FIELD_NAME_PREFIX + baseName + counter + settings.FIELD_NAME_SUFFIX; - if (!existsFieldWithName(name) && !JavaPsiFacade.getInstance(project).getNameHelper().isKeyword(name)) { + if (!existsFieldWithName(name) && !PsiNameHelper.getInstance(project).isKeyword(name)) { return name; } counter++; diff --git a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java index b21204e55ef2..32e4992fe744 100644 --- a/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationDialog.java @@ -108,7 +108,7 @@ public class InheritanceToDelegationDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { final String fieldName = getFieldName(); - final PsiNameHelper helper = JavaPsiFacade.getInstance(myProject).getNameHelper(); + final PsiNameHelper helper = PsiNameHelper.getInstance(myProject); if (!helper.isIdentifier(fieldName)){ throw new ConfigurationException("\'" + fieldName + "\' is invalid field name for delegation"); } diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java index b29d02fad178..8ab4fe47ce7d 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineMethodProcessor.java @@ -448,7 +448,12 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor { if (element instanceof PsiReferenceExpression) { refExprList.add((PsiReferenceExpression)element); } else if (element instanceof PsiImportStaticReferenceElement) { - imports2Delete.add(PsiTreeUtil.getParentOfType(element, PsiImportStaticStatement.class)); + final JavaResolveResult[] resolveResults = ((PsiImportStaticReferenceElement)element).multiResolve(false); + if (resolveResults.length < 2) { + //no overloads available: ensure broken import are deleted and + //unused overloaded imports are deleted by optimize imports helper + imports2Delete.add(PsiTreeUtil.getParentOfType(element, PsiImportStaticStatement.class)); + } } else if (JavaLanguage.INSTANCE != element.getLanguage()) { GenericInlineHandler.inlineReference(usage, myMethod, myInliners); diff --git a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java index 4bae67e08f16..d39cc8a1035e 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java @@ -320,7 +320,7 @@ class IntroduceConstantDialog extends DialogWrapper { } private void updateButtons() { - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getEnteredName())); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(getEnteredName())); } private void targetClassChanged() { @@ -433,7 +433,7 @@ class IntroduceConstantDialog extends DialogWrapper { String errorString = null; if ("".equals(fieldName)) { errorString = RefactoringBundle.message("no.field.name.specified"); - } else if (!JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(fieldName)) { + } else if (!PsiNameHelper.getInstance(myProject).isIdentifier(fieldName)) { errorString = RefactoringMessageUtil.getIncorrectIdentifierMessage(fieldName); } else if (newClass != null && !myParentClass.getLanguage().equals(newClass.getLanguage())) { errorString = RefactoringBundle.message("move.to.different.language", UsageViewUtil.getType(myParentClass), diff --git a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceFieldDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceFieldDialog.java index 09c8cbd1a8cf..6f1cd002c9c5 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceFieldDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceFieldDialog.java @@ -189,7 +189,7 @@ class IntroduceFieldDialog extends DialogWrapper { } private void updateButtons() { - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getEnteredName())); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(getEnteredName())); } private String getTypeLabel() { @@ -240,7 +240,7 @@ class IntroduceFieldDialog extends DialogWrapper { String errorString = null; if ("".equals(fieldName)) { errorString = RefactoringBundle.message("no.field.name.specified"); - } else if (!JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(fieldName)) { + } else if (!PsiNameHelper.getInstance(myProject).isIdentifier(fieldName)) { errorString = RefactoringMessageUtil.getIncorrectIdentifierMessage(fieldName); } if (errorString != null) { diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/AbstractJavaInplaceIntroducer.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/AbstractJavaInplaceIntroducer.java index 5e610f52e40f..a22a0987bdbb 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/AbstractJavaInplaceIntroducer.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/AbstractJavaInplaceIntroducer.java @@ -121,7 +121,7 @@ public abstract class AbstractJavaInplaceIntroducer extends AbstractInplaceIntro public static String[] appendUnresolvedExprName(String[] names, final PsiExpression expr) { if (expr instanceof PsiReferenceExpression && ((PsiReferenceExpression)expr).resolve() == null) { final String name = expr.getText(); - if (JavaPsiFacade.getInstance(expr.getProject()).getNameHelper().isIdentifier(name, LanguageLevel.HIGHEST)) { + if (PsiNameHelper.getInstance(expr.getProject()).isIdentifier(name, LanguageLevel.HIGHEST)) { names = ArrayUtil.mergeArrays(new String[]{name}, names); } } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java index b23b0c465858..2c1fd8376619 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java @@ -281,7 +281,7 @@ public class IntroduceParameterDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { String name = getParameterName(); - if (name == null || !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(name)) { + if (name == null || !PsiNameHelper.getInstance(myProject).isIdentifier(name)) { throw new ConfigurationException("\'" + (name != null ? name : "") + "\' is invalid parameter name"); } } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java index 99b2d6a096a1..350422dd436b 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java @@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.DialogWrapper; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiExpression; +import com.intellij.psi.PsiNameHelper; import com.intellij.psi.PsiType; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.SuggestedNameInfo; @@ -270,7 +271,7 @@ class IntroduceVariableDialog extends DialogWrapper implements IntroduceVariable private void updateOkStatus() { String text = getEnteredName(); - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(text)); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(text)); } public JComponent getPreferredFocusedComponent() { diff --git a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectDialog.java index 7378c2e57d59..878e686474d1 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectDialog.java @@ -185,8 +185,7 @@ public class IntroduceParameterObjectDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { final Project project = sourceMethod.getProject(); - final JavaPsiFacade manager = JavaPsiFacade.getInstance(project); - final PsiNameHelper nameHelper = manager.getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(project); final List<PsiParameter> parametersToExtract = getParametersToExtract(); if (parametersToExtract.isEmpty()) { diff --git a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeParameterizedStaticDialog.java b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeParameterizedStaticDialog.java index fa471dfa3a6e..b08c8d33ca0f 100644 --- a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeParameterizedStaticDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeParameterizedStaticDialog.java @@ -256,7 +256,7 @@ public class MakeParameterizedStaticDialog extends AbstractMakeStaticDialog { setOKActionEnabled(false); } else { - setOKActionEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(classParameterName.trim())); + setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(classParameterName.trim())); } } else diff --git a/java/java-impl/src/com/intellij/refactoring/migration/EditMigrationEntryDialog.java b/java/java-impl/src/com/intellij/refactoring/migration/EditMigrationEntryDialog.java index 4ca1a26f449e..6834a09693a8 100644 --- a/java/java-impl/src/com/intellij/refactoring/migration/EditMigrationEntryDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/migration/EditMigrationEntryDialog.java @@ -132,12 +132,12 @@ public class EditMigrationEntryDialog extends DialogWrapper{ String text = myOldNameField.getText(); text = text.trim(); PsiManager manager = PsiManager.getInstance(myProject); - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isQualifiedName(text)){ + if (!PsiNameHelper.getInstance(manager.getProject()).isQualifiedName(text)){ isEnabled = false; } text = myNewNameField.getText(); text = text.trim(); - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isQualifiedName(text)){ + if (!PsiNameHelper.getInstance(manager.getProject()).isQualifiedName(text)){ isEnabled = false; } setOKActionEnabled(isEnabled); diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesDialog.java b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesDialog.java index c5caa4c9c240..3bbcf743506c 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesDialog.java @@ -322,7 +322,7 @@ public class MoveClassesOrPackagesDialog extends RefactoringDialog { protected void canRun() throws ConfigurationException { if (isMoveToPackage()) { String name = getTargetPackage().trim(); - if (name.length() != 0 && !JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isQualifiedName(name)) { + if (name.length() != 0 && !PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(name)) { throw new ConfigurationException("\'" + name + "\' is invalid destination package name"); } } @@ -491,7 +491,7 @@ public class MoveClassesOrPackagesDialog extends RefactoringDialog { @Nullable private MoveDestination selectDestination() { final String packageName = getTargetPackage().trim(); - if (packageName.length() > 0 && !JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper().isQualifiedName(packageName)) { + if (packageName.length() > 0 && !PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(packageName)) { Messages.showErrorDialog(myProject, RefactoringBundle.message("please.enter.a.valid.target.package.name"), RefactoringBundle.message("move.title")); return null; diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java index 0e02b8f94e28..54ddf03a5c57 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java @@ -122,7 +122,7 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor { public boolean verifyValidPackageName() { String qName = myTargetPackage.getQualifiedName(); if (!StringUtil.isEmpty(qName)) { - PsiNameHelper helper = JavaPsiFacade.getInstance(myProject).getNameHelper(); + PsiNameHelper helper = PsiNameHelper.getInstance(myProject); if (!helper.isQualifiedName(qName)) { Messages.showMessageDialog(myProject, RefactoringBundle.message("invalid.target.package.name.specified"), "Invalid Package Name", Messages.getErrorIcon()); diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveJavaFileHandler.java b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveJavaFileHandler.java index 60619ef4f9ce..92c3bc888f1c 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveJavaFileHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveJavaFileHandler.java @@ -95,7 +95,7 @@ public class MoveJavaFileHandler extends MoveFileHandler { final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(containingDirectory); if (aPackage != null) { final String qualifiedName = aPackage.getQualifiedName(); - final PsiNameHelper helper = JavaPsiFacade.getInstance(file.getProject()).getNameHelper(); + final PsiNameHelper helper = PsiNameHelper.getInstance(file.getProject()); final PsiPackageStatement packageStatement = !StringUtil.isEmptyOrSpaces(qualifiedName) && helper.isQualifiedName(qualifiedName) ? JavaPsiFacade.getElementFactory(file.getProject()).createPackageStatement(qualifiedName) : null; diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveInner/MoveInnerDialog.java b/java/java-impl/src/com/intellij/refactoring/move/moveInner/MoveInnerDialog.java index dd87120c6770..cb502377f83b 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveInner/MoveInnerDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveInner/MoveInnerDialog.java @@ -247,7 +247,7 @@ public class MoveInnerDialog extends RefactoringDialog { message = RefactoringBundle.message("no.class.name.specified"); } else { - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(className)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(className)) { message = RefactoringMessageUtil.getIncorrectIdentifierMessage(className); } else { @@ -256,7 +256,7 @@ public class MoveInnerDialog extends RefactoringDialog { message = RefactoringBundle.message("no.parameter.name.specified"); } else { - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(parameterName)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(parameterName)) { message = RefactoringMessageUtil.getIncorrectIdentifierMessage(parameterName); } } diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveInstanceMethod/MoveInstanceMethodDialog.java b/java/java-impl/src/com/intellij/refactoring/move/moveInstanceMethod/MoveInstanceMethodDialog.java index 3afe836ce615..1c058d2fe855 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveInstanceMethod/MoveInstanceMethodDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveInstanceMethod/MoveInstanceMethodDialog.java @@ -134,7 +134,7 @@ public class MoveInstanceMethodDialog extends MoveInstanceMethodDialogBase { EditorTextField field = myOldClassParameterNameFields.get(aClass); if (field.isEnabled()) { String parameterName = field.getText().trim(); - if (!JavaPsiFacade.getInstance(myMethod.getProject()).getNameHelper().isIdentifier(parameterName)) { + if (!PsiNameHelper.getInstance(myMethod.getProject()).isIdentifier(parameterName)) { Messages .showErrorDialog(getProject(), RefactoringBundle.message("move.method.enter.a.valid.name.for.parameter"), myRefactoringName); return; diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveMembersDialog.java b/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveMembersDialog.java index ab1bc8a8af0b..a8daa9e733fe 100644 --- a/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveMembersDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveMembersDialog.java @@ -264,7 +264,7 @@ public class MoveMembersDialog extends RefactoringDialog implements MoveMembersO return RefactoringBundle.message("no.destination.class.specified"); } else { - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isQualifiedName(fqName)) { + if (!PsiNameHelper.getInstance(manager.getProject()).isQualifiedName(fqName)) { return RefactoringBundle.message("0.is.not.a.legal.fq.name", fqName); } else { diff --git a/java/java-impl/src/com/intellij/refactoring/rename/DirectoryAsPackageRenameHandler.java b/java/java-impl/src/com/intellij/refactoring/rename/DirectoryAsPackageRenameHandler.java index 71ec7ebe267b..958572dce0a6 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/DirectoryAsPackageRenameHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/DirectoryAsPackageRenameHandler.java @@ -18,10 +18,7 @@ package com.intellij.refactoring.rename; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.JavaDirectoryService; -import com.intellij.psi.JavaPsiFacade; -import com.intellij.psi.PsiDirectory; -import com.intellij.psi.PsiPackage; +import com.intellij.psi.*; import com.intellij.refactoring.BaseRefactoringProcessor; import com.intellij.refactoring.RefactoringBundle; import com.intellij.refactoring.move.moveClassesOrPackages.MoveDirectoryWithClassesProcessor; @@ -38,7 +35,7 @@ public class DirectoryAsPackageRenameHandler extends DirectoryAsPackageRenameHan @Override protected boolean isIdentifier(String name, Project project) { - return JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(name); + return PsiNameHelper.getInstance(project).isIdentifier(name); } @Override diff --git a/java/java-impl/src/com/intellij/refactoring/rename/PsiPackageRenameValidator.java b/java/java-impl/src/com/intellij/refactoring/rename/PsiPackageRenameValidator.java index 2a25f057e82f..29df2ff556b0 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/PsiPackageRenameValidator.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/PsiPackageRenameValidator.java @@ -21,6 +21,7 @@ import com.intellij.patterns.ElementPattern; import com.intellij.patterns.PlatformPatterns; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiNameHelper; import com.intellij.psi.PsiPackage; import com.intellij.psi.impl.file.PsiDirectoryFactory; import com.intellij.util.ProcessingContext; @@ -41,7 +42,7 @@ public class PsiPackageRenameValidator implements RenameInputValidatorEx { if (!PsiDirectoryFactory.getInstance(project).isValidPackageName(newName)) { return "Not a valid package name"; } - if (!JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(newName)) { + if (!PsiNameHelper.getInstance(project).isIdentifier(newName)) { return "Not a valid identifier name"; } } diff --git a/java/java-impl/src/com/intellij/refactoring/rename/naming/ConstructorParameterOnFieldRenameRenamer.java b/java/java-impl/src/com/intellij/refactoring/rename/naming/ConstructorParameterOnFieldRenameRenamer.java index 345b3129defb..67bb13ce81e4 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/naming/ConstructorParameterOnFieldRenameRenamer.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/naming/ConstructorParameterOnFieldRenameRenamer.java @@ -36,7 +36,9 @@ public class ConstructorParameterOnFieldRenameRenamer extends AutomaticRenamer { } protected String nameToCanonicalName(@NonNls final String name, final PsiNamedElement element) { - return JavaCodeStyleManager.getInstance(element.getProject()).variableNameToPropertyName(name, VariableKind.FIELD); + final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(element.getProject()); + final VariableKind variableKind = element instanceof PsiVariable ? javaCodeStyleManager.getVariableKind((PsiVariable)element) : VariableKind.FIELD; + return javaCodeStyleManager.variableNameToPropertyName(name, variableKind); } public ConstructorParameterOnFieldRenameRenamer(PsiField aField, String newFieldName) { diff --git a/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderDialog.java b/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderDialog.java index e2354c99812e..41cccd9453ee 100644 --- a/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderDialog.java @@ -153,7 +153,7 @@ public class ReplaceConstructorWithBuilderDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(myProject).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(myProject); for (ParameterData parameterData : myParametersMap.values()) { if (!nameHelper.isIdentifier(parameterData.getFieldName())) throw new ConfigurationException("\'" + parameterData.getFieldName() + "\' is not a valid field name"); if (!nameHelper.isIdentifier(parameterData.getSetterName())) throw new ConfigurationException("\'" + parameterData.getSetterName() + "\' is not a valid setter name"); diff --git a/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryDialog.java b/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryDialog.java index 01444d0cee4d..395ff848701d 100644 --- a/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryDialog.java @@ -202,7 +202,7 @@ public class ReplaceConstructorWithFactoryDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { final String name = myNameField.getEnteredName(); - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(myContainingClass.getProject()).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(myContainingClass.getProject()); if (!nameHelper.isIdentifier(name)) { throw new ConfigurationException("\'" + name + "\' is invalid factory method name"); } diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/TypeCookProcessor.java b/java/java-impl/src/com/intellij/refactoring/typeCook/TypeCookProcessor.java index 08ad857fe766..4e4e681ea03b 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/TypeCookProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/TypeCookProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,10 +30,7 @@ import com.intellij.usageView.UsageInfo; import com.intellij.usageView.UsageViewDescriptor; import org.jetbrains.annotations.NotNull; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; +import java.util.*; public class TypeCookProcessor extends BaseRefactoringProcessor { private PsiElement[] myElements; @@ -75,7 +72,7 @@ public class TypeCookProcessor extends BaseRefactoringProcessor { } } - final HashSet<PsiElement> changedItems = myResult.getCookedElements(); + final Set<PsiElement> changedItems = myResult.getCookedElements(); final UsageInfo[] usages = new UsageInfo[changedItems.size()]; int i = 0; @@ -100,7 +97,7 @@ public class TypeCookProcessor extends BaseRefactoringProcessor { } protected void performRefactoring(UsageInfo[] usages) { - final HashSet<PsiElement> victims = new HashSet<PsiElement>(); + final Set<PsiElement> victims = new HashSet<PsiElement>(); for (UsageInfo usage : usages) { victims.add(usage.getElement()); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/Util.java b/java/java-impl/src/com/intellij/refactoring/typeCook/Util.java index e33388e0e8b7..54149613704b 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/Util.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/Util.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -217,7 +217,7 @@ public class Util { return subst; } - public static boolean bindsTypeParameters(PsiType t, HashSet<PsiTypeParameter> params) { + public static boolean bindsTypeParameters(PsiType t, Set<PsiTypeParameter> params) { if (t instanceof PsiWildcardType) { final PsiWildcardType wct = ((PsiWildcardType)t); final PsiType bound = wct.getBound(); @@ -286,7 +286,7 @@ public class Util { PsiSubstitutor theSubst = PsiSubstitutor.EMPTY; - final HashSet<PsiTypeVariable> cluster = new HashSet<PsiTypeVariable>(); + final Set<PsiTypeVariable> cluster = new HashSet<PsiTypeVariable>(); for (final PsiTypeParameter parm : aSubst.getSubstitutionMap().keySet()) { final PsiType type = createParameterizedType(aSubst.substitute(parm), factory, false, context); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/PsiTypeVariableFactory.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/PsiTypeVariableFactory.java index e9a53aa68702..95535071b50e 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/PsiTypeVariableFactory.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/PsiTypeVariableFactory.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,23 +21,21 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import org.jetbrains.annotations.NotNull; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedList; +import java.util.*; /** * @author db */ public class PsiTypeVariableFactory { private int myCurrent = 0; - private final LinkedList<HashSet<PsiTypeVariable>> myClusters = new LinkedList<HashSet<PsiTypeVariable>>(); - private final HashMap<Integer, HashSet<PsiTypeVariable>> myVarCluster = new HashMap<Integer, HashSet<PsiTypeVariable>>(); + private final List<Set<PsiTypeVariable>> myClusters = new LinkedList<Set<PsiTypeVariable>>(); + private final Map<Integer, Set<PsiTypeVariable>> myVarCluster = new HashMap<Integer, Set<PsiTypeVariable>>(); public final int getNumber() { return myCurrent; } - public final void registerCluster(final HashSet<PsiTypeVariable> cluster) { + public final void registerCluster(final Set<PsiTypeVariable> cluster) { myClusters.add(cluster); for (final PsiTypeVariable aCluster : cluster) { @@ -45,11 +43,11 @@ public class PsiTypeVariableFactory { } } - public final LinkedList<HashSet<PsiTypeVariable>> getClusters() { + public final List<Set<PsiTypeVariable>> getClusters() { return myClusters; } - public final HashSet<PsiTypeVariable> getClusterOf(final int var) { + public final Set<PsiTypeVariable> getClusterOf(final int var) { return myVarCluster.get(new Integer(var)); } diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/ReductionSystem.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/ReductionSystem.java index 271c686b7fa9..a23d6d033c74 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/ReductionSystem.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/ReductionSystem.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,19 +31,19 @@ import java.util.*; * @author db */ public class ReductionSystem { - final HashSet<Constraint> myConstraints = new HashSet<Constraint>(); - final HashSet<PsiElement> myElements; - final HashMap<PsiTypeCastExpression, PsiType> myCastToOperandType; - final HashMap<PsiElement, PsiType> myTypes; + final Set<Constraint> myConstraints = new HashSet<Constraint>(); + final Set<PsiElement> myElements; + final Map<PsiTypeCastExpression, PsiType> myCastToOperandType; + final Map<PsiElement, PsiType> myTypes; final PsiTypeVariableFactory myTypeVariableFactory; final Project myProject; final Settings mySettings; - HashSet<PsiTypeVariable> myBoundVariables; + Set<PsiTypeVariable> myBoundVariables; public ReductionSystem(final Project project, - final HashSet<PsiElement> elements, - final HashMap<PsiElement, PsiType> types, + final Set<PsiElement> elements, + final Map<PsiElement, PsiType> types, final PsiTypeVariableFactory factory, final Settings settings) { myProject = project; @@ -59,7 +59,7 @@ public class ReductionSystem { return myProject; } - public HashSet<Constraint> getConstraints() { + public Set<Constraint> getConstraints() { return myConstraints; } @@ -165,7 +165,7 @@ public class ReductionSystem { class Node { int myComponent = -1; Constraint myConstraint; - HashSet<Node> myNeighbours = new HashSet<Node>(); + Set<Node> myNeighbours = new HashSet<Node>(); public Node() { myConstraint = null; @@ -189,7 +189,7 @@ public class ReductionSystem { final Node[] typeVariableNodes = new Node[myTypeVariableFactory.getNumber()]; final Node[] constraintNodes = new Node[myConstraints.size()]; - final HashMap<Constraint, HashSet<PsiTypeVariable>> boundVariables = new HashMap<Constraint, HashSet<PsiTypeVariable>>(); + final Map<Constraint, Set<PsiTypeVariable>> boundVariables = new HashMap<Constraint, Set<PsiTypeVariable>>(); for (int i = 0; i < typeVariableNodes.length; i++) { typeVariableNodes[i] = new Node(); @@ -207,7 +207,7 @@ public class ReductionSystem { int l = 0; for (final Constraint constraint : myConstraints) { - final HashSet<PsiTypeVariable> boundVars = new HashSet<PsiTypeVariable>(); + final Set<PsiTypeVariable> boundVars = new LinkedHashSet<PsiTypeVariable>(); final Node constraintNode = constraintNodes[l++]; new Object() { @@ -266,9 +266,9 @@ public class ReductionSystem { } } - final LinkedList<HashSet<PsiTypeVariable>> clusters = myTypeVariableFactory.getClusters(); + List<Set<PsiTypeVariable>> clusters = myTypeVariableFactory.getClusters(); - for (final HashSet<PsiTypeVariable> cluster : clusters) { + for (final Set<PsiTypeVariable> cluster : clusters) { Node prev = null; for (final PsiTypeVariable variable : cluster) { @@ -327,7 +327,7 @@ public class ReductionSystem { return systems; } - private void addConstraint(final Constraint constraint, final HashSet<PsiTypeVariable> vars) { + private void addConstraint(final Constraint constraint, final Set<PsiTypeVariable> vars) { if (myBoundVariables == null) { myBoundVariables = vars; } @@ -342,7 +342,7 @@ public class ReductionSystem { return myTypeVariableFactory; } - public HashSet<PsiTypeVariable> getBoundVariables() { + public Set<PsiTypeVariable> getBoundVariables() { return myBoundVariables; } diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/Result.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/Result.java index 31e67a451e7f..a74fc23261e3 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/Result.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/Result.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,9 +25,9 @@ import com.intellij.refactoring.typeCook.deductive.resolver.Binding; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NonNls; -import java.util.HashMap; import java.util.HashSet; import java.util.Map; +import java.util.Set; /** * @author db @@ -35,10 +35,10 @@ import java.util.Map; public class Result { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.typeCook.deductive.builder.Result"); - private final HashSet<PsiElement> myVictims; - private final HashMap<PsiElement, PsiType> myTypes; + private final Set<PsiElement> myVictims; + private final Map<PsiElement, PsiType> myTypes; private final Settings mySettings; - private final HashMap<PsiTypeCastExpression, PsiType> myCastToOperandType; + private final Map<PsiTypeCastExpression, PsiType> myCastToOperandType; private int myCookedNumber = -1; private int myCastsRemoved = -1; @@ -92,10 +92,10 @@ public class Result { return originalType; } - public HashSet<PsiElement> getCookedElements() { + public Set<PsiElement> getCookedElements() { myCookedNumber = 0; - final HashSet<PsiElement> set = new HashSet<PsiElement>(); + final Set<PsiElement> set = new HashSet<PsiElement>(); for (final PsiElement element : myVictims) { final PsiType originalType = Util.getType(element); @@ -137,7 +137,7 @@ public class Result { return false; } - public void apply(final HashSet<PsiElement> victims) { + public void apply(final Set<PsiElement> victims) { for (final PsiElement element : victims) { if (element instanceof PsiTypeCastExpression && myCastToOperandType.containsKey(element)) { final PsiTypeCastExpression cast = ((PsiTypeCastExpression)element); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/SystemBuilder.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/SystemBuilder.java index 2cd9045ba121..8b0514143ba6 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/SystemBuilder.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/builder/SystemBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -37,6 +37,7 @@ import com.intellij.util.containers.HashMap; import java.util.Arrays; import java.util.HashSet; import java.util.Map; +import java.util.Set; /** * Created by IntelliJ IDEA. @@ -49,11 +50,11 @@ public class SystemBuilder { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.typeCook.deductive.builder.SystemBuilder"); private final PsiManager myManager; - private final HashMap<PsiElement, Boolean> myMethodCache; - private final HashMap<PsiParameter, PsiParameter> myParameters; - private final HashMap<PsiMethod, PsiMethod> myMethods; - private final HashMap<PsiElement, PsiType> myTypes; - private final HashSet<PsiAnchor> myVisitedConstructions; + private final Map<PsiElement, Boolean> myMethodCache; + private final Map<PsiParameter, PsiParameter> myParameters; + private final Map<PsiMethod, PsiMethod> myMethods; + private final Map<PsiElement, PsiType> myTypes; + private final Set<PsiAnchor> myVisitedConstructions; private final Settings mySettings; private final PsiTypeVariableFactory myTypeVariableFactory; private final Project myProject; @@ -70,11 +71,11 @@ public class SystemBuilder { myTypeVariableFactory = new PsiTypeVariableFactory(); } - private HashSet<PsiElement> collect(final PsiElement[] scopes) { + private Set<PsiElement> collect(final PsiElement[] scopes) { return new VictimCollector(scopes, mySettings).getVictims(); } - private boolean verifyMethod(final PsiElement element, final HashSet<PsiElement> victims, final PsiSearchHelper helper) { + private boolean verifyMethod(final PsiElement element, final Set<PsiElement> victims, final PsiSearchHelper helper) { PsiMethod method; PsiParameter parameter = null; int index = 0; @@ -352,7 +353,7 @@ public class SystemBuilder { final PsiExpression qualifier = expr instanceof PsiMethodCallExpression ? ((PsiMethodCallExpression)expr).getMethodExpression().getQualifierExpression() : null; - final HashSet<PsiTypeParameter> typeParameters = new HashSet<PsiTypeParameter>(Arrays.asList(methodTypeParameters)); + final Set<PsiTypeParameter> typeParameters = new HashSet<PsiTypeParameter>(Arrays.asList(methodTypeParameters)); PsiSubstitutor qualifierSubstitutor = PsiSubstitutor.EMPTY; PsiSubstitutor supertypeSubstitutor = PsiSubstitutor.EMPTY; @@ -397,7 +398,7 @@ public class SystemBuilder { } } - final HashMap<PsiTypeParameter, PsiType> mapping = new HashMap<PsiTypeParameter, PsiType>(); + final Map<PsiTypeParameter, PsiType> mapping = new HashMap<PsiTypeParameter, PsiType>(); for (int i = 0; i < Math.min(parameters.length, arguments.length); i++) { final PsiType argumentType = evaluateType(arguments[i], system); @@ -913,7 +914,7 @@ public class SystemBuilder { return build(collect(scopes)); } - public ReductionSystem build(final HashSet<PsiElement> victims) { + public ReductionSystem build(final Set<PsiElement> victims) { final PsiSearchHelper helper = PsiSearchHelper.SERVICE.getInstance(myManager.getProject()); ReductionSystem system = new ReductionSystem(myProject, victims, myTypes, myTypeVariableFactory, mySettings); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/Binding.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/Binding.java index 54901124c3c1..88286517e4f1 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/Binding.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/Binding.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +18,7 @@ package com.intellij.refactoring.typeCook.deductive.resolver; import com.intellij.psi.PsiType; import com.intellij.psi.PsiTypeVariable; -import java.util.HashSet; +import java.util.Set; /** * @author db @@ -47,7 +47,7 @@ public abstract class Binding { public abstract void merge(Binding b, boolean removeObject); - public abstract HashSet<PsiTypeVariable> getBoundVariables(); + public abstract Set<PsiTypeVariable> getBoundVariables(); public abstract int getWidth(); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/BindingFactory.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/BindingFactory.java index 49525a67de44..14b9a1715050 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/BindingFactory.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/BindingFactory.java @@ -33,7 +33,6 @@ import com.intellij.util.IncorrectOperationException; import gnu.trove.TIntObjectHashMap; import gnu.trove.TObjectProcedure; -import java.util.HashSet; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.Set; @@ -45,7 +44,7 @@ import java.util.Set; public class BindingFactory { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.typeCook.deductive.resolver.BindingFactory"); - private final HashSet<PsiTypeVariable> myBoundVariables; + private final Set<PsiTypeVariable> myBoundVariables; private final Project myProject; private final PsiTypeVariableFactory myFactory; @@ -95,7 +94,7 @@ public class BindingFactory { myBindings.put(index, type); if (type instanceof Bottom) { - final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(index); + final Set<PsiTypeVariable> cluster = myFactory.getClusterOf(index); if (cluster != null) { for (PsiTypeVariable var : cluster) { @@ -540,7 +539,7 @@ public class BindingFactory { if (removeObject && javaLangObject.equals(type)) { - final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(var.getIndex()); + final Set<PsiTypeVariable> cluster = myFactory.getClusterOf(var.getIndex()); if (cluster != null) { for (final PsiTypeVariable war : cluster) { @@ -560,7 +559,7 @@ public class BindingFactory { } } - public HashSet<PsiTypeVariable> getBoundVariables() { + public Set<PsiTypeVariable> getBoundVariables() { return myBoundVariables; } @@ -663,7 +662,7 @@ public class BindingFactory { Binding unify(PsiType x, PsiType y); } - public Binding balance(final PsiType x, final PsiType y, final Balancer balancer, final HashSet<Constraint> constraints) { + public Binding balance(final PsiType x, final PsiType y, final Balancer balancer, final Set<Constraint> constraints) { final int indicator = (x instanceof PsiTypeVariable ? 1 : 0) + (y instanceof PsiTypeVariable ? 2 : 0); switch (indicator) { @@ -878,7 +877,7 @@ public class BindingFactory { } } - public Binding riseWithWildcard(final PsiType x, final PsiType y, final HashSet<Constraint> constraints) { + public Binding riseWithWildcard(final PsiType x, final PsiType y, final Set<Constraint> constraints) { final Binding binding = balance(x, y, new Balancer() { public Binding varType(final PsiTypeVariable x, final PsiType y) { if (y instanceof Bottom) { @@ -941,7 +940,7 @@ public class BindingFactory { return binding != null ? binding.reduceRecursive() : null; } - public Binding rise(final PsiType x, final PsiType y, final HashSet<Constraint> constraints) { + public Binding rise(final PsiType x, final PsiType y, final Set<Constraint> constraints) { final Binding binding = balance(x, y, new Balancer() { public Binding varType(final PsiTypeVariable x, final PsiType y) { if (y instanceof Bottom || y instanceof PsiWildcardType) { @@ -977,7 +976,7 @@ public class BindingFactory { return binding != null ? binding.reduceRecursive() : null; } - public Binding sink(final PsiType x, final PsiType y, final HashSet<Constraint> constraints) { + public Binding sink(final PsiType x, final PsiType y, final Set<Constraint> constraints) { return balance(x, y, new Balancer() { public Binding varType(final PsiTypeVariable x, final PsiType y) { return create(x, y); @@ -1141,7 +1140,7 @@ public class BindingFactory { return new BindingImpl(); } - public HashSet<PsiTypeVariable> getBoundVariables() { + public Set<PsiTypeVariable> getBoundVariables() { return myBoundVariables; } } diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/ResolverTree.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/ResolverTree.java index 7279b6d4a0d0..a58e0561c449 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/ResolverTree.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/resolver/ResolverTree.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,6 +28,7 @@ import com.intellij.refactoring.typeCook.deductive.PsiExtendedTypeVisitor; import com.intellij.refactoring.typeCook.deductive.builder.Constraint; import com.intellij.refactoring.typeCook.deductive.builder.ReductionSystem; import com.intellij.refactoring.typeCook.deductive.builder.Subtype; +import com.intellij.util.containers.EmptyIterator; import com.intellij.util.graph.DFSTBuilder; import com.intellij.util.graph.Graph; import gnu.trove.TIntArrayList; @@ -51,7 +52,7 @@ public class ResolverTree { private final Settings mySettings; private boolean mySolutionFound = false; - private HashSet<Constraint> myConstraints; + private Set<Constraint> myConstraints; public ResolverTree(final ReductionSystem system) { myBindingFactory = new BindingFactory(system); @@ -65,7 +66,7 @@ public class ResolverTree { reduceCyclicVariables(); } - private ResolverTree(final ResolverTree parent, final HashSet<Constraint> constraints, final Binding binding) { + private ResolverTree(final ResolverTree parent, final Set<Constraint> constraints, final Binding binding) { myBindingFactory = parent.myBindingFactory; myCurrentBinding = binding; mySolutions = parent.mySolutions; @@ -76,7 +77,7 @@ public class ResolverTree { } private static class PsiTypeVarCollector extends PsiExtendedTypeVisitor { - final HashSet<PsiTypeVariable> mySet = new HashSet<PsiTypeVariable>(); + final Set<PsiTypeVariable> mySet = new HashSet<PsiTypeVariable>(); @Override public Object visitTypeVariable(final PsiTypeVariable var) { @@ -85,7 +86,7 @@ public class ResolverTree { return null; } - public HashSet<PsiTypeVariable> getSet(final PsiType type) { + public Set<PsiTypeVariable> getSet(final PsiType type) { type.accept(this); return mySet; } @@ -120,14 +121,14 @@ public class ResolverTree { return result; } - private void setDegree(final HashSet<PsiTypeVariable> set, TObjectIntHashMap<PsiTypeVariable> result) { + private void setDegree(final Set<PsiTypeVariable> set, TObjectIntHashMap<PsiTypeVariable> result) { for (final PsiTypeVariable var : set) { result.increment(var); } } - private HashSet<Constraint> apply(final Binding b) { - final HashSet<Constraint> result = new HashSet<Constraint>(); + private Set<Constraint> apply(final Binding b) { + final Set<Constraint> result = new HashSet<Constraint>(); for (final Constraint constr : myConstraints) { result.add(constr.apply(b)); @@ -136,8 +137,8 @@ public class ResolverTree { return result; } - private HashSet<Constraint> apply(final Binding b, final HashSet<Constraint> additional) { - final HashSet<Constraint> result = new HashSet<Constraint>(); + private Set<Constraint> apply(final Binding b, final Set<Constraint> additional) { + final Set<Constraint> result = new HashSet<Constraint>(); for (final Constraint constr : myConstraints) { result.add(constr.apply(b)); @@ -156,18 +157,18 @@ public class ResolverTree { return newBinding == null ? null : new ResolverTree(this, apply(b), newBinding); } - private ResolverTree applyRule(final Binding b, final HashSet<Constraint> additional) { + private ResolverTree applyRule(final Binding b, final Set<Constraint> additional) { final Binding newBinding = b != null ? myCurrentBinding.compose(b) : null; return newBinding == null ? null : new ResolverTree(this, apply(b, additional), newBinding); } private void reduceCyclicVariables() { - final HashSet<PsiTypeVariable> nodes = new HashSet<PsiTypeVariable>(); - final HashSet<Constraint> candidates = new HashSet<Constraint>(); + final Set<PsiTypeVariable> nodes = new HashSet<PsiTypeVariable>(); + final Set<Constraint> candidates = new HashSet<Constraint>(); - final HashMap<PsiTypeVariable, HashSet<PsiTypeVariable>> ins = new HashMap<PsiTypeVariable, HashSet<PsiTypeVariable>>(); - final HashMap<PsiTypeVariable, HashSet<PsiTypeVariable>> outs = new HashMap<PsiTypeVariable, HashSet<PsiTypeVariable>>(); + final Map<PsiTypeVariable, Set<PsiTypeVariable>> ins = new HashMap<PsiTypeVariable, Set<PsiTypeVariable>>(); + final Map<PsiTypeVariable, Set<PsiTypeVariable>> outs = new HashMap<PsiTypeVariable, Set<PsiTypeVariable>>(); for (final Constraint constraint : myConstraints) { final PsiType left = constraint.getLeft(); @@ -182,11 +183,11 @@ public class ResolverTree { nodes.add(leftVar); nodes.add(rightVar); - final HashSet<PsiTypeVariable> in = ins.get(leftVar); - final HashSet<PsiTypeVariable> out = outs.get(rightVar); + Set<PsiTypeVariable> in = ins.get(leftVar); + Set<PsiTypeVariable> out = outs.get(rightVar); if (in == null) { - final HashSet<PsiTypeVariable> newIn = new HashSet<PsiTypeVariable>(); + final Set<PsiTypeVariable> newIn = new HashSet<PsiTypeVariable>(); newIn.add(rightVar); @@ -197,7 +198,7 @@ public class ResolverTree { } if (out == null) { - final HashSet<PsiTypeVariable> newOut = new HashSet<PsiTypeVariable>(); + final Set<PsiTypeVariable> newOut = new HashSet<PsiTypeVariable>(); newOut.add(leftVar); @@ -217,10 +218,10 @@ public class ResolverTree { @Override public Iterator<PsiTypeVariable> getIn(final PsiTypeVariable n) { - final HashSet<PsiTypeVariable> in = ins.get(n); + final Set<PsiTypeVariable> in = ins.get(n); if (in == null) { - return new HashSet<PsiTypeVariable>().iterator(); + return EmptyIterator.getInstance(); } return in.iterator(); @@ -228,10 +229,10 @@ public class ResolverTree { @Override public Iterator<PsiTypeVariable> getOut(final PsiTypeVariable n) { - final HashSet<PsiTypeVariable> out = outs.get(n); + final Set<PsiTypeVariable> out = outs.get(n); if (out == null) { - return new HashSet<PsiTypeVariable>().iterator(); + return EmptyIterator.getInstance(); } return out.iterator(); @@ -240,7 +241,7 @@ public class ResolverTree { }); final TIntArrayList sccs = dfstBuilder.getSCCs(); - final HashMap<PsiTypeVariable, Integer> index = new HashMap<PsiTypeVariable, Integer>(); + final Map<PsiTypeVariable, Integer> index = new HashMap<PsiTypeVariable, Integer>(); sccs.forEach(new TIntProcedure() { int myTNumber = 0; @@ -284,9 +285,9 @@ public class ResolverTree { private void reduceTypeType(final Constraint constr) { final PsiType left = constr.getLeft(); final PsiType right = constr.getRight(); - final HashSet<Constraint> addendumRise = new HashSet<Constraint>(); - final HashSet<Constraint> addendumSink = new HashSet<Constraint>(); - final HashSet<Constraint> addendumWcrd = new HashSet<Constraint>(); + final Set<Constraint> addendumRise = new HashSet<Constraint>(); + final Set<Constraint> addendumSink = new HashSet<Constraint>(); + final Set<Constraint> addendumWcrd = new HashSet<Constraint>(); int numSons = 0; Binding riseBinding = myBindingFactory.rise(left, right, addendumRise); @@ -356,7 +357,7 @@ public class ResolverTree { private void fillTypeRange(final PsiType lowerBound, final PsiType upperBound, - final HashSet<PsiType> holder) { + final Set<PsiType> holder) { if (lowerBound instanceof PsiClassType && upperBound instanceof PsiClassType) { final PsiClassType.ClassResolveResult resultLower = ((PsiClassType)lowerBound).resolveGenerics(); final PsiClassType.ClassResolveResult resultUpper = ((PsiClassType)upperBound).resolveGenerics(); @@ -385,7 +386,7 @@ public class ResolverTree { } private PsiType[] getTypeRange(final PsiType lowerBound, final PsiType upperBound) { - final HashSet<PsiType> range = new HashSet<PsiType>(); + Set<PsiType> range = new HashSet<PsiType>(); range.add(lowerBound); range.add(upperBound); @@ -464,8 +465,8 @@ public class ResolverTree { reduceCyclicVariables(); } - final HashMap<PsiTypeVariable, Constraint> myTypeVarConstraints = new HashMap<PsiTypeVariable, Constraint>(); - final HashMap<PsiTypeVariable, Constraint> myVarTypeConstraints = new HashMap<PsiTypeVariable, Constraint>(); + final Map<PsiTypeVariable, Constraint> myTypeVarConstraints = new HashMap<PsiTypeVariable, Constraint>(); + final Map<PsiTypeVariable, Constraint> myVarTypeConstraints = new HashMap<PsiTypeVariable, Constraint>(); for (final Constraint constr : myConstraints) { final PsiType left = constr.getLeft(); @@ -530,7 +531,7 @@ public class ResolverTree { final PsiType right = constr.getRight(); if (!(left instanceof PsiTypeVariable) && right instanceof PsiTypeVariable) { - final HashSet<PsiTypeVariable> bound = new PsiTypeVarCollector().getSet(left); + Set<PsiTypeVariable> bound = new PsiTypeVarCollector().getSet(left); if (bound.contains(right)) { myConstraints.remove(constr); @@ -561,10 +562,10 @@ public class ResolverTree { //T1 < a < b < ... { - final HashSet<PsiTypeVariable> haveLeftBound = new HashSet<PsiTypeVariable>(); + Set<PsiTypeVariable> haveLeftBound = new HashSet<PsiTypeVariable>(); Constraint target = null; - final HashSet<PsiTypeVariable> boundVariables = new HashSet<PsiTypeVariable>(); + Set<PsiTypeVariable> boundVariables = new HashSet<PsiTypeVariable>(); for (final Constraint constr : myConstraints) { final PsiType leftType = constr.getLeft(); diff --git a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/util/VictimCollector.java b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/util/VictimCollector.java index 5b2354563ed9..9af367c9fbd1 100644 --- a/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/util/VictimCollector.java +++ b/java/java-impl/src/com/intellij/refactoring/typeCook/deductive/util/VictimCollector.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,13 +19,14 @@ import com.intellij.psi.*; import com.intellij.refactoring.typeCook.Settings; import com.intellij.refactoring.typeCook.Util; -import java.util.HashSet; +import java.util.LinkedHashSet; +import java.util.Set; /** * @author db */ public class VictimCollector extends Visitor { - final HashSet<PsiElement> myVictims = new HashSet<PsiElement>(); + final Set<PsiElement> myVictims = new LinkedHashSet<PsiElement>(); final PsiElement[] myElements; final Settings mySettings; @@ -106,7 +107,7 @@ public class VictimCollector extends Visitor { } } - public HashSet<PsiElement> getVictims() { + public Set<PsiElement> getVictims() { for (PsiElement element : myElements) { element.accept(this); } diff --git a/java/java-impl/src/com/intellij/refactoring/util/ParameterTablePanel.java b/java/java-impl/src/com/intellij/refactoring/util/ParameterTablePanel.java index 83fba883184c..7a427b9fc56f 100644 --- a/java/java-impl/src/com/intellij/refactoring/util/ParameterTablePanel.java +++ b/java/java-impl/src/com/intellij/refactoring/util/ParameterTablePanel.java @@ -310,7 +310,7 @@ public abstract class ParameterTablePanel extends JPanel { case PARAMETER_NAME_COLUMN: { VariableData data = getVariableData()[rowIndex]; String name = (String)aValue; - if (JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(name)) { + if (PsiNameHelper.getInstance(myProject).isIdentifier(name)) { data.name = name; } updateSignature(); diff --git a/java/java-impl/src/com/intellij/refactoring/util/duplicates/MethodDuplicatesHandler.java b/java/java-impl/src/com/intellij/refactoring/util/duplicates/MethodDuplicatesHandler.java index 876617b516e4..4bd3d6db70a5 100644 --- a/java/java-impl/src/com/intellij/refactoring/util/duplicates/MethodDuplicatesHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/util/duplicates/MethodDuplicatesHandler.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,13 +28,14 @@ import com.intellij.openapi.command.CommandProcessor; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.module.Module; -import com.intellij.openapi.module.ModuleUtil; +import com.intellij.openapi.module.ModuleUtilCore; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.progress.Task; import com.intellij.openapi.project.Project; import com.intellij.openapi.project.ProjectUtil; import com.intellij.openapi.ui.Messages; +import com.intellij.openapi.util.Computable; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.wm.WindowManager; import com.intellij.psi.*; @@ -71,7 +72,7 @@ public class MethodDuplicatesHandler implements RefactoringActionHandler { } final AnalysisScope scope = new AnalysisScope(file); - final Module module = ModuleUtil.findModuleForPsiElement(file); + final Module module = ModuleUtilCore.findModuleForPsiElement(file); final BaseAnalysisActionDialog dlg = new BaseAnalysisActionDialog(RefactoringBundle.message("replace.method.duplicates.scope.chooser.title", REFACTORING_NAME), RefactoringBundle.message("replace.method.duplicates.scope.chooser.message"), project, scope, module != null ? module.getName() : null, false, @@ -134,13 +135,18 @@ public class MethodDuplicatesHandler implements RefactoringActionHandler { } final Map<PsiMember, Set<Module>> memberWithModulesMap = new HashMap<PsiMember, Set<Module>>(); - for (PsiMember member : members) { - final Module module = ModuleUtil.findModuleForPsiElement(member); + for (final PsiMember member : members) { + final Module module = ApplicationManager.getApplication().runReadAction(new Computable<Module>() { + @Override + public Module compute() { + return ModuleUtilCore.findModuleForPsiElement(member); + } + }); if (module != null) { final HashSet<Module> dependencies = new HashSet<Module>(); ApplicationManager.getApplication().runReadAction(new Runnable() { public void run() { - ModuleUtil.collectModulesDependsOn(module, dependencies); + ModuleUtilCore.collectModulesDependsOn(module, dependencies); } }); memberWithModulesMap.put(member, dependencies); @@ -158,7 +164,7 @@ public class MethodDuplicatesHandler implements RefactoringActionHandler { progressIndicator.setText2(ProjectUtil.calcRelativeToProjectPath(virtualFile, project)); } } - final Module targetModule = ModuleUtil.findModuleForPsiElement(file); + final Module targetModule = ModuleUtilCore.findModuleForPsiElement(file); if (targetModule == null) return; for (Map.Entry<PsiMember, Set<Module>> entry : memberWithModulesMap.entrySet()) { final Set<Module> dependencies = entry.getValue(); diff --git a/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueDialog.java b/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueDialog.java index ac9b65950590..e7918134afe5 100644 --- a/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueDialog.java @@ -107,8 +107,7 @@ class WrapReturnValueDialog extends RefactoringDialog { @Override protected void canRun() throws ConfigurationException { final Project project = sourceMethod.getProject(); - final JavaPsiFacade manager = JavaPsiFacade.getInstance(project); - final PsiNameHelper nameHelper = manager.getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(project); if (myCreateInnerClassButton.isSelected()) { final String innerClassName = getInnerClassName().trim(); if (!nameHelper.isIdentifier(innerClassName)) throw new ConfigurationException("\'" + innerClassName + "\' is invalid inner class name"); diff --git a/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java b/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java index d59129174520..a08464fbd7ce 100644 --- a/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java +++ b/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -244,7 +244,7 @@ public class SliceLeafAnalyzer { final SliceNodeGuide guide = new SliceNodeGuide(treeStructure); WalkingState<SliceNode> walkingState = new WalkingState<SliceNode>(guide) { @Override - public void visit(@NotNull SliceNode element) { + public void visit(@NotNull final SliceNode element) { element.calculateDupNode(); node(element, map).clear(); SliceNode duplicate = element.getDuplicate(); @@ -252,20 +252,21 @@ public class SliceLeafAnalyzer { node(element, map).addAll(node(duplicate, map)); } else { - final SliceUsage sliceUsage = element.getValue(); - - Collection<? extends AbstractTreeNode> children = element.getChildren(); - if (children.isEmpty()) { - PsiElement value = ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { - @Override - public PsiElement compute() { - return sliceUsage.indexNesting == 0 ? sliceUsage.getElement() : null; + ApplicationManager.getApplication().runReadAction(new Runnable() { + @Override + public void run() { + final SliceUsage sliceUsage = element.getValue(); + + Collection<? extends AbstractTreeNode> children = element.getChildren(); + if (children.isEmpty()) { + PsiElement value = sliceUsage.indexNesting == 0 ? sliceUsage.getElement() : null; + if (value != null) { + node(element, map).addAll(ContainerUtil.singleton(value, LEAF_ELEMENT_EQUALITY)); + } } - }); - if (value != null) { - node(element, map).addAll(ContainerUtil.singleton(value, LEAF_ELEMENT_EQUALITY)); } - } + }); + super.visit(element); } } diff --git a/java/java-impl/src/com/intellij/slicer/SliceNullnessAnalyzer.java b/java/java-impl/src/com/intellij/slicer/SliceNullnessAnalyzer.java index b65932aeaa81..ba6f8602ba46 100644 --- a/java/java-impl/src/com/intellij/slicer/SliceNullnessAnalyzer.java +++ b/java/java-impl/src/com/intellij/slicer/SliceNullnessAnalyzer.java @@ -170,7 +170,7 @@ public class SliceNullnessAnalyzer { final SliceLeafAnalyzer.SliceNodeGuide guide = new SliceLeafAnalyzer.SliceNodeGuide(treeStructure); WalkingState<SliceNode> walkingState = new WalkingState<SliceNode>(guide) { @Override - public void visit(@NotNull SliceNode element) { + public void visit(@NotNull final SliceNode element) { element.calculateDupNode(); node(element, map).clear(); SliceNode duplicate = element.getDuplicate(); @@ -178,11 +178,10 @@ public class SliceNullnessAnalyzer { node(element, map).add(node(duplicate, map)); } else { - final SliceUsage sliceUsage = element.getValue(); final PsiElement value = ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { @Override public PsiElement compute() { - return sliceUsage.getElement(); + return element.getValue().getElement(); } }); Nullness nullness = ApplicationManager.getApplication().runReadAction(new Computable<Nullness>() { @@ -198,7 +197,13 @@ public class SliceNullnessAnalyzer { group(element, map, NullAnalysisResult.NOT_NULLS).add(value); } else { - Collection<? extends AbstractTreeNode> children = element.getChildren(); + Collection<? extends AbstractTreeNode> children = ApplicationManager.getApplication().runReadAction( + new Computable<Collection<? extends AbstractTreeNode>>() { + @Override + public Collection<? extends AbstractTreeNode> compute() { + return element.getChildren(); + } + }); if (children.isEmpty()) { group(element, map, NullAnalysisResult.UNKNOWNS).add(value); } diff --git a/java/java-impl/src/com/intellij/slicer/SliceUsage.java b/java/java-impl/src/com/intellij/slicer/SliceUsage.java index b8d5a34c3c61..ef68b0d6a28e 100644 --- a/java/java-impl/src/com/intellij/slicer/SliceUsage.java +++ b/java/java-impl/src/com/intellij/slicer/SliceUsage.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,6 +19,7 @@ import com.intellij.analysis.AnalysisScope; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressManager; +import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiSubstitutor; import com.intellij.usageView.UsageInfo; @@ -68,7 +69,12 @@ public class SliceUsage extends UsageInfo2UsageAdapter { } public void processChildren(@NotNull Processor<SliceUsage> processor) { - final PsiElement element = getElement(); + final PsiElement element = ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { + @Override + public PsiElement compute() { + return getElement(); + } + }); ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator(); indicator.checkCanceled(); diff --git a/java/java-impl/src/com/intellij/testIntegration/createTest/CreateTestDialog.java b/java/java-impl/src/com/intellij/testIntegration/createTest/CreateTestDialog.java index 5be9ce379705..a620938830ef 100644 --- a/java/java-impl/src/com/intellij/testIntegration/createTest/CreateTestDialog.java +++ b/java/java-impl/src/com/intellij/testIntegration/createTest/CreateTestDialog.java @@ -185,7 +185,7 @@ public class CreateTestDialog extends DialogWrapper { myTargetClassNameField.getDocument().addDocumentListener(new DocumentAdapter() { @Override public void documentChanged(DocumentEvent e) { - getOKAction().setEnabled(JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getClassName())); + getOKAction().setEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(getClassName())); } }); diff --git a/java/java-impl/src/com/intellij/testIntegration/createTest/JavaTestGenerator.java b/java/java-impl/src/com/intellij/testIntegration/createTest/JavaTestGenerator.java index abde9233f535..fd96a06d6cd4 100644 --- a/java/java-impl/src/com/intellij/testIntegration/createTest/JavaTestGenerator.java +++ b/java/java-impl/src/com/intellij/testIntegration/createTest/JavaTestGenerator.java @@ -28,6 +28,7 @@ import com.intellij.openapi.editor.Editor; import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.Messages; +import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; @@ -63,12 +64,17 @@ public class JavaTestGenerator implements TestGenerator { if (targetClass == null) { return null; } - addSuperClass(targetClass, project, d.getSuperClassName()); + final TestFramework frameworkDescriptor = d.getSelectedTestFrameworkDescriptor(); + final String defaultSuperClass = frameworkDescriptor.getDefaultSuperClass(); + final String superClassName = d.getSuperClassName(); + if (!Comparing.strEqual(superClassName, defaultSuperClass)) { + addSuperClass(targetClass, project, superClassName); + } Editor editor = CodeInsightUtil.positionCursor(project, targetClass.getContainingFile(), targetClass.getLBrace()); addTestMethods(editor, targetClass, - d.getSelectedTestFrameworkDescriptor(), + frameworkDescriptor, d.getSelectedMethods(), d.shouldGeneratedBefore(), d.shouldGeneratedAfter()); @@ -135,7 +141,7 @@ public class JavaTestGenerator implements TestGenerator { private static void addSuperClass(PsiClass targetClass, Project project, String superClassName) throws IncorrectOperationException { if (superClassName == null) return; final PsiReferenceList extendsList = targetClass.getExtendsList(); - if (extendsList == null || extendsList.getReferencedTypes().length > 0) return; + if (extendsList == null) return; PsiElementFactory ef = JavaPsiFacade.getInstance(project).getElementFactory(); PsiJavaCodeReferenceElement superClassRef; @@ -147,7 +153,12 @@ public class JavaTestGenerator implements TestGenerator { else { superClassRef = ef.createFQClassNameReferenceElement(superClassName, GlobalSearchScope.allScope(project)); } - extendsList.add(superClassRef); + final PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements(); + if (referenceElements.length == 0) { + extendsList.add(superClassRef); + } else { + referenceElements[0].replace(superClassRef); + } } @Nullable diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/AllOverridingMethodsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/AllOverridingMethodsSearch.java index 4cc0cdf9642f..32067d077a48 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/AllOverridingMethodsSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/AllOverridingMethodsSearch.java @@ -23,6 +23,7 @@ import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.EmptyQuery; import com.intellij.util.Query; import com.intellij.util.QueryExecutor; @@ -63,6 +64,6 @@ public class AllOverridingMethodsSearch extends ExtensibleQueryFactory<Pair<PsiM } public static Query<Pair<PsiMethod, PsiMethod>> search(final PsiClass aClass) { - return search(aClass, GlobalSearchScope.allScope(aClass.getProject())); + return search(aClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(aClass))); } } diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedMembersSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedMembersSearch.java index 14e37a51b86f..f6003eb12fb5 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedMembersSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedMembersSearch.java @@ -19,6 +19,7 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMember; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Query; import org.jetbrains.annotations.NotNull; @@ -34,6 +35,6 @@ public class AnnotatedMembersSearch { } public static Query<PsiMember> search(@NotNull PsiClass annotationClass) { - return search(annotationClass, GlobalSearchScope.allScope(annotationClass.getProject())); + return search(annotationClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(annotationClass))); } } diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedPackagesSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedPackagesSearch.java index 17e3fa0f617c..69548d5ff317 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedPackagesSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotatedPackagesSearch.java @@ -19,6 +19,7 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiPackage; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Query; import org.jetbrains.annotations.NotNull; @@ -53,6 +54,6 @@ public class AnnotatedPackagesSearch extends ExtensibleQueryFactory<PsiPackage, } public static Query<PsiPackage> search(@NotNull PsiClass annotationClass) { - return search(annotationClass, GlobalSearchScope.allScope(annotationClass.getProject())); + return search(annotationClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(annotationClass))); } }
\ No newline at end of file diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotationTargetsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotationTargetsSearch.java index c177985396a9..0b42ceae1709 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotationTargetsSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/AnnotationTargetsSearch.java @@ -21,6 +21,7 @@ import com.intellij.psi.PsiModifierListOwner; import com.intellij.psi.PsiPackage; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.MergeQuery; import com.intellij.util.Query; import org.jetbrains.annotations.NotNull; @@ -58,6 +59,6 @@ public class AnnotationTargetsSearch { } public static Query<PsiModifierListOwner> search(@NotNull PsiClass annotationClass) { - return search(annotationClass, GlobalSearchScope.allScope(annotationClass.getProject())); + return search(annotationClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(annotationClass))); } }
\ No newline at end of file diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java index e07692008ff9..cc6bf9d3044d 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.extensions.ExtensionPointName; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressIndicatorProvider; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Pair; @@ -28,6 +29,7 @@ import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.PsiSearchScopeUtil; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.reference.SoftReference; import com.intellij.util.Processor; import com.intellij.util.Query; @@ -188,7 +190,8 @@ public class ClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass, Clas } }); if (CommonClassNames.JAVA_LANG_OBJECT.equals(qname)) { - return AllClassesSearch.search(searchScope, baseClass.getProject(), parameters.getNameCondition()).forEach(new Processor<PsiClass>() { + Project project = PsiUtilCore.getProjectInReadAction(baseClass); + return AllClassesSearch.search(searchScope, project, parameters.getNameCondition()).forEach(new Processor<PsiClass>() { @Override public boolean process(final PsiClass aClass) { ProgressIndicatorProvider.checkCanceled(); @@ -250,7 +253,7 @@ public class ClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass, Clas } }; stack.push(Pair.create(createHardReference(baseClass), qname)); - final GlobalSearchScope projectScope = GlobalSearchScope.allScope(baseClass.getProject()); + final GlobalSearchScope projectScope = GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(baseClass)); final JavaPsiFacade facade = JavaPsiFacade.getInstance(projectScope.getProject()); while (!stack.isEmpty()) { ProgressIndicatorProvider.checkCanceled(); diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java index da798a15ed3b..1a98d0c167d3 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,6 +21,7 @@ import com.intellij.psi.PsiAnonymousClass; import com.intellij.psi.PsiClass; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.FilteredQuery; import com.intellij.util.Query; import com.intellij.util.QueryExecutor; @@ -73,7 +74,7 @@ public class DirectClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass private DirectClassInheritorsSearch() {} public static Query<PsiClass> search(final PsiClass aClass) { - return search(aClass, GlobalSearchScope.allScope(aClass.getProject())); + return search(aClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(aClass))); } public static Query<PsiClass> search(final PsiClass aClass, SearchScope scope) { diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/FunctionalExpressionSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/FunctionalExpressionSearch.java index 8ad915c5ed95..f729579a5782 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/FunctionalExpressionSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/FunctionalExpressionSearch.java @@ -15,7 +15,9 @@ */ package com.intellij.psi.search.searches; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiFunctionalExpression; import com.intellij.psi.PsiMethod; @@ -23,6 +25,7 @@ import com.intellij.psi.PsiModifier; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.PsiSearchHelper; import com.intellij.psi.search.SearchScope; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.EmptyQuery; import com.intellij.util.Query; import com.intellij.util.QueryExecutor; @@ -36,7 +39,7 @@ public class FunctionalExpressionSearch extends ExtensibleQueryFactory<PsiFuncti private final PsiClass myElementToSearch; private final SearchScope myScope; - public SearchParameters(PsiClass aClass, SearchScope scope) { + public SearchParameters(@NotNull PsiClass aClass, @NotNull SearchScope scope) { myElementToSearch = aClass; myScope = scope; } @@ -52,23 +55,28 @@ public class FunctionalExpressionSearch extends ExtensibleQueryFactory<PsiFuncti } } - public static Query<PsiFunctionalExpression> search(final PsiClass aClass, SearchScope scope) { + public static Query<PsiFunctionalExpression> search(@NotNull final PsiClass aClass, @NotNull SearchScope scope) { return INSTANCE.createUniqueResultsQuery(new SearchParameters(aClass, scope)); } - public static Query<PsiFunctionalExpression> search(final PsiMethod psiMethod) { - return search(psiMethod, GlobalSearchScope.allScope(psiMethod.getProject())); + public static Query<PsiFunctionalExpression> search(@NotNull final PsiMethod psiMethod) { + return search(psiMethod, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(psiMethod))); } - public static Query<PsiFunctionalExpression> search(final PsiMethod psiMethod, SearchScope scope) { - if (!psiMethod.hasModifierProperty(PsiModifier.STATIC) && !psiMethod.hasModifierProperty(PsiModifier.DEFAULT)) { - return INSTANCE.createUniqueResultsQuery(new SearchParameters(psiMethod.getContainingClass(), scope)); - } + public static Query<PsiFunctionalExpression> search(@NotNull final PsiMethod psiMethod, @NotNull final SearchScope scope) { + return ApplicationManager.getApplication().runReadAction(new Computable<Query<PsiFunctionalExpression>>() { + @Override + public Query<PsiFunctionalExpression> compute() { + if (!psiMethod.hasModifierProperty(PsiModifier.STATIC) && !psiMethod.hasModifierProperty(PsiModifier.DEFAULT)) { + return INSTANCE.createUniqueResultsQuery(new SearchParameters(psiMethod.getContainingClass(), scope)); + } - return EmptyQuery.getEmptyQuery(); + return EmptyQuery.getEmptyQuery(); + } + }); } - public static Query<PsiFunctionalExpression> search(final PsiClass aClass) { - return search(aClass, GlobalSearchScope.allScope(aClass.getProject())); + public static Query<PsiFunctionalExpression> search(@NotNull final PsiClass aClass) { + return search(aClass, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(aClass))); } } diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java index 5dd9726db029..e6b0e19e9701 100644 --- a/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java +++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/MethodReferencesSearch.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,9 +16,11 @@ package com.intellij.psi.search.searches; import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiReference; import com.intellij.psi.search.*; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.*; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; @@ -98,11 +100,12 @@ public static void searchOptimized(final PsiMethod method, SearchScope scope, fi final SearchRequestCollector requests = parameters.getOptimizer(); - return uniqueResults(new MergeQuery<PsiReference>(result, new SearchRequestQuery(parameters.getMethod().getProject(), requests))); + Project project = PsiUtilCore.getProjectInReadAction(parameters.getMethod()); + return uniqueResults(new MergeQuery<PsiReference>(result, new SearchRequestQuery(project, requests))); } public static Query<PsiReference> search(final PsiMethod method, final boolean strictSignatureSearch) { - return search(method, GlobalSearchScope.allScope(method.getProject()), strictSignatureSearch); + return search(method, GlobalSearchScope.allScope(PsiUtilCore.getProjectInReadAction(method)), strictSignatureSearch); } public static Query<PsiReference> search(final PsiMethod method) { diff --git a/java/java-indexing-impl/src/com/intellij/codeInsight/navigation/MethodImplementationsSearch.java b/java/java-indexing-impl/src/com/intellij/codeInsight/navigation/MethodImplementationsSearch.java index f77b536f7876..9a5f5ac4ddc1 100644 --- a/java/java-indexing-impl/src/com/intellij/codeInsight/navigation/MethodImplementationsSearch.java +++ b/java/java-indexing-impl/src/com/intellij/codeInsight/navigation/MethodImplementationsSearch.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,10 +28,11 @@ import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import java.util.ArrayList; +import java.util.List; public class MethodImplementationsSearch implements QueryExecutor<PsiElement, DefinitionsScopedSearch.SearchParameters> { @Override - public boolean execute(final @NotNull DefinitionsScopedSearch.SearchParameters queryParameters, final @NotNull Processor<PsiElement> consumer) { + public boolean execute(@NotNull final DefinitionsScopedSearch.SearchParameters queryParameters, @NotNull final Processor<PsiElement> consumer) { final PsiElement sourceElement = queryParameters.getElement(); if (sourceElement instanceof PsiMethod) { return processImplementations((PsiMethod)sourceElement, consumer, queryParameters.getScope()); @@ -49,12 +50,12 @@ public class MethodImplementationsSearch implements QueryExecutor<PsiElement, De })) { return false; } - final ArrayList<PsiMethod> methods = new ArrayList<PsiMethod>(); + List<PsiMethod> methods = new ArrayList<PsiMethod>(); getOverridingMethods(psiMethod, methods, searchScope); return ContainerUtil.process(methods, consumer); } - public static void getOverridingMethods(PsiMethod method, ArrayList<PsiMethod> list, SearchScope scope) { + public static void getOverridingMethods(PsiMethod method, List<PsiMethod> list, SearchScope scope) { for (PsiMethod psiMethod : OverridingMethodsSearch.search(method, scope, true)) { list.add(psiMethod); } @@ -63,7 +64,7 @@ public class MethodImplementationsSearch implements QueryExecutor<PsiElement, De @SuppressWarnings("UnusedDeclaration") @Deprecated public static PsiMethod[] getMethodImplementations(final PsiMethod method, SearchScope scope) { - ArrayList<PsiMethod> result = new ArrayList<PsiMethod>(); + List<PsiMethod> result = new ArrayList<PsiMethod>(); getOverridingMethods(method, result, scope); return result.toArray(new PsiMethod[result.size()]); diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/file/impl/JavaFileManagerImpl.java b/java/java-indexing-impl/src/com/intellij/psi/impl/file/impl/JavaFileManagerImpl.java index 1b14c8ff462d..0c2087893e04 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/file/impl/JavaFileManagerImpl.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/file/impl/JavaFileManagerImpl.java @@ -179,7 +179,7 @@ public class JavaFileManagerImpl implements JavaFileManager, Disposable { // See IDEADEV-5626 final VirtualFile root = ProjectRootManager.getInstance(myManager.getProject()).getFileIndex().getClassRootForFile(vFile); VirtualFile parent = vFile.getParent(); - final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(myManager.getProject()).getNameHelper(); + final PsiNameHelper nameHelper = PsiNameHelper.getInstance(myManager.getProject()); while (parent != null && !Comparing.equal(parent, root)) { if (!nameHelper.isIdentifier(parent.getName())) return false; parent = parent.getParent(); diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedElementsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedElementsSearcher.java index dec2dccb341e..53fa2eb48604 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedElementsSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedElementsSearcher.java @@ -18,7 +18,6 @@ package com.intellij.psi.impl.search; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.util.Computable; import com.intellij.psi.*; -import com.intellij.psi.impl.PsiManagerImpl; import com.intellij.psi.impl.java.stubs.index.JavaAnnotationIndex; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.LocalSearchScope; @@ -50,7 +49,12 @@ public class AnnotatedElementsSearcher implements QueryExecutor<PsiModifierListO }); assert annotationFQN != null; - final PsiManagerImpl psiManager = (PsiManagerImpl)annClass.getManager(); + final PsiManager psiManager = ApplicationManager.getApplication().runReadAction(new Computable<PsiManager>() { + @Override + public PsiManager compute() { + return annClass.getManager(); + } + }); final SearchScope useScope = p.getScope(); final Class<? extends PsiModifierListOwner>[] types = p.getTypes(); diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedPackagesSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedPackagesSearcher.java index 4437b3f49e51..51565a81e5f4 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedPackagesSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/AnnotatedPackagesSearcher.java @@ -19,15 +19,15 @@ */ package com.intellij.psi.impl.search; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.Module; +import com.intellij.openapi.util.Computable; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.psi.impl.PsiManagerImpl; import com.intellij.psi.impl.java.stubs.index.JavaAnnotationIndex; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.PsiSearchHelper; -import com.intellij.psi.search.SearchScope; import com.intellij.psi.search.searches.AnnotatedPackagesSearch; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.Processor; @@ -44,49 +44,67 @@ public class AnnotatedPackagesSearcher implements QueryExecutor<PsiPackage, Anno final PsiClass annClass = p.getAnnotationClass(); assert annClass.isAnnotationType() : "Annotation type should be passed to annotated packages search"; - final String annotationFQN = annClass.getQualifiedName(); + final String annotationFQN = ApplicationManager.getApplication().runReadAction(new Computable<String>() { + @Override + public String compute() { + return annClass.getQualifiedName(); + } + }); assert annotationFQN != null; - final PsiManagerImpl psiManager = (PsiManagerImpl)annClass.getManager(); - final SearchScope useScope = p.getScope(); + final PsiManager psiManager = ApplicationManager.getApplication().runReadAction(new Computable<PsiManager>() { + @Override + public PsiManager compute() { + return annClass.getManager(); + } + }); + final GlobalSearchScope useScope = (GlobalSearchScope)p.getScope(); - final String annotationShortName = annClass.getName(); + final String annotationShortName = ApplicationManager.getApplication().runReadAction(new Computable<String>() { + @Override + public String compute() { + return annClass.getName(); + } + }); assert annotationShortName != null; - final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : null; - - final Collection<PsiAnnotation> annotations = JavaAnnotationIndex.getInstance().get(annotationShortName, psiManager.getProject(), scope); - for (PsiAnnotation annotation : annotations) { - PsiModifierList modlist = (PsiModifierList)annotation.getParent(); - final PsiElement owner = modlist.getParent(); - if (!(owner instanceof PsiClass)) continue; - PsiClass candidate = (PsiClass)owner; - if (!"package-info".equals(candidate.getName())) continue; - - LOG.assertTrue(candidate.isValid()); - - final PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement(); - if (ref == null) continue; - - if (!psiManager.areElementsEquivalent(ref.resolve(), annClass)) continue; - if (useScope instanceof GlobalSearchScope && - !((GlobalSearchScope)useScope).contains(candidate.getContainingFile().getVirtualFile())) { - continue; - } - final String qname = candidate.getQualifiedName(); - if (qname != null && !consumer.process(JavaPsiFacade.getInstance(psiManager.getProject()).findPackage( - qname.substring(0, qname.lastIndexOf('.'))))) { - return false; - } + final Collection<PsiAnnotation> annotations = JavaAnnotationIndex.getInstance().get(annotationShortName, psiManager.getProject(), + useScope); + + for (final PsiAnnotation annotation : annotations) { + boolean accepted = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>(){ + @Override + public Boolean compute() { + PsiModifierList modlist = (PsiModifierList)annotation.getParent(); + final PsiElement owner = modlist.getParent(); + if ((owner instanceof PsiClass)) { + PsiClass candidate = (PsiClass)owner; + if ("package-info".equals(candidate.getName())) { + LOG.assertTrue(candidate.isValid()); + final PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement(); + if (ref != null && psiManager.areElementsEquivalent(ref.resolve(), annClass) && + useScope.contains(candidate.getContainingFile().getVirtualFile())) { + final String qname = candidate.getQualifiedName(); + if (qname != null && !consumer.process(JavaPsiFacade.getInstance(psiManager.getProject()).findPackage( + qname.substring(0, qname.lastIndexOf('.'))))) { + return false; + } + } + } + } + return true; + } + }); + if (!accepted) return false; } PsiSearchHelper helper = PsiSearchHelper.SERVICE.getInstance(psiManager.getProject()); final GlobalSearchScope infoFilesFilter = new PackageInfoFilesOnly(); GlobalSearchScope infoFiles = - useScope instanceof GlobalSearchScope ? ((GlobalSearchScope)useScope).intersectWith(infoFilesFilter) : infoFilesFilter; + useScope.intersectWith(infoFilesFilter); - final boolean[] wantmore = {true}; + final boolean[] wantMore = {true}; helper.processAllFilesWithWord(annotationShortName, infoFiles, new Processor<PsiFile>() { @Override public boolean process(final PsiFile psiFile) { @@ -103,12 +121,12 @@ public class AnnotatedPackagesSearcher implements QueryExecutor<PsiPackage, Anno if (!psiManager.areElementsEquivalent(ref.resolve(), annClass)) return true; - wantmore[0] = consumer.process(JavaPsiFacade.getInstance(psiManager.getProject()).findPackage(stmt.getPackageName())); - return wantmore[0]; + wantMore[0] = consumer.process(JavaPsiFacade.getInstance(psiManager.getProject()).findPackage(stmt.getPackageName())); + return wantMore[0]; } }, true); - return wantmore[0]; + return wantMore[0]; } private static class PackageInfoFilesOnly extends GlobalSearchScope { diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaAllOverridingMethodsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaAllOverridingMethodsSearcher.java index 35ec8b2800e7..f8f824b77c95 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaAllOverridingMethodsSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaAllOverridingMethodsSearcher.java @@ -15,6 +15,8 @@ */ package com.intellij.psi.impl.search; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Pair; import com.intellij.psi.*; import com.intellij.psi.search.SearchScope; @@ -39,11 +41,18 @@ public class JavaAllOverridingMethodsSearcher implements QueryExecutor<Pair<PsiM public boolean execute(@NotNull final AllOverridingMethodsSearch.SearchParameters p, @NotNull final Processor<Pair<PsiMethod, PsiMethod>> consumer) { final PsiClass psiClass = p.getPsiClass(); - PsiMethod[] methodsArray = psiClass.getMethods(); - final List<PsiMethod> methods = new ArrayList<PsiMethod>(methodsArray.length); - for (PsiMethod method : methodsArray) { - if (PsiUtil.canBeOverriden(method)) methods.add(method); - } + final List<PsiMethod> methods = ApplicationManager.getApplication().runReadAction(new Computable<List<PsiMethod>>() { + @Override + public List<PsiMethod> compute() { + PsiMethod[] methodsArray = psiClass.getMethods(); + final List<PsiMethod> methods = new ArrayList<PsiMethod>(methodsArray.length); + for (PsiMethod method : methodsArray) { + if (PsiUtil.canBeOverriden(method)) methods.add(method); + } + return methods; + } + }); + final SearchScope scope = p.getScope(); diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java index fb012672660d..287d43f4cf2d 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,12 +17,12 @@ package com.intellij.psi.impl.search; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.progress.ProgressIndicatorProvider; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.psi.impl.PsiManagerImpl; import com.intellij.psi.impl.java.stubs.index.JavaAnonymousClassBaseRefOccurenceIndex; import com.intellij.psi.impl.java.stubs.index.JavaSuperClassNameOccurenceIndex; import com.intellij.psi.search.EverythingGlobalScope; @@ -31,6 +31,7 @@ import com.intellij.psi.search.SearchScope; import com.intellij.psi.search.searches.AllClassesSearch; import com.intellij.psi.search.searches.DirectClassInheritorsSearch; import com.intellij.psi.util.PsiUtil; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Processor; import com.intellij.util.QueryExecutor; import com.intellij.util.containers.ContainerUtil; @@ -49,7 +50,6 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir @Override public boolean execute(@NotNull final DirectClassInheritorsSearch.SearchParameters p, @NotNull final Processor<PsiClass> consumer) { final PsiClass aClass = p.getClassToProcess(); - final PsiManagerImpl psiManager = (PsiManagerImpl)aClass.getManager(); final SearchScope useScope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() { @Override @@ -65,13 +65,13 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir } }); + final Project project = PsiUtilCore.getProjectInReadAction(aClass); if (CommonClassNames.JAVA_LANG_OBJECT.equals(qualifiedName)) { //[pasynkov]: WTF? //final SearchScope scope = useScope.intersectWith(GlobalSearchScope.notScope(GlobalSearchScope.getScopeRestrictedByFileTypes( // GlobalSearchScope.allScope(psiManager.getProject()), StdFileTypes.JSP, StdFileTypes.JSPX))); - final SearchScope scope = useScope; - return AllClassesSearch.search(scope, aClass.getProject()).forEach(new Processor<PsiClass>() { + return AllClassesSearch.search(useScope, project).forEach(new Processor<PsiClass>() { @Override public boolean process(final PsiClass psiClass) { if (psiClass.isInterface()) { @@ -90,7 +90,7 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir }); } - final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : new EverythingGlobalScope(psiManager.getProject()); + final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : new EverythingGlobalScope(project); final String searchKey = ApplicationManager.getApplication().runReadAction(new Computable<String>() { @Override public String compute() { @@ -104,15 +104,20 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir Collection<PsiReferenceList> candidates = ApplicationManager.getApplication().runReadAction(new Computable<Collection<PsiReferenceList>>() { @Override public Collection<PsiReferenceList> compute() { - return JavaSuperClassNameOccurenceIndex.getInstance().get(searchKey, psiManager.getProject(), scope); + return JavaSuperClassNameOccurenceIndex.getInstance().get(searchKey, project, scope); } }); Map<String, List<PsiClass>> classes = new HashMap<String, List<PsiClass>>(); - for (PsiReferenceList referenceList : candidates) { + for (final PsiReferenceList referenceList : candidates) { ProgressIndicatorProvider.checkCanceled(); - final PsiClass candidate = (PsiClass)referenceList.getParent(); + final PsiClass candidate = (PsiClass)ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() { + @Override + public PsiElement compute() { + return referenceList.getParent(); + } + }); if (!checkInheritance(p, aClass, candidate)) continue; String fqn = ApplicationManager.getApplication().runReadAction(new Computable<String>() { @@ -137,7 +142,7 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir Collection<PsiAnonymousClass> anonymousCandidates = ApplicationManager.getApplication().runReadAction(new Computable<Collection<PsiAnonymousClass>>() { @Override public Collection<PsiAnonymousClass> compute() { - return JavaAnonymousClassBaseRefOccurenceIndex.getInstance().get(searchKey, psiManager.getProject(), scope); + return JavaAnonymousClassBaseRefOccurenceIndex.getInstance().get(searchKey, project, scope); } }); @@ -148,7 +153,13 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir if (!consumer.process(candidate)) return false; } - if (aClass.isEnum()) { + boolean isEnum = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + return aClass.isEnum(); + } + }); + if (isEnum) { // abstract enum can be subclassed in the body PsiField[] fields = ApplicationManager.getApplication().runReadAction(new Computable<PsiField[]>() { @Override @@ -189,10 +200,10 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir // if there is a class from the same jar, prefer it boolean sameJarClassFound = false; - VirtualFile jarFile = PsiUtil.getJarFile(aClass); + VirtualFile jarFile = getJarFile(aClass); if (jarFile != null) { for (PsiClass sameNamedClass : sameNamedClasses) { - boolean fromSameJar = Comparing.equal(PsiUtil.getJarFile(sameNamedClass), jarFile); + boolean fromSameJar = Comparing.equal(getJarFile(sameNamedClass), jarFile); if (fromSameJar) { sameJarClassFound = true; if (!consumer.process(sameNamedClass)) return false; @@ -202,4 +213,13 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor<PsiClass, Dir return sameJarClassFound || ContainerUtil.process(sameNamedClasses, consumer); } + + private static VirtualFile getJarFile(final PsiClass aClass) { + return ApplicationManager.getApplication().runReadAction(new Computable<VirtualFile>() { + @Override + public VirtualFile compute() { + return PsiUtil.getJarFile(aClass); + } + }); + } } diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java index 2ee2cc2d8123..e7da21e37b51 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java @@ -27,6 +27,7 @@ import com.intellij.psi.search.searches.FunctionalExpressionSearch; import com.intellij.psi.search.searches.MethodReferencesSearch; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiUtil; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Processor; import com.intellij.util.QueryExecutor; import org.jetbrains.annotations.NotNull; @@ -36,15 +37,15 @@ import java.util.Collection; public class JavaFunctionalExpressionSearcher implements QueryExecutor<PsiFunctionalExpression, FunctionalExpressionSearch.SearchParameters> { @Override - public boolean execute(final @NotNull FunctionalExpressionSearch.SearchParameters queryParameters, - final @NotNull Processor<PsiFunctionalExpression> consumer) { + public boolean execute(@NotNull final FunctionalExpressionSearch.SearchParameters queryParameters, + @NotNull final Processor<PsiFunctionalExpression> consumer) { final PsiClass aClass = queryParameters.getElementToSearch(); - if (!ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + if (ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { @Override public Boolean compute() { - return LambdaUtil.isFunctionalClass(aClass); + return !LambdaUtil.isFunctionalClass(aClass) || !PsiUtil.isLanguageLevel8OrHigher(aClass); } - }) || !PsiUtil.isLanguageLevel8OrHigher(aClass)) { + })) { return true; } return collectFunctionalExpressions(aClass, ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() { @@ -64,8 +65,13 @@ public class JavaFunctionalExpressionSearcher implements QueryExecutor<PsiFuncti return aClass.getUseScope(); } }); - final SearchScope useScope = searchScope.intersectWith(classScope); - final Project project = aClass.getProject(); + final SearchScope useScope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() { + @Override + public SearchScope compute() { + return searchScope.intersectWith(classScope); + } + }); + final Project project = PsiUtilCore.getProjectInReadAction(aClass); final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : new EverythingGlobalScope(project); final Collection<PsiMethod> lambdaCandidates = ApplicationManager.getApplication().runReadAction(new Computable<Collection<PsiMethod>>() { @Override @@ -76,16 +82,16 @@ public class JavaFunctionalExpressionSearcher implements QueryExecutor<PsiFuncti } }); for (PsiMethod psiMethod : lambdaCandidates) { - for (PsiReference ref : MethodReferencesSearch.search(psiMethod, scope, false)) { - final PsiElement refElement = ref.getElement(); - if (refElement != null) { - final PsiElement candidateElement = refElement.getParent(); - if (candidateElement instanceof PsiCallExpression) { - final PsiExpressionList argumentList = ((PsiCallExpression)candidateElement).getArgumentList(); - if (argumentList != null) { - final Boolean accepted = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { - @Override - public Boolean compute() { + for (final PsiReference ref : MethodReferencesSearch.search(psiMethod, scope, false)) { + boolean accepted = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + final PsiElement refElement = ref.getElement(); + if (refElement != null) { + final PsiElement candidateElement = refElement.getParent(); + if (candidateElement instanceof PsiCallExpression) { + final PsiExpressionList argumentList = ((PsiCallExpression)candidateElement).getArgumentList(); + if (argumentList != null) { final PsiExpression[] args = argumentList.getExpressions(); for (PsiExpression arg : args) { if (arg instanceof PsiFunctionalExpression) { @@ -96,57 +102,66 @@ public class JavaFunctionalExpressionSearcher implements QueryExecutor<PsiFuncti } } } - return true; } - }); - if (!accepted) return false; + } } + return true; } - } + }); + if (!accepted) return false; } } - for (PsiReference reference : ReferencesSearch.search(aClass, scope)) { - final PsiElement element = reference.getElement(); - if (element != null) { - final PsiElement parent = element.getParent(); - if (parent instanceof PsiTypeElement) { - final PsiElement gParent = parent.getParent(); - if (gParent instanceof PsiVariable) { - final PsiExpression initializer = PsiUtil.skipParenthesizedExprDown(((PsiVariable)gParent).getInitializer()); - if (initializer instanceof PsiFunctionalExpression) { - if (!consumer.process((PsiFunctionalExpression)initializer)) return false; - } - for (PsiReference varRef : ReferencesSearch.search(parent, scope)) { - final PsiElement varElement = varRef.getElement(); - if (varElement != null) { - final PsiElement varElementParent = varElement.getParent(); - if (varElementParent instanceof PsiAssignmentExpression && - ((PsiAssignmentExpression)varElementParent).getLExpression() == varElement) { - final PsiExpression rExpression = PsiUtil.skipParenthesizedExprDown(((PsiAssignmentExpression)varElementParent).getRExpression()); - if (rExpression instanceof PsiFunctionalExpression) { - if (!consumer.process((PsiFunctionalExpression)rExpression)) return false; + for (final PsiReference reference : ReferencesSearch.search(aClass, scope)) { + boolean accepted = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + final PsiElement element = reference.getElement(); + if (element != null) { + final PsiElement parent = element.getParent(); + if (parent instanceof PsiTypeElement) { + final PsiElement gParent = parent.getParent(); + if (gParent instanceof PsiVariable) { + final PsiExpression initializer = PsiUtil.skipParenthesizedExprDown(((PsiVariable)gParent).getInitializer()); + if (initializer instanceof PsiFunctionalExpression) { + if (!consumer.process((PsiFunctionalExpression)initializer)) return false; + } + for (PsiReference varRef : ReferencesSearch.search(parent, scope)) { + final PsiElement varElement = varRef.getElement(); + if (varElement != null) { + final PsiElement varElementParent = varElement.getParent(); + if (varElementParent instanceof PsiAssignmentExpression && + ((PsiAssignmentExpression)varElementParent).getLExpression() == varElement) { + final PsiExpression rExpression = PsiUtil.skipParenthesizedExprDown(((PsiAssignmentExpression)varElementParent).getRExpression()); + if (rExpression instanceof PsiFunctionalExpression) { + if (!consumer.process((PsiFunctionalExpression)rExpression)) return false; + } + } } } - } - } - } else if (gParent instanceof PsiMethod) { - final PsiReturnStatement[] returnStatements = ApplicationManager.getApplication().runReadAction( - new Computable<PsiReturnStatement[]>() { - @Override - public PsiReturnStatement[] compute() { - return PsiUtil.findReturnStatements((PsiMethod)gParent); + } else if (gParent instanceof PsiMethod) { + final PsiReturnStatement[] returnStatements = ApplicationManager.getApplication().runReadAction( + new Computable<PsiReturnStatement[]>() { + @Override + public PsiReturnStatement[] compute() { + return PsiUtil.findReturnStatements((PsiMethod)gParent); + } + }); + for (PsiReturnStatement returnStatement : returnStatements) { + final PsiExpression returnValue = returnStatement.getReturnValue(); + if (returnValue instanceof PsiFunctionalExpression) { + if (!consumer.process((PsiFunctionalExpression)returnValue)) return false; + } } - }); - for (PsiReturnStatement returnStatement : returnStatements) { - final PsiExpression returnValue = returnStatement.getReturnValue(); - if (returnValue instanceof PsiFunctionalExpression) { - if (!consumer.process((PsiFunctionalExpression)returnValue)) return false; } } } + + return true; } - } + }); + if (!accepted) return false; + } return true; } diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodDeepestSuperSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodDeepestSuperSearcher.java index ece2108b072c..933998344add 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodDeepestSuperSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodDeepestSuperSearcher.java @@ -1,5 +1,22 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.psi.impl.search; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiMethod; import com.intellij.util.Processor; import com.intellij.util.QueryExecutor; @@ -23,12 +40,17 @@ public class MethodDeepestSuperSearcher implements QueryExecutor<PsiMethod, PsiM return findDeepestSuperOrSelfSignature(method, methods, null, consumer); } - private static boolean findDeepestSuperOrSelfSignature(PsiMethod method, + private static boolean findDeepestSuperOrSelfSignature(final PsiMethod method, Set<PsiMethod> set, Set<PsiMethod> guard, Processor<PsiMethod> processor) { if (guard != null && !guard.add(method)) return true; - PsiMethod[] supers = method.findSuperMethods(); + PsiMethod[] supers = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod[]>() { + @Override + public PsiMethod[] compute() { + return method.findSuperMethods(); + } + }); if (supers.length == 0 && set.add(method) && !processor.process(method)) { return false; diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodSuperSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodSuperSearcher.java index d65e80e7f997..acb5faae4947 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodSuperSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/MethodSuperSearcher.java @@ -1,6 +1,23 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.psi.impl.search; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.Computable; import com.intellij.psi.*; import com.intellij.psi.search.searches.SuperMethodsSearch; import com.intellij.psi.util.InheritanceUtil; @@ -22,18 +39,23 @@ public class MethodSuperSearcher implements QueryExecutor<MethodSignatureBackedB public boolean execute(@NotNull final SuperMethodsSearch.SearchParameters queryParameters, @NotNull final Processor<MethodSignatureBackedByPsiMethod> consumer) { final PsiClass parentClass = queryParameters.getPsiClass(); final PsiMethod method = queryParameters.getMethod(); - HierarchicalMethodSignature signature = method.getHierarchicalMethodSignature(); + return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + HierarchicalMethodSignature signature = method.getHierarchicalMethodSignature(); - final boolean checkBases = queryParameters.isCheckBases(); - final boolean allowStaticMethod = queryParameters.isAllowStaticMethod(); - final List<HierarchicalMethodSignature> supers = signature.getSuperSignatures(); - for (HierarchicalMethodSignature superSignature : supers) { - if (MethodSignatureUtil.isSubsignature(superSignature, signature)) { - if (!addSuperMethods(superSignature, method, parentClass, allowStaticMethod, checkBases, consumer)) return false; - } - } + final boolean checkBases = queryParameters.isCheckBases(); + final boolean allowStaticMethod = queryParameters.isAllowStaticMethod(); + final List<HierarchicalMethodSignature> supers = signature.getSuperSignatures(); + for (HierarchicalMethodSignature superSignature : supers) { + if (MethodSignatureUtil.isSubsignature(superSignature, signature)) { + if (!addSuperMethods(superSignature, method, parentClass, allowStaticMethod, checkBases, consumer)) return false; + } + } - return true; + return true; + } + }); } private static boolean addSuperMethods(final HierarchicalMethodSignature signature, diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/PsiAnnotationMethodReferencesSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/PsiAnnotationMethodReferencesSearcher.java index 50f10caef9cb..b5a6fc58d425 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/PsiAnnotationMethodReferencesSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/PsiAnnotationMethodReferencesSearcher.java @@ -1,5 +1,22 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.psi.impl.search; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.util.Computable; import com.intellij.psi.*; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiUtil; @@ -16,10 +33,24 @@ public class PsiAnnotationMethodReferencesSearcher implements QueryExecutor<PsiR @Override public boolean execute(@NotNull final ReferencesSearch.SearchParameters p, @NotNull final Processor<PsiReference> consumer) { final PsiElement refElement = p.getElementToSearch(); - if (PsiUtil.isAnnotationMethod(refElement)) { - PsiMethod method = (PsiMethod)refElement; - if (PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(method.getName()) && method.getParameterList().getParametersCount() == 0) { - final Query<PsiReference> query = ReferencesSearch.search(method.getContainingClass(), p.getScope(), p.isIgnoreAccessScope()); + boolean isAnnotation = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() { + @Override + public Boolean compute() { + return PsiUtil.isAnnotationMethod(refElement); + } + }); + if (isAnnotation) { + final PsiMethod method = (PsiMethod)refElement; + PsiClass containingClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() { + @Override + public PsiClass compute() { + boolean isValueMethod = + PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(method.getName()) && method.getParameterList().getParametersCount() == 0; + return isValueMethod ? method.getContainingClass() : null; + } + }); + if (containingClass != null) { + final Query<PsiReference> query = ReferencesSearch.search(containingClass, p.getScope(), p.isIgnoreAccessScope()); return query.forEach(createImplicitDefaultAnnotationMethodConsumer(consumer)); } } diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/SimpleAccessorReferenceSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/SimpleAccessorReferenceSearcher.java index 16870688e738..e047db8b992a 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/SimpleAccessorReferenceSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/SimpleAccessorReferenceSearcher.java @@ -54,7 +54,6 @@ public class SimpleAccessorReferenceSearcher extends QueryExecutorBase<PsiRefere for (CustomPropertyScopeProvider provider : Extensions.getExtensions(CustomPropertyScopeProvider.EP_NAME)) { additional = additional.union(provider.getScope(method.getProject())); } - assert propertyName != null; final SearchScope propScope = scope.intersectWith(method.getUseScope()).intersectWith(additional); collector.searchWord(propertyName, propScope, UsageSearchContext.IN_FOREIGN_LANGUAGES, true, method); } diff --git a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java index 78f29c4c8488..4e47c4466813 100644 --- a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java +++ b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java @@ -21,6 +21,7 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.util.ArrayUtil; import gnu.trove.THashSet; +import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -328,6 +329,7 @@ public class AnnotationUtil { * @param annotations annotations qualified names or patterns. Patterns can have '*' at the end * @return <code>true</code> if annotated of at least one annotation from the annotations list */ + @Contract("null,_ -> false") public static boolean checkAnnotatedUsingPatterns(@Nullable PsiModifierListOwner owner, @NotNull Collection<String> annotations) { final PsiModifierList modList; if (owner == null || (modList = owner.getModifierList()) == null) return false; diff --git a/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java b/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java index 52888f123215..c835a4171f74 100644 --- a/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java @@ -153,7 +153,7 @@ public class GenericsUtil { PsiType type2, Set<Couple<PsiType>> compared, PsiManager manager, - PsiClass nestedLayer, + PsiClass nestedLayer, PsiTypeParameter parameter) { Couple<PsiType> types = Couple.of(type1, type2); if (compared.contains(types)) { @@ -549,6 +549,14 @@ public class GenericsUtil { return false; } } + + final PsiClass extendsBoundClass = PsiUtil.resolveClassInClassTypeOnly(extendsBound); + final PsiClass boundBoundClass = PsiUtil.resolveClassInClassTypeOnly(boundBound); + if (boundBoundClass != null && extendsBoundClass != null && !boundBoundClass.isInterface() && !extendsBoundClass.isInterface()) { + return !InheritanceUtil.isInheritorOrSelf(boundBoundClass, extendsBoundClass, true) && + !InheritanceUtil.isInheritorOrSelf(extendsBoundClass, boundBoundClass, true); + } + return !TypeConversionUtil.areTypesConvertible(boundBound, extendsBound) && !TypeConversionUtil.areTypesConvertible(extendsBound, boundBound); } diff --git a/java/java-psi-api/src/com/intellij/psi/JVMElementFactory.java b/java/java-psi-api/src/com/intellij/psi/JVMElementFactory.java index 1b4be9766b6f..e6c38aa5a186 100644 --- a/java/java-psi-api/src/com/intellij/psi/JVMElementFactory.java +++ b/java/java-psi-api/src/com/intellij/psi/JVMElementFactory.java @@ -307,3 +307,4 @@ public interface JVMElementFactory { */ boolean isValidLocalVariableName(@NotNull String name); } + diff --git a/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java b/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java index 8130b864ad9a..c94709ee164a 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java @@ -28,6 +28,8 @@ public class PsiCapturedWildcardType extends PsiType.Stub { @NotNull private final PsiElement myContext; @Nullable private final PsiTypeParameter myParameter; + private PsiType myUpperBound; + @NotNull public static PsiCapturedWildcardType create(@NotNull PsiWildcardType existential, @NotNull PsiElement context) { return create(existential, context, null); @@ -40,11 +42,28 @@ public class PsiCapturedWildcardType extends PsiType.Stub { return new PsiCapturedWildcardType(existential, context, parameter); } - private PsiCapturedWildcardType(@NotNull PsiWildcardType existential, @NotNull PsiElement context, @Nullable PsiTypeParameter parameter) { + private PsiCapturedWildcardType(@NotNull PsiWildcardType existential, + @NotNull PsiElement context, + @Nullable PsiTypeParameter parameter) { super(PsiAnnotation.EMPTY_ARRAY); myExistential = existential; myContext = context; myParameter = parameter; + if (parameter != null) { + final PsiClassType[] boundTypes = parameter.getExtendsListTypes(); + if (boundTypes.length > 0) { + PsiType result = null; + for (PsiType type : boundTypes) { + if (result == null) { + result = type; + } + else { + result = GenericsUtil.getGreatestLowerBound(result, type); + } + } + myUpperBound = result; + } + } } @Override @@ -128,10 +147,14 @@ public class PsiCapturedWildcardType extends PsiType.Stub { return PsiWildcardType.createSuper(myContext.getManager(), ((PsiCapturedWildcardType)bound).getUpperBound()); } else { - return PsiType.getJavaLangObject(myContext.getManager(), getResolveScope()); + return myUpperBound != null ? myUpperBound : PsiType.getJavaLangObject(myContext.getManager(), getResolveScope()); } } + public void setUpperBound(PsiType upperBound) { + myUpperBound = upperBound; + } + @NotNull public PsiWildcardType getWildcard() { return myExistential; @@ -141,4 +164,8 @@ public class PsiCapturedWildcardType extends PsiType.Stub { public PsiElement getContext() { return myContext; } + + public PsiTypeParameter getTypeParameter() { + return myParameter; + } } diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java index 0b0e09684128..9729425dee81 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java @@ -323,7 +323,9 @@ public class PsiMethodReferenceUtil { final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(resolveResult); final MethodSignature signature = interfaceMethod != null ? interfaceMethod.getSignature(LambdaUtil.getSubstitutor(interfaceMethod, resolveResult)) : null; - LOG.assertTrue(signature != null); + if (signature == null) { + return false; + } final PsiType[] parameterTypes = signature.getParameterTypes(); final QualifierResolveResult qualifierResolveResult = getQualifierResolveResult(methodRef); return (method.getParameterList().getParametersCount() + 1 == parameterTypes.length || diff --git a/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java b/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java index 747f4f8034c3..888f1c24bf11 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java @@ -31,8 +31,6 @@ import static com.intellij.util.ObjectUtils.notNull; /** * Service for validating and parsing Java identifiers. - * - * @see com.intellij.psi.JavaPsiFacade#getNameHelper() */ public abstract class PsiNameHelper { diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java index a69e11a9d3cc..b38bb494c1e7 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java @@ -722,7 +722,7 @@ public final class PsiUtil extends PsiUtilCore { } public static void checkIsIdentifier(@NotNull PsiManager manager, String text) throws IncorrectOperationException{ - if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(text)){ + if (!PsiNameHelper.getInstance(manager.getProject()).isIdentifier(text)){ throw new IncorrectOperationException(PsiBundle.message("0.is.not.an.identifier", text) ); } } diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java index 42f1494bad2e..d7a60cc4cb88 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java @@ -862,6 +862,14 @@ public class TypeConversionUtil { if (left instanceof PsiPrimitiveType && !PsiType.NULL.equals(left)) { return right instanceof PsiClassType && isAssignable(left, right); } + + if (left instanceof PsiIntersectionType) { + for (PsiType lConjunct : ((PsiIntersectionType)left).getConjuncts()) { + if (!boxingConversionApplicable(lConjunct, right)) return false; + } + return true; + } + return left instanceof PsiClassType && right instanceof PsiPrimitiveType && !PsiType.NULL.equals(right) diff --git a/java/java-psi-impl/src/com/intellij/codeInsight/BaseExternalAnnotationsManager.java b/java/java-psi-impl/src/com/intellij/codeInsight/BaseExternalAnnotationsManager.java index 05b516e47ee5..966504719826 100644 --- a/java/java-psi-impl/src/com/intellij/codeInsight/BaseExternalAnnotationsManager.java +++ b/java/java-psi-impl/src/com/intellij/codeInsight/BaseExternalAnnotationsManager.java @@ -49,21 +49,20 @@ import java.util.concurrent.ConcurrentMap; public abstract class BaseExternalAnnotationsManager extends ExternalAnnotationsManager { private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.BaseExternalAnnotationsManager"); + @SuppressWarnings("MismatchedQueryAndUpdateOfCollection") @NotNull private static final List<PsiFile> NULL_LIST = new ArrayList<PsiFile>(0); @NotNull private final ConcurrentMap<VirtualFile, List<PsiFile>> myExternalAnnotations = new ConcurrentSoftValueHashMap<VirtualFile, List<PsiFile>>(10, 0.75f, 2); protected final PsiManager myPsiManager; - @SuppressWarnings("UnusedDeclaration") - private final LowMemoryWatcher myLowMemoryWatcher = LowMemoryWatcher.register(new Runnable() { - @Override - public void run() { - dropCache(); - } - }); - public BaseExternalAnnotationsManager(final PsiManager psiManager) { myPsiManager = psiManager; + LowMemoryWatcher.register(new Runnable() { + @Override + public void run() { + dropCache(); + } + }, psiManager.getProject()); } @Nullable diff --git a/java/java-psi-impl/src/com/intellij/codeInsight/folding/impl/JavaFoldingBuilderBase.java b/java/java-psi-impl/src/com/intellij/codeInsight/folding/impl/JavaFoldingBuilderBase.java index e2de5a55e0b3..f4154bc4fe1a 100644 --- a/java/java-psi-impl/src/com/intellij/codeInsight/folding/impl/JavaFoldingBuilderBase.java +++ b/java/java-psi-impl/src/com/intellij/codeInsight/folding/impl/JavaFoldingBuilderBase.java @@ -843,8 +843,8 @@ public abstract class JavaFoldingBuilderBase extends CustomFoldingBuilder implem FoldingGroup group = FoldingGroup.newGroup("lambda"); final String prettySpace = oneLine ? " " : ""; foldElements.add(new NamedFoldingDescriptor(expression, closureStart, rangeStart, group, lambdas + prettySpace)); - if (rbrace != null && rangeEnd + 1 < closureEnd) { - foldElements.add(new NamedFoldingDescriptor(rbrace, rangeEnd, closureEnd, group, prettySpace + "}")); + if (classRBrace != null && rangeEnd + 1 < closureEnd) { + foldElements.add(new NamedFoldingDescriptor(classRBrace, rangeEnd, closureEnd, group, prettySpace + "}")); } addCodeBlockFolds(body, foldElements, processedComments, document, quick); diff --git a/java/java-psi-impl/src/com/intellij/codeInsight/javadoc/JavaDocInfoGenerator.java b/java/java-psi-impl/src/com/intellij/codeInsight/javadoc/JavaDocInfoGenerator.java index f2b9583c49b0..1f642b18d1b1 100644 --- a/java/java-psi-impl/src/com/intellij/codeInsight/javadoc/JavaDocInfoGenerator.java +++ b/java/java-psi-impl/src/com/intellij/codeInsight/javadoc/JavaDocInfoGenerator.java @@ -45,6 +45,7 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.ArrayUtilRt; import com.intellij.util.Function; import com.intellij.util.IncorrectOperationException; +import com.intellij.util.containers.ContainerUtil; import com.intellij.xml.util.XmlStringUtil; import org.jdom.Document; import org.jdom.Element; @@ -720,14 +721,21 @@ public class JavaDocInfoGenerator { boolean generateLink, boolean splitAnnotations) { PsiManager manager = owner.getManager(); + Set<String> shownAnnotations = ContainerUtil.newHashSet(); + for (PsiAnnotation annotation : annotations) { final PsiJavaCodeReferenceElement nameReferenceElement = annotation.getNameReferenceElement(); if (nameReferenceElement == null) continue; final PsiElement resolved = nameReferenceElement.resolve(); boolean inferred = AnnotationUtil.isInferredAnnotation(annotation); + + if (!(shownAnnotations.add(annotation.getQualifiedName()) || isRepeatableAnnotationType(resolved))) { + continue; + } + if (resolved instanceof PsiClass) { final PsiClass annotationType = (PsiClass)resolved; - if (AnnotationUtil.isAnnotated(annotationType, "java.lang.annotation.Documented", false)) { + if (isDocumentedAnnotationType(annotationType)) { if (inferred) buffer.append("<i>"); final PsiClassType type = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(annotationType, PsiSubstitutor.EMPTY); buffer.append("@"); @@ -770,6 +778,14 @@ public class JavaDocInfoGenerator { } } + public static boolean isDocumentedAnnotationType(@Nullable PsiElement annotationType) { + return annotationType instanceof PsiClass && AnnotationUtil.isAnnotated((PsiClass)annotationType, "java.lang.annotation.Documented", false); + } + + public static boolean isRepeatableAnnotationType(@Nullable PsiElement annotationType) { + return annotationType instanceof PsiClass && AnnotationUtil.isAnnotated((PsiClass)annotationType, CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE, false, true); + } + private void generateMethodParameterJavaDoc(@NonNls StringBuilder buffer, PsiParameter parameter, boolean generatePrologueAndEpilogue) { if (generatePrologueAndEpilogue) generatePrologue(buffer); diff --git a/java/java-psi-impl/src/com/intellij/lang/java/parser/ReferenceParser.java b/java/java-psi-impl/src/com/intellij/lang/java/parser/ReferenceParser.java index e18b1b5b5dab..c6c8e71fbca1 100644 --- a/java/java-psi-impl/src/com/intellij/lang/java/parser/ReferenceParser.java +++ b/java/java-psi-impl/src/com/intellij/lang/java/parser/ReferenceParser.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -66,7 +66,7 @@ public class ReferenceParser { final TypeInfo typeInfo = parseTypeInfo(builder, flags, false); if (typeInfo != null) { - assert notSet(flags, DISJUNCTIONS|CONJUNCTIONS) : "don't not set both flags simultaneously"; + assert notSet(flags, DISJUNCTIONS|CONJUNCTIONS) : "don't set both flags simultaneously"; final IElementType operator = isSet(flags, DISJUNCTIONS) ? JavaTokenType.OR : isSet(flags, CONJUNCTIONS) ? JavaTokenType.AND : null; if (operator != null && builder.getTokenType() == operator) { diff --git a/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowAnalyzer.java b/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowAnalyzer.java index da32b64ea092..b8f810611201 100644 --- a/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowAnalyzer.java +++ b/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowAnalyzer.java @@ -204,7 +204,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor { ProgressIndicatorProvider.checkCanceled(); ControlFlowSubRange subRange = entry.getValue(); PsiElement element = entry.getKey(); - myControlFlowFactory.registerSubRange(element, subRange, myEvaluateConstantIfCondition, myPolicy); + myControlFlowFactory.registerSubRange(element, subRange, myEvaluateConstantIfCondition, myEnabledShortCircuit, myPolicy); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowFactory.java b/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowFactory.java index 2ba1906c422c..3159193bce4f 100644 --- a/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowFactory.java +++ b/java/java-psi-impl/src/com/intellij/psi/controlFlow/ControlFlowFactory.java @@ -62,19 +62,29 @@ public class ControlFlowFactory { cachedFlows.clear(); } + @Deprecated public void registerSubRange(final PsiElement codeFragment, final ControlFlowSubRange flow, final boolean evaluateConstantIfConfition, final ControlFlowPolicy policy) { - registerControlFlow(codeFragment, flow, evaluateConstantIfConfition, policy); + registerSubRange(codeFragment, flow, evaluateConstantIfConfition, true, policy); + } + + public void registerSubRange(final PsiElement codeFragment, + final ControlFlowSubRange flow, + final boolean evaluateConstantIfConfition, + boolean enableShortCircuit, final ControlFlowPolicy policy) { + registerControlFlow(codeFragment, flow, evaluateConstantIfConfition, enableShortCircuit, policy); } private static class ControlFlowContext { private final ControlFlowPolicy policy; private final boolean evaluateConstantIfCondition; + private final boolean enableShortCircuit; private final long modificationCount; private final ControlFlow controlFlow; - private ControlFlowContext(boolean evaluateConstantIfCondition, @NotNull ControlFlowPolicy policy, long modificationCount, @NotNull ControlFlow controlFlow) { + private ControlFlowContext(boolean evaluateConstantIfCondition, boolean enableShortCircuit, @NotNull ControlFlowPolicy policy, long modificationCount, @NotNull ControlFlow controlFlow) { this.evaluateConstantIfCondition = evaluateConstantIfCondition; + this.enableShortCircuit = enableShortCircuit; this.policy = policy; this.modificationCount = modificationCount; this.controlFlow = controlFlow; @@ -96,9 +106,10 @@ public class ControlFlowFactory { return result; } - public boolean isFor(@NotNull ControlFlowPolicy policy, final boolean evaluateConstantIfCondition, long modificationCount) { + public boolean isFor(@NotNull ControlFlowPolicy policy, final boolean evaluateConstantIfCondition, final boolean enableShortCircuit, long modificationCount) { if (modificationCount != this.modificationCount) return false; if (!policy.equals(this.policy)) return false; + if (enableShortCircuit != this.enableShortCircuit) return false; // optimization: when no constant condition were computed, both control flows are the same if (!controlFlow.isConstantConditionOccurred()) return true; @@ -107,7 +118,7 @@ public class ControlFlowFactory { } private boolean isFor(@NotNull ControlFlowContext that) { - return isFor(that.policy, that.evaluateConstantIfCondition, that.modificationCount); + return isFor(that.policy, that.evaluateConstantIfCondition, that.enableShortCircuit, that.modificationCount); } } @@ -129,28 +140,30 @@ public class ControlFlowFactory { final long modificationCount = element.getManager().getModificationTracker().getModificationCount(); ConcurrentList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element); for (ControlFlowContext context : cached) { - if (context.isFor(policy, evaluateConstantIfCondition,modificationCount)) return context.controlFlow; + if (context.isFor(policy, evaluateConstantIfCondition, enableShortCircuit, modificationCount)) return context.controlFlow; } ControlFlow controlFlow = new ControlFlowAnalyzer(element, policy, enableShortCircuit, evaluateConstantIfCondition).buildControlFlow(); - ControlFlowContext context = createContext(evaluateConstantIfCondition, policy, controlFlow, modificationCount); + ControlFlowContext context = createContext(evaluateConstantIfCondition, enableShortCircuit, policy, controlFlow, modificationCount); cached.addIfAbsent(context); return controlFlow; } @NotNull private static ControlFlowContext createContext(final boolean evaluateConstantIfCondition, + boolean enableShortCircuit, @NotNull ControlFlowPolicy policy, @NotNull ControlFlow controlFlow, final long modificationCount) { - return new ControlFlowContext(evaluateConstantIfCondition, policy, modificationCount,controlFlow); + return new ControlFlowContext(evaluateConstantIfCondition, enableShortCircuit, policy, modificationCount,controlFlow); } private void registerControlFlow(@NotNull PsiElement element, @NotNull ControlFlow flow, boolean evaluateConstantIfCondition, + boolean enableShortCircuit, @NotNull ControlFlowPolicy policy) { final long modificationCount = element.getManager().getModificationTracker().getModificationCount(); - ControlFlowContext controlFlowContext = createContext(evaluateConstantIfCondition, policy, flow, modificationCount); + ControlFlowContext controlFlowContext = createContext(evaluateConstantIfCondition, enableShortCircuit, policy, flow, modificationCount); ConcurrentList<ControlFlowContext> cached = getOrCreateCachedFlowsForElement(element); cached.addIfAbsent(controlFlowContext); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java index 7c597e495f2e..9c9525aef859 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java @@ -80,14 +80,14 @@ public class PsiSubstitutorImpl implements PsiSubstitutor { } private boolean containsInMap(PsiTypeParameter typeParameter) { - if (typeParameter instanceof LightTypeParameter) { + if (typeParameter instanceof LightTypeParameter && ((LightTypeParameter)typeParameter).useDelegateToSubstitute()) { typeParameter = ((LightTypeParameter)typeParameter).getDelegate(); } return mySubstitutionMap.containsKey(typeParameter); } private PsiType getFromMap(@NotNull PsiTypeParameter typeParameter) { - if (typeParameter instanceof LightTypeParameter) { + if (typeParameter instanceof LightTypeParameter && ((LightTypeParameter)typeParameter).useDelegateToSubstitute()) { typeParameter = ((LightTypeParameter)typeParameter).getDelegate(); } return mySubstitutionMap.get(typeParameter); @@ -394,7 +394,7 @@ public class PsiSubstitutorImpl implements PsiSubstitutor { } } } - } else if (substituted instanceof PsiWildcardType && ((PsiWildcardType)substituted).isSuper()) { + } else if (substituted instanceof PsiWildcardType && ((PsiWildcardType)substituted).isSuper() && !(oldSubstituted instanceof PsiCapturedWildcardType)) { final PsiType erasure = TypeConversionUtil.erasure(((PsiWildcardType)substituted).getBound()); if (erasure != null) { final PsiType[] boundTypes = typeParameter.getExtendsListTypes(); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java index c188c3a38013..9129052bf74f 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java @@ -263,7 +263,6 @@ public class PsiPackageImpl extends PsiPackageBase implements PsiPackage, Querya processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this); ElementClassHint classHint = processor.getHint(ElementClassHint.KEY); - final JavaPsiFacade facade = getFacade(); final Condition<String> nameCondition = processor.getHint(JavaCompletionHints.NAME_FILTER); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) { @@ -291,7 +290,7 @@ public class PsiPackageImpl extends PsiPackageBase implements PsiPackage, Querya for (PsiPackage pack : packs) { final String packageName = pack.getName(); if (packageName == null) continue; - if (!facade.getNameHelper().isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) { + if (!PsiNameHelper.getInstance(myManager.getProject()).isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) { continue; } if (!processor.execute(pack, state)) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightTypeParameter.java b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightTypeParameter.java index 6775a64c59ef..3cd347648a07 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/light/LightTypeParameter.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/light/LightTypeParameter.java @@ -79,6 +79,10 @@ public class LightTypeParameter extends LightClass implements PsiTypeParameter { return getDelegate().addAnnotation(qualifiedName); } + public boolean useDelegateToSubstitute() { + return true; + } + @Override public String toString() { return "PsiTypeParameter:" + getName(); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/FunctionalInterfaceParameterizationUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/FunctionalInterfaceParameterizationUtil.java index b4b188c772cc..9742e0f28608 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/FunctionalInterfaceParameterizationUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/FunctionalInterfaceParameterizationUtil.java @@ -36,7 +36,7 @@ public class FunctionalInterfaceParameterizationUtil { } if (classType instanceof PsiClassType) { for (PsiType type : ((PsiClassType)classType).getParameters()) { - if (type instanceof PsiWildcardType || type instanceof PsiCapturedWildcardType) { + if (type instanceof PsiWildcardType) { return true; } } @@ -94,7 +94,8 @@ public class FunctionalInterfaceParameterizationUtil { final InferenceSession session = new InferenceSession(typeParameters, PsiSubstitutor.EMPTY, expr.getManager(), expr); for (int i = 0; i < targetMethodParams.length; i++) { - session.addConstraint(new TypeEqualityConstraint(lambdaParams[i].getType(), targetMethodParams[i].getType())); + session.addConstraint(new TypeEqualityConstraint(lambdaParams[i].getType(), + session.substituteWithInferenceVariables(targetMethodParams[i].getType()))); } if (!session.repeatInferencePhases(false)) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceIncorporationPhase.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceIncorporationPhase.java index 9766122e31d0..9c8b8b4772b3 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceIncorporationPhase.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceIncorporationPhase.java @@ -89,28 +89,6 @@ public class InferenceIncorporationPhase { upDown(lowerBounds, eqBounds, substitutor); upUp(upperBounds); - - for (PsiType eqBound : eqBounds) { - if (mySession.isProperType(eqBound)) { - for (PsiType upperBound : upperBounds) { - if (!mySession.isProperType(upperBound)) { - addConstraint(new StrictSubtypingConstraint(substitutor.substitute(upperBound), eqBound)); - } - } - - for (PsiType lowerBound : lowerBounds) { - if (!mySession.isProperType(lowerBound)) { - addConstraint(new StrictSubtypingConstraint(eqBound, substitutor.substitute(lowerBound))); - } - } - - for (PsiType otherEqBound : eqBounds) { - if (eqBound != otherEqBound && !mySession.isProperType(otherEqBound)) { - addConstraint(new TypeEqualityConstraint(substitutor.substitute(otherEqBound), eqBound)); - } - } - } - } } for (Pair<PsiTypeParameter[], PsiClassType> capture : myCaptures) { @@ -135,7 +113,7 @@ public class InferenceIncorporationPhase { if (aType instanceof PsiWildcardType) { for (PsiType eqBound : eqBounds) { - if (mySession.isProperType(eqBound)) return false; + if (mySession.getInferenceVariable(eqBound) == null) return false; } final PsiClassType[] paramBounds = parameters[i].getExtendsListTypes(); @@ -143,15 +121,15 @@ public class InferenceIncorporationPhase { if (!((PsiWildcardType)aType).isBounded()) { for (PsiType upperBound : upperBounds) { - if (mySession.isProperType(upperBound)) { + if (mySession.getInferenceVariable(upperBound) == null) { for (PsiClassType paramBound : paramBounds) { - addConstraint(new StrictSubtypingConstraint(upperBound, paramBound)); + addConstraint(new StrictSubtypingConstraint(upperBound, mySession.substituteWithInferenceVariables(paramBound))); } } } for (PsiType lowerBound : lowerBounds) { - if (mySession.isProperType(lowerBound)) return false; + if (mySession.getInferenceVariable(lowerBound) == null) return false; } } else if (((PsiWildcardType)aType).isExtends()) { @@ -159,19 +137,19 @@ public class InferenceIncorporationPhase { final PsiType extendsBound = ((PsiWildcardType)aType).getExtendsBound(); for (PsiType upperBound : upperBounds) { - if (mySession.isProperType(upperBound)) { + if (mySession.getInferenceVariable(upperBound) == null) { if (paramBounds.length == 1 && paramBounds[0].equalsToText(CommonClassNames.JAVA_LANG_OBJECT) || paramBounds.length == 0) { addConstraint(new StrictSubtypingConstraint(upperBound, extendsBound)); } else if (extendsBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { for (PsiClassType paramBound : paramBounds) { - addConstraint(new StrictSubtypingConstraint(upperBound, paramBound)); + addConstraint(new StrictSubtypingConstraint(upperBound, mySession.substituteWithInferenceVariables(paramBound))); } } } } for (PsiType lowerBound : lowerBounds) { - if (mySession.isProperType(lowerBound)) return false; + if (mySession.getInferenceVariable(lowerBound) == null) return false; } } else { @@ -179,15 +157,15 @@ public class InferenceIncorporationPhase { final PsiType superBound = ((PsiWildcardType)aType).getSuperBound(); for (PsiType upperBound : upperBounds) { - if (mySession.isProperType(upperBound)) { + if (mySession.getInferenceVariable(upperBound) == null) { for (PsiClassType paramBound : paramBounds) { - addConstraint(new StrictSubtypingConstraint(paramBound, upperBound)); + addConstraint(new StrictSubtypingConstraint(mySession.substituteWithInferenceVariables(paramBound), upperBound)); } } } for (PsiType lowerBound : lowerBounds) { - if (mySession.isProperType(lowerBound)) { + if (mySession.getInferenceVariable(lowerBound) == null) { addConstraint(new StrictSubtypingConstraint(lowerBound, superBound)); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java index 27e34f00a25f..35db6c29bc0c 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java @@ -15,10 +15,12 @@ */ package com.intellij.psi.impl.source.resolve.graphInference; +import com.intellij.ide.highlighter.JavaFileType; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.Pair; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.impl.PsiImplUtil; import com.intellij.psi.impl.source.resolve.graphInference.constraints.*; @@ -42,8 +44,14 @@ public class InferenceSession { public static final Key<PsiType> LOWER_BOUND = Key.create("LowBound"); private static final Key<Boolean> ERASED = Key.create("UNCHECKED_CONVERSION"); + private static final Function<Pair<PsiType, PsiType>, PsiType> UPPER_BOUND_FUNCTION = new Function<Pair<PsiType, PsiType>, PsiType>() { + @Override + public PsiType fun(Pair<PsiType, PsiType> pair) { + return GenericsUtil.getGreatestLowerBound(pair.first, pair.second); + } + }; - private final Map<PsiTypeParameter, InferenceVariable> myInferenceVariables = new LinkedHashMap<PsiTypeParameter, InferenceVariable>(); + private final Set<InferenceVariable> myInferenceVariables = new LinkedHashSet<InferenceVariable>(); private final List<ConstraintFormula> myConstraints = new ArrayList<ConstraintFormula>(); private final Set<ConstraintFormula> myConstraintsCopy = new HashSet<ConstraintFormula>(); @@ -56,8 +64,14 @@ public class InferenceSession { private final InferenceIncorporationPhase myIncorporationPhase = new InferenceIncorporationPhase(this); private final PsiElement myContext; - - private final PsiTypeParameter[] myParamsToInfer; + + private PsiSubstitutor myInferenceSubstitution = PsiSubstitutor.EMPTY; + private Map<PsiElement, InferenceSession> myNestedSessions = new HashMap<PsiElement, InferenceSession>(); + public void registerNestedSession(InferenceSession session) { + propagateVariables(session.getInferenceVariables()); + myNestedSessions.put(session.getContext(), session); + myNestedSessions.putAll(session.myNestedSessions); + } public InferenceSession(PsiTypeParameter[] typeParams, PsiType[] leftTypes, @@ -70,13 +84,12 @@ public class InferenceSession { myContext = context; initBounds(typeParams); - myParamsToInfer = typeParams; LOG.assertTrue(leftTypes.length == rightTypes.length); for (int i = 0; i < leftTypes.length; i++) { final PsiType rightType = mySiteSubstitutor.substitute(rightTypes[i]); if (rightType != null) { - addConstraint(new TypeCompatibilityConstraint(leftTypes[i], rightType)); + addConstraint(new TypeCompatibilityConstraint(substituteWithInferenceVariables(leftTypes[i]), substituteWithInferenceVariables(rightType))); } } } @@ -90,11 +103,6 @@ public class InferenceSession { myContext = context; initBounds(typeParams); - myParamsToInfer = typeParams; - } - - public PsiTypeParameter[] getParamsToInfer() { - return myParamsToInfer; } public void initExpressionConstraints(PsiParameter[] parameters, PsiExpression[] args, PsiElement parent, PsiMethod method) { @@ -117,7 +125,7 @@ public class InferenceSession { for (int i = 0; i < args.length; i++) { if (args[i] != null && isPertinentToApplicability(args[i], method)) { PsiType parameterType = getParameterType(parameters, i, mySiteSubstitutor, varargs); - addConstraint(new ExpressionCompatibilityConstraint(args[i], parameterType)); + addConstraint(new ExpressionCompatibilityConstraint(args[i], substituteWithInferenceVariables(parameterType))); } } } @@ -213,7 +221,7 @@ public class InferenceSession { final MethodCandidateInfo.CurrentCandidateProperties properties = getCurrentProperties(parent); if (!repeatInferencePhases(true)) { //inferred result would be checked as candidate won't be applicable - return resolveSubset(myInferenceVariables.values(), mySiteSubstitutor); + return resolveSubset(myInferenceVariables, mySiteSubstitutor); } if (properties != null && !properties.isApplicabilityCheck()) { @@ -235,20 +243,17 @@ public class InferenceSession { } } - final PsiSubstitutor substitutor = resolveBounds(myInferenceVariables.values(), mySiteSubstitutor); + final PsiSubstitutor substitutor = resolveBounds(myInferenceVariables, mySiteSubstitutor); if (substitutor != null) { if (myContext != null) { myContext.putUserData(ERASED, myErased); } mySiteSubstitutor = substitutor; - for (PsiTypeParameter parameter : substitutor.getSubstitutionMap().keySet()) { - final InferenceVariable variable = getInferenceVariable(parameter); - if (variable != null) { - variable.setInstantiation(substitutor.substitute(parameter)); - } + for (InferenceVariable variable : myInferenceVariables) { + variable.setInstantiation(substitutor.substitute(variable.getParameter())); } } else { - return resolveSubset(myInferenceVariables.values(), mySiteSubstitutor); + return resolveSubset(myInferenceVariables, mySiteSubstitutor); } return prepareSubstitution(); @@ -262,12 +267,16 @@ public class InferenceSession { boolean varargs, boolean toplevel) { for (int i = 0; i < args.length; i++) { if (args[i] != null) { - PsiType parameterType = getParameterType(parameters, i, siteSubstitutor, varargs); + InferenceSession session = myNestedSessions.get(PsiTreeUtil.getParentOfType(args[i], PsiCallExpression.class)); + if (session == null) { + session = this; + } + PsiType parameterType = session.substituteWithInferenceVariables(getParameterType(parameters, i, siteSubstitutor, varargs)); if (!isPertinentToApplicability(args[i], parentMethod)) { additionalConstraints.add(new ExpressionCompatibilityConstraint(args[i], parameterType)); } additionalConstraints.add(new CheckedExceptionCompatibilityConstraint(args[i], parameterType)); - if (args[i] instanceof PsiCallExpression) { + if (args[i] instanceof PsiCallExpression && PsiPolyExpressionUtil.isPolyExpression(args[i])) { //If the expression is a poly class instance creation expression (15.9) or a poly method invocation expression (15.12), //the set contains all constraint formulas that would appear in the set C when determining the poly expression's invocation type. final PsiCallExpression callExpression = (PsiCallExpression)args[i]; @@ -299,18 +308,18 @@ public class InferenceSession { return callExpression.resolveMethodGenerics(); } }; - final JavaResolveResult result = expression == null + MethodCandidateInfo.CurrentCandidateProperties properties = MethodCandidateInfo.getCurrentMethod(argumentList); + final JavaResolveResult result = properties != null ? null : + expression == null ? computableResolve.compute() : PsiResolveHelper.ourGraphGuard.doPreventingRecursion(expression, false, computableResolve); - if (result instanceof MethodCandidateInfo) { - final PsiMethod method = ((MethodCandidateInfo)result).getElement(); - //need to get type parameters for 2 level nested expressions (they won't be covered by expression constraints on this level?!) - initBounds(method.getTypeParameters()); + final PsiMethod method = result instanceof MethodCandidateInfo ? ((MethodCandidateInfo)result).getElement() : properties != null ? properties.getMethod() : null; + if (method != null) { final PsiExpression[] newArgs = argumentList.getExpressions(); final PsiParameter[] newParams = method.getParameterList().getParameters(); if (newParams.length > 0) { - collectAdditionalConstraints(newParams, newArgs, method, ((MethodCandidateInfo)result).getSiteSubstitutor(), - additionalConstraints, ((MethodCandidateInfo)result).isVarargs(), false); + collectAdditionalConstraints(newParams, newArgs, method, result != null ? ((MethodCandidateInfo)result).getSiteSubstitutor() : properties.getSubstitutor(), + additionalConstraints, result != null ? ((MethodCandidateInfo)result).isVarargs() : properties.isVarargs(), false); } } } @@ -321,14 +330,14 @@ public class InferenceSession { for (InferenceVariable variable : variables) { final PsiType equalsBound = getEqualsBound(variable, substitutor); if (!(equalsBound instanceof PsiPrimitiveType)) { - substitutor = substitutor.put(variable.getParameter(), equalsBound); + substitutor = substitutor.put(variable, equalsBound); } } return substitutor; } private PsiSubstitutor prepareSubstitution() { - for (InferenceVariable inferenceVariable : myInferenceVariables.values()) { + for (InferenceVariable inferenceVariable : myInferenceVariables) { final PsiTypeParameter typeParameter = inferenceVariable.getParameter(); PsiType instantiation = inferenceVariable.getInstantiation(); if (instantiation == PsiType.NULL) { @@ -340,33 +349,24 @@ public class InferenceSession { return mySiteSubstitutor; } - private boolean isInsideRecursiveCall(PsiTypeParameter parameter) { - final PsiTypeParameterListOwner parameterOwner = parameter.getOwner(); - if (myContext != null && PsiTreeUtil.isAncestor(parameterOwner, myContext, true)) { - final PsiModifierListOwner staticContainer = PsiUtil.getEnclosingStaticElement(myContext, null); - if (staticContainer == null || PsiTreeUtil.isAncestor(staticContainer, parameterOwner, false)) { - return true; - } - } - return false; + public void initBounds(PsiTypeParameter... typeParameters) { + initBounds(myContext, typeParameters); } - public boolean initBounds(PsiTypeParameter... typeParameters) { - return initBounds(myContext, typeParameters); - } - - public boolean initBounds(PsiElement context, PsiTypeParameter... typeParameters) { - boolean sameMethodCall = false; + public InferenceVariable[] initBounds(PsiElement context, PsiTypeParameter... typeParameters) { + List<InferenceVariable> result = new ArrayList<InferenceVariable>(typeParameters.length); for (PsiTypeParameter parameter : typeParameters) { - if (myInferenceVariables.containsKey(parameter)) { - sameMethodCall = true; - continue; - } InferenceVariable variable = new InferenceVariable(context, parameter); + result.add(variable); + myInferenceSubstitution = myInferenceSubstitution.put(parameter, + JavaPsiFacade.getElementFactory(variable.getProject()).createType(variable)); + } + for (InferenceVariable variable : result) { + PsiTypeParameter parameter = variable.getParameter(); boolean added = false; final PsiClassType[] extendsListTypes = parameter.getExtendsListTypes(); for (PsiType classType : extendsListTypes) { - classType = mySiteSubstitutor.substitute(classType); + classType = substituteWithInferenceVariables(mySiteSubstitutor.substitute(classType)); if (isProperType(classType)) { added = true; } @@ -376,9 +376,9 @@ public class InferenceSession { variable.addBound(PsiType.getJavaLangObject(parameter.getManager(), parameter.getResolveScope()), InferenceBound.UPPER); } - myInferenceVariables.put(parameter, variable); } - return sameMethodCall; + myInferenceVariables.addAll(result); + return result.toArray(new InferenceVariable[result.size()]); } private void initReturnTypeConstraint(PsiMethod method, final PsiCallExpression context) { @@ -393,7 +393,7 @@ public class InferenceSession { } for (PsiClassType thrownType : method.getThrowsList().getReferencedTypes()) { - final InferenceVariable variable = getInferenceVariable(thrownType); + final InferenceVariable variable = getInferenceVariable(substituteWithInferenceVariables(thrownType)); if (variable != null) { variable.setThrownBound(); } @@ -401,6 +401,7 @@ public class InferenceSession { } public void registerReturnTypeConstraints(PsiType returnType, PsiType targetType) { + returnType = substituteWithInferenceVariables(returnType); final InferenceVariable inferenceVariable = shouldResolveAndInstantiate(returnType, targetType); if (inferenceVariable != null) { final PsiSubstitutor substitutor = resolveSubset(Collections.singletonList(inferenceVariable), mySiteSubstitutor); @@ -416,17 +417,9 @@ public class InferenceSession { if (psiClass != null) { LOG.assertTrue(returnType instanceof PsiClassType); final PsiTypeParameter[] typeParameters = psiClass.getTypeParameters(); - PsiSubstitutor subst = PsiSubstitutor.EMPTY; - final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject()); - PsiTypeParameter[] copy = new PsiTypeParameter[typeParameters.length]; - for (int i = 0; i < typeParameters.length; i++) { - PsiTypeParameter typeParameter = typeParameters[i]; - copy[i] = elementFactory.createTypeParameterFromText("rCopy" + typeParameter.getName(), null); - initBounds(myContext, copy[i]); - subst = subst.put(typeParameter, elementFactory.createType(copy[i])); - } - final PsiType substitutedCapture = PsiUtil.captureToplevelWildcards(subst.substitute(returnType), myContext); - myIncorporationPhase.addCapture(copy, (PsiClassType)returnType); + InferenceVariable[] copy = initBounds(myContext, typeParameters); + final PsiType substitutedCapture = PsiUtil.captureToplevelWildcards(returnType, myContext); + myIncorporationPhase.addCapture(copy, (PsiClassType)substituteWithInferenceVariables(returnType)); addConstraint(new TypeCompatibilityConstraint(targetType, substitutedCapture)); } } else { @@ -584,8 +577,8 @@ public class InferenceSession { public InferenceVariable getInferenceVariable(PsiType psiType) { final PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(psiType); - if (psiClass instanceof PsiTypeParameter) { - return myInferenceVariables.get(psiClass); + if (psiClass instanceof InferenceVariable) { + return (InferenceVariable)psiClass; } return null; } @@ -694,7 +687,13 @@ public class InferenceSession { while (!allVars.isEmpty()) { final List<InferenceVariable> vars = InferenceVariablesOrder.resolveOrder(allVars, this); if (!myIncorporationPhase.hasCaptureConstraints(vars)) { - final PsiSubstitutor firstSubstitutor = resolveSubset(vars, substitutor); + PsiSubstitutor firstSubstitutor = resolveSubset(vars, substitutor); + if (firstSubstitutor != null) { + final Set<PsiTypeParameter> parameters = firstSubstitutor.getSubstitutionMap().keySet(); + if (GenericsUtil.findTypeParameterWithBoundError(parameters.toArray(new PsiTypeParameter[parameters.size()]), firstSubstitutor, myContext, true) != null) { + firstSubstitutor = null; + } + } if (firstSubstitutor != null) { substitutor = firstSubstitutor; allVars.removeAll(vars); @@ -703,73 +702,102 @@ public class InferenceSession { } final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(getManager().getProject()); - for (InferenceVariable var : vars) { - final PsiTypeParameter parameter = var.getParameter(); - final PsiTypeParameter copy = elementFactory.createTypeParameterFromText("z" + parameter.getName(), null); - final PsiType lub = getLowerBound(var, substitutor); - final PsiType glb = getUpperBound(var, substitutor); - final InferenceVariable zVariable = new InferenceVariable(var.getCallContext(), copy); - zVariable.addBound(glb, InferenceBound.UPPER); + final PsiTypeParameter[] freshParameters = createFreshVariables(vars); + for (int i = 0; i < freshParameters.length; i++) { + PsiTypeParameter parameter = freshParameters[i]; + final InferenceVariable var = vars.get(i); + final PsiType lub = getLowerBound(var, PsiSubstitutor.EMPTY); if (lub != PsiType.NULL) { - if (!TypeConversionUtil.isAssignable(glb, lub)) { - return null; + for (PsiClassType upperBoundType : parameter.getExtendsListTypes()) { + if (!TypeConversionUtil.isAssignable(upperBoundType, lub)) { + return null; + } } - copy.putUserData(LOWER_BOUND, lub); - zVariable.addBound(lub, InferenceBound.LOWER); + parameter.putUserData(LOWER_BOUND, lub); } - myInferenceVariables.put(copy, zVariable); - allVars.add(zVariable); - var.addBound(elementFactory.createType(copy), InferenceBound.EQ); + var.addBound(elementFactory.createType(parameter), InferenceBound.EQ); } myIncorporationPhase.forgetCaptures(vars); - if (!myIncorporationPhase.incorporate()) { + if (!repeatInferencePhases(true)) { return null; } } return substitutor; } - private PsiType getLowerBound(InferenceVariable var, PsiSubstitutor substitutor) { - return composeBound(var, InferenceBound.LOWER, new Function<Pair<PsiType, PsiType>, PsiType>() { + private PsiTypeParameter[] createFreshVariables(final List<InferenceVariable> vars) { + final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(getManager().getProject()); + + PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; + final PsiTypeParameter[] yVars = new PsiTypeParameter[vars.size()]; + for (int i = 0; i < vars.size(); i++) { + InferenceVariable var = vars.get(i); + final PsiTypeParameter parameter = var.getParameter(); + yVars[i] = elementFactory.createTypeParameterFromText(getFreshVariableName(var), parameter); + substitutor = substitutor.put(var, elementFactory.createType(yVars[i])); + } + + + final PsiSubstitutor ySubstitutor = substitutor; + final String classText = "class I<" + StringUtil.join(vars, new Function<InferenceVariable, String>() { @Override - public PsiType fun(Pair<PsiType, PsiType> pair) { - return GenericsUtil.getLeastUpperBound(pair.first, pair.second, myManager); - } - }, substitutor); + public String fun(InferenceVariable variable) { + final PsiType glb = composeBound(variable, InferenceBound.UPPER, UPPER_BOUND_FUNCTION, ySubstitutor, true); + return getFreshVariableName(variable) + " extends " + glb.getInternalCanonicalText(); + } + }, ", ") + ">{}"; + + final PsiFile file = + PsiFileFactory.getInstance(getManager().getProject()).createFileFromText("inference_dummy.java", JavaFileType.INSTANCE, classText); + LOG.assertTrue(file instanceof PsiJavaFile, classText); + final PsiClass[] classes = ((PsiJavaFile)file).getClasses(); + LOG.assertTrue(classes.length == 1, classText); + return classes[0].getTypeParameters(); + } + + private static String getFreshVariableName(InferenceVariable var) { + return var.getName(); } private PsiSubstitutor resolveSubset(Collection<InferenceVariable> vars, PsiSubstitutor substitutor) { for (InferenceVariable var : vars) { LOG.assertTrue(var.getInstantiation() == PsiType.NULL); final PsiTypeParameter typeParameter = var.getParameter(); + if (substitutor.getSubstitutionMap().containsKey(typeParameter) && var.getCallContext() != myContext) { + continue;//todo + } + final PsiType eqBound = getEqualsBound(var, substitutor); if (eqBound != PsiType.NULL && eqBound instanceof PsiPrimitiveType) continue; - final PsiType lub = eqBound != PsiType.NULL && (myErased || eqBound != null) ? eqBound : getLowerBound(var, substitutor); - if (lub != PsiType.NULL) { - substitutor = substitutor.put(typeParameter, lub); - } - else if (var.isThrownBound() && isThrowable(var.getBounds(InferenceBound.UPPER))) { - final PsiClassType runtimeException = PsiType.getJavaLangRuntimeException(myManager, GlobalSearchScope.allScope(myManager.getProject())); - substitutor = substitutor.put(typeParameter, runtimeException); - } - else { - if (substitutor.getSubstitutionMap().get(typeParameter) != null) continue; - substitutor = substitutor.put(typeParameter, myErased ? null : getUpperBound(var, substitutor)); + PsiType type = eqBound != PsiType.NULL && (myErased || eqBound != null) ? eqBound : getLowerBound(var, substitutor); + if (type == PsiType.NULL) { + if (var.isThrownBound() && isThrowable(var.getBounds(InferenceBound.UPPER))) { + type = PsiType.getJavaLangRuntimeException(myManager, GlobalSearchScope.allScope(myManager.getProject())); + } + else { + if (substitutor.getSubstitutionMap().get(typeParameter) != null) continue; + type = myErased ? null : getUpperBound(var, substitutor); + } } + substitutor = substitutor.put(typeParameter, type); } return substitutor; } - private PsiType getUpperBound(InferenceVariable var, PsiSubstitutor substitutor) { - return composeBound(var, InferenceBound.UPPER, new Function<Pair<PsiType, PsiType>, PsiType>() { + private PsiType getLowerBound(InferenceVariable var, PsiSubstitutor substitutor) { + return composeBound(var, InferenceBound.LOWER, new Function<Pair<PsiType, PsiType>, PsiType>() { @Override public PsiType fun(Pair<PsiType, PsiType> pair) { - return GenericsUtil.getGreatestLowerBound(pair.first, pair.second); + return GenericsUtil.getLeastUpperBound(pair.first, pair.second, myManager); } }, substitutor); } + private PsiType getUpperBound(InferenceVariable var, PsiSubstitutor substitutor) { + return composeBound(var, InferenceBound.UPPER, UPPER_BOUND_FUNCTION, substitutor); + } + public PsiType getEqualsBound(InferenceVariable var, PsiSubstitutor substitutor) { return composeBound(var, InferenceBound.EQ, new Function<Pair<PsiType, PsiType>, PsiType>() { @Override @@ -783,16 +811,19 @@ public class InferenceSession { InferenceBound boundType, Function<Pair<PsiType, PsiType>, PsiType> fun, PsiSubstitutor substitutor) { + return composeBound(variable, boundType, fun, substitutor, false); + } + + private PsiType composeBound(InferenceVariable variable, + InferenceBound boundType, + Function<Pair<PsiType, PsiType>, PsiType> fun, + PsiSubstitutor substitutor, + boolean includeNonProperBounds) { final List<PsiType> lowerBounds = variable.getBounds(boundType); PsiType lub = PsiType.NULL; - List<PsiType> dTypes = new ArrayList<PsiType>(); for (PsiType lowerBound : lowerBounds) { lowerBound = substituteNonProperBound(lowerBound, substitutor); - final HashSet<InferenceVariable> dependencies = new HashSet<InferenceVariable>(); - collectDependencies(lowerBound, dependencies); - if (dependencies.size() == 1 && dependencies.contains(variable) && isInsideRecursiveCall(dependencies)) { - lub = JavaPsiFacade.getElementFactory(myManager.getProject()).createType(variable.getParameter()); - } else if (dependencies.isEmpty() || isInsideRecursiveCall(dependencies)) { + if (includeNonProperBounds || isProperType(lowerBound)) { if (lub == PsiType.NULL) { lub = lowerBound; } @@ -804,13 +835,6 @@ public class InferenceSession { return lub; } - private boolean isInsideRecursiveCall(HashSet<InferenceVariable> dependencies) { - for (InferenceVariable dependency : dependencies) { - if (!isInsideRecursiveCall(dependency.getParameter())) return false; - } - return true; - } - public PsiManager getManager() { return myManager; } @@ -820,7 +844,7 @@ public class InferenceSession { } public Collection<InferenceVariable> getInferenceVariables() { - return myInferenceVariables.values(); + return myInferenceVariables; } public void addConstraint(ConstraintFormula constraint) { @@ -829,10 +853,6 @@ public class InferenceSession { } } - public Collection<PsiTypeParameter> getTypeParams() { - return myInferenceVariables.keySet(); - } - private boolean proceedWithAdditionalConstraints(Set<ConstraintFormula> additionalConstraints) { final PsiSubstitutor siteSubstitutor = mySiteSubstitutor; @@ -855,7 +875,7 @@ public class InferenceSession { } //resolve input variables - PsiSubstitutor substitutor = resolveSubset(varsToResolve, retrieveNonPrimitiveEqualsBounds(getInferenceVariables()).putAll(siteSubstitutor)); + PsiSubstitutor substitutor = resolveSubset(varsToResolve, siteSubstitutor); if (substitutor == null) { return false; } @@ -972,7 +992,7 @@ public class InferenceSession { for (int i = 0; i < functionalMethodParameters.length; i++) { final PsiType pType = signature.getParameterTypes()[i]; - addConstraint(new TypeCompatibilityConstraint(getParameterType(parameters, i, PsiSubstitutor.EMPTY, varargs), + addConstraint(new TypeCompatibilityConstraint(substituteWithInferenceVariables(getParameterType(parameters, i, PsiSubstitutor.EMPTY, varargs)), PsiImplUtil.normalizeWildcardTypeByPosition(pType, reference))); } } @@ -1003,11 +1023,11 @@ public class InferenceSession { final PsiType qType = JavaPsiFacade.getElementFactory(method.getProject()).createType(containingClass, psiSubstitutor); - addConstraint(new TypeCompatibilityConstraint(qType, pType)); + addConstraint(new TypeCompatibilityConstraint(substituteWithInferenceVariables(qType), pType)); for (int i = 0; i < signature.getParameterTypes().length - 1; i++) { final PsiType interfaceParamType = signature.getParameterTypes()[i + 1]; - addConstraint(new TypeCompatibilityConstraint(getParameterType(parameters, i, PsiSubstitutor.EMPTY, varargs), + addConstraint(new TypeCompatibilityConstraint(substituteWithInferenceVariables(getParameterType(parameters, i, PsiSubstitutor.EMPTY, varargs)), PsiImplUtil.normalizeWildcardTypeByPosition(interfaceParamType, reference))); } } @@ -1020,7 +1040,7 @@ public class InferenceSession { } public InferenceVariable getInferenceVariable(PsiTypeParameter parameter) { - return myInferenceVariables.get(parameter); + return parameter instanceof InferenceVariable && myInferenceVariables.contains(parameter) ? (InferenceVariable)parameter : null; } /** @@ -1031,10 +1051,11 @@ public class InferenceSession { PsiExpression[] args, PsiElement context, boolean varargs) { - final InferenceSession session = new InferenceSession(PsiTypeParameter.EMPTY_ARRAY, PsiSubstitutor.EMPTY, m2.getManager(), context); + List<PsiTypeParameter> params = new ArrayList<PsiTypeParameter>(); for (PsiTypeParameter param : PsiUtil.typeParametersIterable(m2)) { - session.initBounds(context, param); + params.add(param); } + final InferenceSession session = new InferenceSession(params.toArray(new PsiTypeParameter[params.size()]), PsiSubstitutor.EMPTY, m2.getManager(), context); final PsiParameter[] parameters1 = m1.getParameterList().getParameters(); final PsiParameter[] parameters2 = m2.getParameterList().getParameters(); @@ -1045,7 +1066,7 @@ public class InferenceSession { final int paramsLength = !varargs ? parameters1.length : parameters1.length - 1; for (int i = 0; i < paramsLength; i++) { PsiType sType = getParameterType(parameters1, i, PsiSubstitutor.EMPTY, false); - PsiType tType = getParameterType(parameters2, i, PsiSubstitutor.EMPTY, varargs); + PsiType tType = session.substituteWithInferenceVariables(getParameterType(parameters2, i, PsiSubstitutor.EMPTY, varargs)); if (session.isProperType(sType) && session.isProperType(tType)) { if (!TypeConversionUtil.isAssignable(tType, sType)) { return false; @@ -1063,7 +1084,7 @@ public class InferenceSession { if (varargs) { PsiType sType = getParameterType(parameters1, paramsLength, PsiSubstitutor.EMPTY, true); - PsiType tType = getParameterType(parameters2, paramsLength, PsiSubstitutor.EMPTY, true); + PsiType tType = session.substituteWithInferenceVariables(getParameterType(parameters2, paramsLength, PsiSubstitutor.EMPTY, true)); session.addConstraint(new StrictSubtypingConstraint(tType, sType)); } @@ -1257,25 +1278,6 @@ public class InferenceSession { return myIncorporationPhase.hasCaptureConstraints(Arrays.asList(inferenceVariable)); } - public void liftBounds(PsiElement context, Collection<InferenceVariable> variables) { - for (InferenceVariable variable : variables) { - final PsiTypeParameter parameter = variable.getParameter(); - final InferenceVariable inferenceVariable = getInferenceVariable(parameter); - if (inferenceVariable != null) { - final PsiElement callContext = inferenceVariable.getCallContext(); - if (context.equals(callContext) || myContext.equals(callContext)) { - for (InferenceBound boundType : InferenceBound.values()) { - for (PsiType bound : variable.getBounds(boundType)) { - inferenceVariable.addBound(bound, boundType); - } - } - } - } else { - myInferenceVariables.put(parameter, variable); - } - } - } - public static boolean wasUncheckedConversionPerformed(PsiElement call) { final Boolean erased = call.getUserData(ERASED); return erased != null && erased.booleanValue(); @@ -1284,4 +1286,20 @@ public class InferenceSession { public PsiElement getContext() { return myContext; } + + public void propagateVariables(Collection<InferenceVariable> variables) { + myInferenceVariables.addAll(variables); + } + + public PsiType substituteWithInferenceVariables(PsiType type) { + return myInferenceSubstitution.substitute(type); + } + + public PsiType startWithFreshVars(PsiType type) { + PsiSubstitutor s = PsiSubstitutor.EMPTY; + for (InferenceVariable variable : myInferenceVariables) { + s = s.put(variable, JavaPsiFacade.getElementFactory(variable.getProject()).createType(variable.getParameter())); + } + return s.substitute(type); + } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceVariable.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceVariable.java index 6bc9e0b89871..8d91b620f798 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceVariable.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceVariable.java @@ -15,9 +15,7 @@ */ package com.intellij.psi.impl.source.resolve.graphInference; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiType; -import com.intellij.psi.PsiTypeParameter; +import com.intellij.psi.*; import com.intellij.psi.impl.light.LightTypeParameter; import java.util.*; @@ -139,6 +137,11 @@ public class InferenceVariable extends LightTypeParameter { } @Override + public boolean useDelegateToSubstitute() { + return false; + } + + @Override public String toString() { return getDelegate().toString(); } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/PsiGraphInferenceHelper.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/PsiGraphInferenceHelper.java index b4c971b3b469..28ad946275e9 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/PsiGraphInferenceHelper.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/PsiGraphInferenceHelper.java @@ -67,12 +67,12 @@ public class PsiGraphInferenceHelper implements PsiInferenceHelper { if (typeParameters.length == 0) return PsiSubstitutor.EMPTY; InferenceSession session = new InferenceSession(typeParameters, leftTypes, rightTypes, PsiSubstitutor.EMPTY, myManager, null); for (PsiType leftType : leftTypes) { - if (!session.isProperType(leftType)) { + if (!session.isProperType(session.substituteWithInferenceVariables(leftType))) { return session.infer(); } } for (PsiType rightType : rightTypes) { - if (!session.isProperType(rightType)) { + if (!session.isProperType(session.substituteWithInferenceVariables(rightType))) { return session.infer(); } } @@ -105,10 +105,11 @@ public class PsiGraphInferenceHelper implements PsiInferenceHelper { rightTypes = new PsiType[]{param}; } final InferenceSession inferenceSession = new InferenceSession(new PsiTypeParameter[]{typeParam}, leftTypes, rightTypes, PsiSubstitutor.EMPTY, myManager, null); - if (inferenceSession.isProperType(param) && inferenceSession.isProperType(arg)) { + if (inferenceSession.isProperType(inferenceSession.substituteWithInferenceVariables(param)) && + inferenceSession.isProperType(inferenceSession.substituteWithInferenceVariables(arg))) { boolean proceed = false; for (PsiClassType classType : typeParam.getExtendsListTypes()) { - if (!inferenceSession.isProperType(classType)) { + if (!inferenceSession.isProperType(inferenceSession.substituteWithInferenceVariables(classType))) { proceed = true; break; } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java index 82b320ae99f3..b59cf70bdb69 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java @@ -19,16 +19,12 @@ import com.intellij.psi.*; import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession; import com.intellij.psi.impl.source.resolve.graphInference.InferenceVariable; import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil; -import com.intellij.psi.impl.source.tree.java.PsiMethodCallExpressionImpl; import com.intellij.psi.infos.MethodCandidateInfo; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; -import com.intellij.util.containers.ContainerUtil; -import com.intellij.util.containers.HashSet; import org.jetbrains.annotations.NotNull; -import java.util.Collection; -import java.util.Iterator; +import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -94,7 +90,11 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm if (method != null && !method.isConstructor()) { returnType = method.getReturnType(); if (returnType != null) { - typeParams = method.getTypeParameters(); + List<PsiTypeParameter> params = new ArrayList<PsiTypeParameter>(); + for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(method)) { + params.add(parameter); + } + typeParams = params.toArray(new PsiTypeParameter[params.size()]); } } else if (myExpression instanceof PsiNewExpression) { //default constructor final PsiJavaCodeReferenceElement classReference = ((PsiNewExpression)myExpression).getClassOrAnonymousClassReference(); @@ -108,38 +108,8 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm } if (typeParams != null) { - - final Set<PsiTypeParameter> oldBounds = ContainerUtil.newHashSet(session.getParamsToInfer()); - final boolean sameMethodCall = session.initBounds(myExpression, typeParams); - PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; - final HashSet<InferenceVariable> variables = new HashSet<InferenceVariable>(); - session.collectDependencies(returnType, variables); - final PsiTypeParameter[] params = new PsiTypeParameter[typeParams.length]; - for (int i = 0; i < typeParams.length; i++) { - if (variables.contains(session.getInferenceVariable(typeParams[i]))) { - params[i] = JavaPsiFacade.getElementFactory(myExpression.getProject()).createTypeParameterFromText("copyOf" + myExpression.hashCode() + typeParams[i].getName(), null); - substitutor = substitutor.put(typeParams[i], JavaPsiFacade.getElementFactory(myExpression.getProject()).createType(params[i])); - } - else { - params[i] = typeParams[i]; - } - } - PsiSubstitutor siteSubstitutor = PsiSubstitutor.EMPTY; - if (method != null && !method.isConstructor()) { - if (resolveResult instanceof MethodCandidateInfo) { - siteSubstitutor = ((MethodCandidateInfo)resolveResult).getSiteSubstitutor(); - } - else if (candidateProperties != null) { - siteSubstitutor = candidateProperties.getSubstitutor(); - } - } - for (PsiTypeParameter typeParameter : siteSubstitutor.getSubstitutionMap().keySet()) { - substitutor = substitutor.put(typeParameter, substitutor.substitute(siteSubstitutor.substitute(typeParameter))); - } - - final Collection<PsiTypeParameter> params1 = session.getTypeParams(); - final InferenceSession callSession = new InferenceSession(params, substitutor, myExpression.getManager(), myExpression); - callSession.initBounds(session.getContext(), params1.toArray(new PsiTypeParameter[params1.size()])); + final InferenceSession callSession = new InferenceSession(typeParams, PsiSubstitutor.EMPTY, myExpression.getManager(), myExpression); + callSession.propagateVariables(session.getInferenceVariables()); if (method != null) { final PsiExpression[] args = argumentList.getExpressions(); final PsiParameter[] parameters = method.getParameterList().getParameters(); @@ -150,27 +120,12 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm if (!accepted) { return false; } - callSession.registerReturnTypeConstraints( - method != null && !PsiUtil.isRawSubstitutor(method, siteSubstitutor) ? siteSubstitutor.substitute(returnType) : returnType, - substitutor.substitute(returnType)); + callSession.registerReturnTypeConstraints(returnType, myT); if (callSession.repeatInferencePhases(true)) { - final Collection<InferenceVariable> inferenceVariables = callSession.getInferenceVariables(); - if (sameMethodCall) { - for (Iterator<InferenceVariable> iterator = inferenceVariables.iterator(); iterator.hasNext(); ) { - InferenceVariable variable = iterator.next(); - if (oldBounds.contains(variable.getParameter())) { - iterator.remove(); - } - } - } - session.liftBounds(myExpression, inferenceVariables); + session.registerNestedSession(callSession); } else { return false; } - final PsiType capturedReturnType = myExpression instanceof PsiMethodCallExpression - ? PsiMethodCallExpressionImpl.captureReturnType((PsiMethodCallExpression)myExpression, method, returnType, substitutor) - : substitutor.substitute(returnType); - constraints.add(new TypeCompatibilityConstraint(myT, capturedReturnType)); } } return true; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/LambdaExpressionCompatibilityConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/LambdaExpressionCompatibilityConstraint.java index cbed2ea59491..c282481e79c0 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/LambdaExpressionCompatibilityConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/LambdaExpressionCompatibilityConstraint.java @@ -45,7 +45,7 @@ public class LambdaExpressionCompatibilityConstraint implements ConstraintFormul constraints.add(new StrictSubtypingConstraint(myT, groundTargetType)); } else { for (PsiParameter parameter : parameters) { - if (!session.isProperType(substitutor.substitute(parameter.getType()))) { + if (!session.isProperType(session.substituteWithInferenceVariables(substitutor.substitute(parameter.getType())))) { return false; } } @@ -62,7 +62,7 @@ public class LambdaExpressionCompatibilityConstraint implements ConstraintFormul if (returnExpressions.isEmpty() && !myExpression.isValueCompatible()) { //not value-compatible return false; } - returnType = substitutor.substitute(returnType); + returnType = session.substituteWithInferenceVariables(substitutor.substitute(returnType)); if (!session.isProperType(returnType)) { for (PsiExpression returnExpression : returnExpressions) { constraints.add(new ExpressionCompatibilityConstraint(returnExpression, returnType)); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/PsiMethodReferenceCompatibilityConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/PsiMethodReferenceCompatibilityConstraint.java index eefd040b2a99..fbfd8195fc11 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/PsiMethodReferenceCompatibilityConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/PsiMethodReferenceCompatibilityConstraint.java @@ -93,11 +93,13 @@ public class PsiMethodReferenceCompatibilityConstraint implements ConstraintForm if (targetParameters.length == parameters.length + 1) { specialCase(session, constraints, substitutor, targetParameters, true); for (int i = 1; i < targetParameters.length; i++) { - constraints.add(new TypeCompatibilityConstraint(psiSubstitutor.substitute(parameters[i - 1].getType()), substitutor.substitute(targetParameters[i].getType()))); + constraints.add(new TypeCompatibilityConstraint(session.substituteWithInferenceVariables(psiSubstitutor.substitute(parameters[i - 1].getType())), + substitutor.substitute(targetParameters[i].getType()))); } } else if (targetParameters.length == parameters.length) { for (int i = 0; i < targetParameters.length; i++) { - constraints.add(new TypeCompatibilityConstraint(psiSubstitutor.substitute(parameters[i].getType()), substitutor.substitute(targetParameters[i].getType()))); + constraints.add(new TypeCompatibilityConstraint(session.substituteWithInferenceVariables(psiSubstitutor.substitute(parameters[i].getType())), + substitutor.substitute(targetParameters[i].getType()))); } } else { return false; @@ -108,12 +110,13 @@ public class PsiMethodReferenceCompatibilityConstraint implements ConstraintForm } if (applicableMethodReturnType != null) { - constraints.add(new TypeCompatibilityConstraint(returnType, psiSubstitutor.substitute(applicableMethodReturnType))); - } else if (applicableMember instanceof PsiClass || applicableMember instanceof PsiMethod && ((PsiMethod)applicableMember).isConstructor()) { + constraints.add(new TypeCompatibilityConstraint(returnType, + session.substituteWithInferenceVariables(psiSubstitutor.substitute(applicableMethodReturnType)))); + } + else if (applicableMember instanceof PsiClass || applicableMember instanceof PsiMethod && ((PsiMethod)applicableMember).isConstructor()) { final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(applicableMember.getProject()); - if (containingClass != null) { - final PsiClassType classType = elementFactory.createType(containingClass, psiSubstitutor); + final PsiType classType = session.substituteWithInferenceVariables(elementFactory.createType(containingClass, psiSubstitutor)); constraints.add(new TypeCompatibilityConstraint(returnType, classType)); } } @@ -122,7 +125,7 @@ public class PsiMethodReferenceCompatibilityConstraint implements ConstraintForm } final Map<PsiMethodReferenceExpression, PsiType> map = PsiMethodReferenceUtil.getFunctionalTypeMap(); - final PsiType added = map.put(myExpression, groundTargetType); + final PsiType added = map.put(myExpression, session.startWithFreshVars(groundTargetType)); final JavaResolveResult resolve; try { resolve = myExpression.advancedResolve(true); @@ -205,7 +208,7 @@ public class PsiMethodReferenceCompatibilityConstraint implements ConstraintForm PsiPolyExpressionUtil.mentionsTypeParameters(referencedMethodReturnType, ContainerUtil.newHashSet(containingClass.getTypeParameters()))) { //todo specification bug? specialCase(session, constraints, substitutor, targetParameters, false); } - constraints.add(new TypeCompatibilityConstraint(returnType, psiSubstitutor.substitute(referencedMethodReturnType))); + constraints.add(new TypeCompatibilityConstraint(returnType, session.substituteWithInferenceVariables(psiSubstitutor.substitute(referencedMethodReturnType)))); } return true; @@ -241,7 +244,8 @@ public class PsiMethodReferenceCompatibilityConstraint implements ConstraintForm final PsiClass qualifierClass = PsiUtil.resolveClassInType(qualifierType); if (qualifierClass != null) { session.initBounds(qualifierClass.getTypeParameters()); - constraints.add(new StrictSubtypingConstraint(qualifierType, substitutor.substitute(targetParameters[0].getType()))); + constraints.add(new StrictSubtypingConstraint(session.substituteWithInferenceVariables(qualifierType), + session.substituteWithInferenceVariables(substitutor.substitute(targetParameters[0].getType())))); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java index 29525add1549..661d59105046 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/MethodReferenceResolver.java @@ -68,7 +68,7 @@ public class MethodReferenceResolver implements ResolveCache.PolyVariantContextR if (interfaceMethod != null) { final PsiClassType returnType = composeReturnType(containingClass, substitutor); final InferenceSession session = new InferenceSession(containingClass.getTypeParameters(), substitutor, reference.getManager(), null); - if (!(session.isProperType(returnType) && session.isProperType(interfaceMethodReturnType))) { + if (!(session.isProperType(session.substituteWithInferenceVariables(returnType)) && session.isProperType(interfaceMethodReturnType))) { session.registerReturnTypeConstraints(returnType, interfaceMethodReturnType); substitutor = session.infer(); } @@ -116,13 +116,6 @@ public class MethodReferenceResolver implements ResolveCache.PolyVariantContextR private PsiSubstitutor inferTypeArguments() { if (interfaceMethod == null) return substitutor; final InferenceSession session = new InferenceSession(method.getTypeParameters(), substitutor, reference.getManager(), reference); - - //lift parameters from outer call - final CurrentCandidateProperties methodSubstitutorPair = MethodCandidateInfo.getCurrentMethod(reference.getParent()); - if (methodSubstitutorPair != null) { - session.initBounds(methodSubstitutorPair.getMethod().getTypeParameters()); - } - final PsiSubstitutor psiSubstitutor = session.collectApplicabilityConstraints(reference, this, functionalInterfaceType); if (psiSubstitutor != null) { return psiSubstitutor; @@ -133,6 +126,10 @@ public class MethodReferenceResolver implements ResolveCache.PolyVariantContextR } if (interfaceMethodReturnType != PsiType.VOID && interfaceMethodReturnType != null) { + if (method.isConstructor()) { + //todo + session.initBounds(reference, method.getContainingClass().getTypeParameters()); + } final PsiType returnType = method.isConstructor() ? composeReturnType(containingClass, substitutor) : method.getReturnType(); if (returnType != null) { session.registerReturnTypeConstraints(returnType, interfaceMethodReturnType); diff --git a/java/java-runtime/src/com/intellij/rt/debugger/DefaultMethodInvoker.java b/java/java-runtime/src/com/intellij/rt/debugger/DefaultMethodInvoker.java new file mode 100644 index 000000000000..da01203c09f7 --- /dev/null +++ b/java/java-runtime/src/com/intellij/rt/debugger/DefaultMethodInvoker.java @@ -0,0 +1,39 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.rt.debugger; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * @author egor + */ +public class DefaultMethodInvoker { + + // only methods without arguments for now + public static Object invoke(Object obj, String name) + throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { + + Method method = obj.getClass().getMethod(name, null); + if (method != null) { + method.setAccessible(true); + Object res = method.invoke(obj, null); + method.setAccessible(false); + return res; + } + return null; + } +} diff --git a/java/java-tests/testData/codeInsight/completion/keywords/finalInCatch.java b/java/java-tests/testData/codeInsight/completion/keywords/finalInCatch.java new file mode 100644 index 000000000000..6346b73dd045 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/keywords/finalInCatch.java @@ -0,0 +1,7 @@ +public class StructuredConfigKey { + { + try { + + } catch (<caret>) + } +} diff --git a/java/java-tests/testData/codeInsight/completion/keywords/finalInIncompleteCatch.java b/java/java-tests/testData/codeInsight/completion/keywords/finalInIncompleteCatch.java new file mode 100644 index 000000000000..0cdeb4962618 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/keywords/finalInIncompleteCatch.java @@ -0,0 +1,7 @@ +public class StructuredConfigKey { + { + try { + + } catch (<caret> + } +} diff --git a/java/java-tests/testData/codeInsight/completion/smartType/SuggestTypeParametersInTypeArgumentList.java b/java/java-tests/testData/codeInsight/completion/smartType/SuggestTypeParametersInTypeArgumentList.java new file mode 100644 index 000000000000..0bc90adbf7a3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/smartType/SuggestTypeParametersInTypeArgumentList.java @@ -0,0 +1,8 @@ +class StringEx<T extends String> { +} +class Outer<T extends String> { + static class CompletionTest<T extends String> { + private StringEx<<caret>> myString; + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/ParameterBoundsWithCapturedWildcard.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/ParameterBoundsWithCapturedWildcard.java new file mode 100644 index 000000000000..c7cb266321c5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/ParameterBoundsWithCapturedWildcard.java @@ -0,0 +1,5 @@ +class Test<T > { + public static interface EventListener<V extends String> {} + public void addListener (EventListener<<error descr="Type parameter '? extends T' is not within its bound; should extend 'java.lang.String'">? extends T</error>> listener) {} + public void addListener1(EventListener<? super T> listener) {} +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/SuperCaptureSubstitutionWhenTypeParameterHasUpperBounds.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/SuperCaptureSubstitutionWhenTypeParameterHasUpperBounds.java new file mode 100644 index 000000000000..4eaf810dad4f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/SuperCaptureSubstitutionWhenTypeParameterHasUpperBounds.java @@ -0,0 +1,30 @@ +class Test<T > { + interface Event{} + + interface EventListener<V extends Event> { + void handleEvent(V event); + } + + public void addListener(EventListener<? super T> listener) { + EventListener<? extends Event> localListener = listener; + <error descr="Incompatible types. Found: 'Test.EventListener<capture<? super T>>', required: 'Test.EventListener<? super Test.Event>'">EventListener<? super Event> localListener1 = listener;</error> + } +} + +class Test1 { + + public static class Entity<E extends Entity<E>> { + + public final <T, V extends EntityVisitor<? super E, T>> T handle(final V visitor) { + return visitor.handle(this); + } + + } + + public interface EntityVisitor<E extends Entity<E>, T> { + + T handle(Entity<? extends E> e); + + } + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA110947.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA110947.java index 5f7ac80942a2..e895159a5762 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA110947.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA110947.java @@ -9,7 +9,7 @@ abstract class ProcedureService { abstract <C extends Command<Result>> Class<? extends Procedure<Command<Result>>> getProcedure(Class<C> cmd); public <C extends Command<Result>> void execute(Class<? extends Command> aClass) { - Class<Procedure<Command<Result>>> procedureClass = getProcedure(aClass); + <error descr="Incompatible types. Found: 'java.lang.Class<capture<? extends Procedure<Command<Result>>>>', required: 'java.lang.Class<Procedure<Command<Result>>>'">Class<Procedure<Command<Result>>> procedureClass = getProcedure(aClass);</error> <error descr="Incompatible types. Found: 'java.lang.Class<capture<? extends Command>>', required: 'java.lang.Class<Command>'">Class<Command> c = aClass;</error> <error descr="Incompatible types. Found: 'java.lang.Class<capture<? extends Command>>', required: 'java.lang.Class<C>'">Class<C> c1 = aClass;</error> } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA128333.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA128333.java new file mode 100644 index 000000000000..24bc5b3ab1fe --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA128333.java @@ -0,0 +1,24 @@ +import java.util.*; +import java.lang.annotation.Annotation; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +abstract class WithAnn { + + { + map((Class<? extends Annotation> ann) -> getAnnotation(ann)); + map(this::getAnnotation); + } + + abstract <A> A getAnnotation(Class<A> annotationClass); + abstract <R> void map(Function<Class<? extends Annotation>, ? extends R> mapper); +} + +class Test { + private void it(final Set<Class<? extends String>> set) { + set.forEach((clazz) -> bind(clazz)); + } + + protected <T> void bind(Class<T> clazz) {} +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/SuperWildcardWithBoundPromotion.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/SuperWildcardWithBoundPromotion.java index f1a533020e34..33dd56b27183 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/SuperWildcardWithBoundPromotion.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/SuperWildcardWithBoundPromotion.java @@ -20,7 +20,7 @@ class Bug2<T extends Integer>{ } void bug1(Parametrized<? super T> param) { - <error descr="Inferred type 'capture<? super T>' for type parameter 'I' is not within its bound; should extend 'java.lang.Number'">foo(param)</error>; + foo(param); } @@ -35,7 +35,7 @@ class Test { } void bug1(Parametrized<? super T> param) { - <error descr="Inferred type 'java.io.Serializable' for type parameter 'I' is not within its bound; should extend 'java.lang.Number'">foo(param)</error>; + <error descr="Inferred type 'capture<? super T>' for type parameter 'I' is not within its bound; should extend 'java.lang.Number'">foo(param)</error>; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/WildcardsBoundsIntersection.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/WildcardsBoundsIntersection.java index 6385fe5d125e..cf8ad1c9fb9f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/WildcardsBoundsIntersection.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/WildcardsBoundsIntersection.java @@ -10,6 +10,6 @@ class Node<NodeTypeT extends NodeType> { class Main { public static void main(NodeProperty<NumberExpression, Integer> nval, Node<? extends NodeType> expr) { - int val = expr.get<error descr="'get(NodeProperty<? super capture<? extends NodeType>,java.lang.Integer>)' in 'Node' cannot be applied to '(NodeProperty<NumberExpression,java.lang.Integer>)'">(nval)</error>; + int val = expr.get<error descr="'get(NodeProperty<? super capture<? extends NodeType>,java.lang.Object>)' in 'Node' cannot be applied to '(NodeProperty<NumberExpression,java.lang.Integer>)'">(nval)</error>; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/CyclicParamsDependency.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/CyclicParamsDependency.java new file mode 100644 index 000000000000..927165e23e9c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/CyclicParamsDependency.java @@ -0,0 +1,18 @@ +import java.util.List; + +class Sample { + <T extends List<K>, K extends List<T>> T foo(){ + <error descr="Incompatible types. Found: 'K', required: 'T'">T t = foo().get(0);</error> + <error descr="Incompatible types. Found: 'K', required: 'K'">K k = foo().get(0);</error> + + <error descr="Incompatible types. Found: 'T', required: 'T'">T t1 = foo().get(0).get(0);</error> + + String s = foo(); + <error descr="Incompatible types. Found: 'K', required: 'java.lang.String'">String s1 = foo().get(0);</error> + return null; + } + + { + foo(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA126163.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA126163.java new file mode 100644 index 000000000000..7869663fb863 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA126163.java @@ -0,0 +1,29 @@ +class Test { + + public static void main( String[] args ) throws Exception { + Checker.assertThat("", Utils.is(Utils.notNullValue())); + } +} + +interface Util<T> { +} + +class Utils { + static <T> Util<T> is( Util<T> util ) { + return null; + } + + static <T> Util<T> is( T t ) { + return null; + } + + static <T> Util<T> notNullValue() { + return null; + } +} + +class Checker { + static <T> void assertThat(T actual, Util<T> util) { + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128101.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128101.java index 42be49b62f04..ac00e0bae517 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128101.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128101.java @@ -22,8 +22,8 @@ class TestIDEA128101 { construct(String.class, createPath(integerAttribute), createPath(stringAttribute)); construct1<error descr="Cannot resolve method 'construct1(java.lang.Class<java.lang.String>, TestIDEA128101.Path<java.lang.Integer>, TestIDEA128101.Path<java.lang.String>)'">(String.class, createPath(integerAttribute), createPath(stringAttribute))</error>; construct2(String.class, createPath(integerAttribute), createPath(stringAttribute)); - <error descr="Type parameter K has incompatible upper bounds: Integer and String">construct3(String.class, createPath(integerAttribute), createPath(stringAttribute));</error> - <error descr="Type parameter K has incompatible upper bounds: Integer and String">construct4(String.class, createPath(integerAttribute), createPath(stringAttribute));</error> + construct3<error descr="Cannot resolve method 'construct3(java.lang.Class<java.lang.String>, TestIDEA128101.Path<java.lang.Integer>, TestIDEA128101.Path<java.lang.String>)'">(String.class, createPath(integerAttribute), createPath(stringAttribute))</error>; + construct4(String.class, createPath(integerAttribute), createPath<error descr="'createPath(TestIDEA128101.Attribute<Y>)' in 'TestIDEA128101' cannot be applied to '(TestIDEA128101.Attribute<java.lang.String>)'">(stringAttribute)</error>); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128766.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128766.java new file mode 100644 index 000000000000..715b158d2cdd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IDEA128766.java @@ -0,0 +1,21 @@ +class Test { + + static class TKey<T> {} + + public interface Getter { + <T> T getValue(TKey<T> key); + } + + public static <TK extends TKey<?>> TK getAKey(TK tKeySuffix) { + return tKeySuffix; + } + + static final TKey<Double> KEY_D = new TKey<>(); + public static void f(Getter getter) { + double d1 = getter.getValue(KEY_D); + double d2 = getter.getValue(getAKey(KEY_D)); + TKey<Double> aKey = getAKey(KEY_D); + double d3 = getter.getValue(aKey); + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InfiniteTypes.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InfiniteTypes.java new file mode 100644 index 000000000000..2f6d975261e4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/InfiniteTypes.java @@ -0,0 +1,9 @@ +class Test { + + public static void main(String[] args) { + multiBound("test"); + multiBound(null); + } + + static <E extends Comparable<E> & CharSequence> void multiBound(E e) {} +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SOEDuringInferenceFromParamBounds.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SOEDuringInferenceFromParamBounds.java index 3f26bbc1ef56..90e8efb23b5d 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SOEDuringInferenceFromParamBounds.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SOEDuringInferenceFromParamBounds.java @@ -3,5 +3,5 @@ import java.util.Map; public class SOE { public static <K extends M, M extends Map<K,M>> M foo() {return null;} - public static <K1 extends M1, M1 extends Map<K1,M1>> Map<K1, M1> foo1() {return <error descr="Inferred type 'java.util.Map<K1,M1>' for type parameter 'M' is not within its bound; should implement 'java.util.Map<java.util.Map<K1,M1>,java.util.Map<K1,M1>>'">foo()</error>;} + public static <K1 extends M1, M1 extends Map<K1,M1>> Map<K1, M1> foo1() {<error descr="Incompatible types. Found: 'M', required: 'java.util.Map<K1,M1>'">return foo();</error>} } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SameMethodNestedChainedCallsNearFunctionInterfaces.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SameMethodNestedChainedCallsNearFunctionInterfaces.java new file mode 100644 index 000000000000..d8e931915013 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/SameMethodNestedChainedCallsNearFunctionInterfaces.java @@ -0,0 +1,87 @@ +import java.util.*; +import java.util.function.BiFunction; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +class Test +{ + public static class K<T> + { + private final T head; + private final K<T> tail; + + public K(T head, K<T> tail) + { + this.head = head; + this.tail = tail; + } + } + + public static class P<U> + { + public <B, C> P<C> biMap(P<B> that, BiFunction<U, B, C> f) + { + return null; + } + } + + public static <A> P<K<A>> f(K<P<A>> x) + { + return x.head.biMap(f(x.tail), K::new); + } +} + +class A<T> +{ + public A(Supplier<T> arg0, Supplier<A<T>> arg1){} + + static <S> A<S> make(S[] s) + { + return helpMake(0, s); + } + + static <S> A<S> helpMake(int offset, S[] s) + { + return new A<>(() -> s[offset], () -> helpMake(offset + 1, s)); + } +} + +interface MultivaluedMap<K, V> extends Map<K, List<V>> { + + void putSingle(K var1, V var2); + + void add(K var1, V var2); + + V getFirst(K var1); +} + + +class Headers { + private final Map<String, List<String>> headers; + + public Headers(Map<String, List<String>> headers) { + this.headers = headers; + } + + public Headers(MultivaluedMap<String, Object> multimap) { + this.headers = multimap.entrySet() + .stream() + .collect( + Collectors.toMap( + Map.Entry::getKey, + x -> x.getValue() + .stream() + .map(Object::toString) + .collect(Collectors.toList()) + ) + ); + } +} + +class IDEA128245 { + public void testCollectors(final Stream<Map.Entry<String, Set<String>>> stream, + Stream<Integer> integerStream) { + stream.collect(Collectors.toMap(Map.Entry::getKey, entry -> integerStream.collect(Collectors.toSet()))); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/AdditionalConstraints3Level.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/AdditionalConstraints3Level.java new file mode 100644 index 000000000000..3e4ef6f955e5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/AdditionalConstraints3Level.java @@ -0,0 +1,15 @@ +import java.util.List; +import java.util.function.Function; + +abstract class Sample { + abstract <T> T id (T t); + abstract <R> void foo(List<R> c); + abstract <U> List<U> bar(Function<String, U> m); + + { + foo(bar(this::id)); + foo(bar(id(i -> i))); + + Function<String, String> s = id(this::id); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/WildcardParametrization.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/WildcardParametrization.java new file mode 100644 index 000000000000..d1adfe4a9ee1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/WildcardParametrization.java @@ -0,0 +1,19 @@ + +import java.util.function.Function; + +class IdeaTest { + class Test<K>{} + + public void checkAnnotationsPresent() { + Function<Test<? extends Annotation>, Annotation> mapper = this::getAnnotation; + Function<Test<? extends Annotation>, ? extends Annotation> mapper1 = this::getAnnotation; + } + + public <A extends Annotation> A getAnnotation(Test<A> annotationClass) { + return null; + } + + static class Annotation{} + + +} diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_after.java b/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_after.java new file mode 100644 index 000000000000..d57959a1485a --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_after.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + if (f() && new Object(){<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_before.java b/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_before.java new file mode 100644 index 000000000000..9718c041c2e0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBraceCompositeCondition_before.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + if (f() && new Object()<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_after.java b/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_after.java new file mode 100644 index 000000000000..f85e4d676ead --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_after.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + if (new Object(){<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_before.java b/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_before.java new file mode 100644 index 000000000000..f536c7eba9a3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBraceNewObject_before.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + if (new Object()<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBrace_after.java b/java/java-tests/testData/codeInsight/typing/fixIfByBrace_after.java new file mode 100644 index 000000000000..f17312c07aa6 --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBrace_after.java @@ -0,0 +1,7 @@ +class C { + boolean f() { + if (f()) { + <caret> + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixIfByBrace_before.java b/java/java-tests/testData/codeInsight/typing/fixIfByBrace_before.java new file mode 100644 index 000000000000..017a62e874f3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixIfByBrace_before.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + if (f()<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_after.java b/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_after.java new file mode 100644 index 000000000000..92e28bfe1542 --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_after.java @@ -0,0 +1,7 @@ +class C { + boolean f() { + while (f()) { + <caret> + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_before.java b/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_before.java new file mode 100644 index 000000000000..a254dee776db --- /dev/null +++ b/java/java-tests/testData/codeInsight/typing/fixWhileByBrace_before.java @@ -0,0 +1,5 @@ +class C { + boolean f() { + while (f()<caret>) + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/awt/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/awt/annotations.xml index 0314b02a4d7b..2e75eb0e3c6c 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/awt/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/awt/annotations.xml @@ -1,4 +1,10 @@ <root> + <item name="java.awt.Component boolean action(java.awt.Event, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean action(java.awt.Event, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean action(java.awt.Event, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;_,!null->false;_,null->false;null,_->false""/> @@ -18,6 +24,12 @@ <item name="java.awt.Component boolean eventEnabled(java.awt.AWTEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component boolean gotFocus(java.awt.Event, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean gotFocus(java.awt.Event, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean gotFocus(java.awt.Event, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;_,!null->false;_,null->false;null,_->false""/> @@ -26,46 +38,85 @@ <item name="java.awt.Component boolean handleEvent(java.awt.Event) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component boolean imageUpdate(java.awt.Image, int, int, int, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean isFocusCycleRoot(java.awt.Container) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean isSameOrAncestorOf(java.awt.Component, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean keyDown(java.awt.Event, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean keyDown(java.awt.Event, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;null,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean keyUp(java.awt.Event, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean keyUp(java.awt.Event, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;null,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean lostFocus(java.awt.Event, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component boolean lostFocus(java.awt.Event, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean lostFocus(java.awt.Event, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;_,!null->false;_,null->false;null,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseDown(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseDown(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseDrag(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseDrag(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseEnter(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseEnter(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseExit(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseExit(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseMove(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseMove(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Component boolean mouseUp(java.awt.Event, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component boolean mouseUp(java.awt.Event, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->false;null,_,_->false""/> @@ -93,6 +144,9 @@ <item name="java.awt.Component java.awt.Dimension getMaximumSize()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component java.awt.Dimension getSize(java.awt.Dimension) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component java.awt.Dimension getSize(java.awt.Dimension)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> @@ -107,6 +161,9 @@ <item name="java.awt.Component java.awt.Dimension size()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component java.awt.Point getLocation(java.awt.Point) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component java.awt.Point getLocation(java.awt.Point)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> @@ -124,6 +181,9 @@ <item name="java.awt.Component java.awt.Rectangle bounds()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component java.awt.Rectangle getBounds(java.awt.Rectangle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component java.awt.Rectangle getBounds(java.awt.Rectangle)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> @@ -134,6 +194,9 @@ <val val=""null->null""/> </annotation> </item> + <item name="java.awt.Component java.awt.image.VolatileImage createVolatileImage(int, int, java.awt.ImageCapabilities) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component java.lang.String paramString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -146,9 +209,48 @@ <item name="java.awt.Component void add(java.awt.PopupMenu) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component void addComponentListener(java.awt.event.ComponentListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addFocusListener(java.awt.event.FocusListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addHierarchyBoundsListener(java.awt.event.HierarchyBoundsListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addHierarchyListener(java.awt.event.HierarchyListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addInputMethodListener(java.awt.event.InputMethodListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addKeyListener(java.awt.event.KeyListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addMouseListener(java.awt.event.MouseListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addMouseMotionListener(java.awt.event.MouseMotionListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addMouseWheelListener(java.awt.event.MouseWheelListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addPropertyChangeListener(java.beans.PropertyChangeListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component void applyComponentOrientation(java.awt.ComponentOrientation) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component void autoProcessMouseWheel(java.awt.event.MouseWheelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void checkGD(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component void createBufferStrategy(int, java.awt.BufferCapabilities) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -161,9 +263,54 @@ <item name="java.awt.Component void list(java.io.PrintWriter, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component void paint(java.awt.Graphics) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void paintHeavyweightComponents(java.awt.Graphics) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void printHeavyweightComponents(java.awt.Graphics) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void processEvent(java.awt.AWTEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Component void removeComponentListener(java.awt.event.ComponentListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeFocusListener(java.awt.event.FocusListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeHierarchyBoundsListener(java.awt.event.HierarchyBoundsListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeHierarchyListener(java.awt.event.HierarchyListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeInputMethodListener(java.awt.event.InputMethodListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeKeyListener(java.awt.event.KeyListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeMouseListener(java.awt.event.MouseListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeMouseMotionListener(java.awt.event.MouseMotionListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removeMouseWheelListener(java.awt.event.MouseWheelListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removePropertyChangeListener(java.beans.PropertyChangeListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Component void removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Component void resize(java.awt.Dimension) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -185,16 +332,28 @@ <item name="java.awt.Container boolean eventEnabled(java.awt.AWTEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container boolean isAncestorOf(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container boolean isAncestorOf(java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.awt.Container boolean isFocusCycleRoot(java.awt.Container) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Container boolean isRemoveNotifyNeeded(java.awt.Component, java.awt.Container, java.awt.Container) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container boolean isRemoveNotifyNeeded(java.awt.Component, java.awt.Container, java.awt.Container)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->false;_,null,_->false;null,_,_->false""/> </annotation> </item> + <item name="java.awt.Container int getComponentZOrder(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container java.awt.Component add(java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -225,12 +384,21 @@ <item name="java.awt.Container java.lang.String paramString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container void addContainerListener(java.awt.event.ContainerListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container void addDelicately(java.awt.Component, java.awt.Container, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.awt.Container void addImpl(java.awt.Component, java.lang.Object, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container void addPropertyChangeListener(java.beans.PropertyChangeListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Container void addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container void applyComponentOrientation(java.awt.ComponentOrientation) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -252,15 +420,24 @@ <item name="java.awt.Container void list(java.io.PrintWriter, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container void processEvent(java.awt.AWTEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.awt.Container void remove(java.awt.Component) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container void removeContainerListener(java.awt.event.ContainerListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container void removeDelicately(java.awt.Component, java.awt.Container, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Container void reparentChild(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Container void reparentTraverse(java.awt.peer.ContainerPeer, java.awt.Container) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -273,6 +450,9 @@ <item name="java.awt.Dimension Dimension(java.awt.Dimension) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Dimension boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Dimension boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -290,6 +470,9 @@ <item name="java.awt.Frame java.lang.String constructComponentName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Frame void init(java.lang.String, java.awt.GraphicsConfiguration) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Frame void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -305,6 +488,9 @@ <item name="java.awt.Window Window(java.awt.Window, java.awt.GraphicsConfiguration) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window boolean dispatchMouseWheelToAncestor(java.awt.event.MouseWheelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window boolean dispatchMouseWheelToAncestor(java.awt.event.MouseWheelEvent)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -324,21 +510,63 @@ <item name="java.awt.Window java.lang.String constructComponentName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window void addOwnedWindow(java.lang.ref.WeakReference) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void addPropertyChangeListener(java.beans.PropertyChangeListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void addWindowFocusListener(java.awt.event.WindowFocusListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void addWindowListener(java.awt.event.WindowListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void addWindowStateListener(java.awt.event.WindowStateListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window void connectOwnedWindow(java.awt.Window) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window void deliverMouseWheelToAncestor(java.awt.event.MouseWheelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window void dispatchEventImpl(java.awt.AWTEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.awt.Window void ownedInit(java.awt.Window) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window void postProcessKeyEvent(java.awt.event.KeyEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window void preProcessKeyEvent(java.awt.event.KeyEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window void processEvent(java.awt.AWTEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.awt.Window void removeOwnedWindow(java.lang.ref.WeakReference) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void removeWindowFocusListener(java.awt.event.WindowFocusListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void removeWindowListener(java.awt.event.WindowListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void removeWindowStateListener(java.awt.event.WindowStateListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.awt.Window void setCursor(java.awt.Cursor) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.awt.Window void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/beans/beancontext/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/beans/beancontext/annotations.xml index 60214de88d04..ce4e092e389f 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/beans/beancontext/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/beans/beancontext/annotations.xml @@ -43,6 +43,9 @@ <item name="java.beans.beancontext.BeanContextServicesSupport void bcsPreSerializationHook(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.beans.beancontext.BeanContextServicesSupport void childJustRemovedHook(java.lang.Object, java.beans.beancontext.BeanContextSupport.BCSChild) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.beans.beancontext.BeanContextServicesSupport void childJustRemovedHook(java.lang.Object, java.beans.beancontext.BeanContextSupport.BCSChild) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/io/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/io/annotations.xml index 868b0f3f11c0..521adcf48636 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/io/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/io/annotations.xml @@ -62,6 +62,9 @@ <item name="java.io.DataInputStream void readFully(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File File(java.io.File, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File File(java.io.File, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -71,12 +74,21 @@ <item name="java.io.File File(java.lang.String, java.io.File) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File File(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File File(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.io.File File(java.net.URI) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File boolean checkAndCreate(java.lang.String, java.lang.SecurityManager) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.File boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -85,15 +97,33 @@ <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String, java.io.File) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String, java.io.File) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String, java.io.File) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File java.io.File createTempFile(java.lang.String, java.lang.String, java.io.File)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File java.io.File generateFile(java.lang.String, java.lang.String, java.io.File) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.File java.io.File generateFile(java.lang.String, java.lang.String, java.io.File) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.File java.io.File generateFile(java.lang.String, java.lang.String, java.io.File) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File java.io.File generateFile(java.lang.String, java.lang.String, java.io.File)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -103,12 +133,26 @@ <item name="java.io.File java.io.File getCanonicalFile()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File java.io.File[] listFiles(java.io.FileFilter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.File java.io.File[] listFiles(java.io.FilenameFilter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File java.lang.String getName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.io.File java.lang.String slashify(java.lang.String, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.File java.lang.String slashify(java.lang.String, boolean)"> + <annotation name="org.jetbrains.annotations.Contract"> + <val val=""!null,_->!null""/> + </annotation> + </item> + <item name="java.io.File java.lang.String[] list(java.io.FilenameFilter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.File java.net.URI toURI()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -124,21 +168,45 @@ <item name="java.io.FileInputStream FileInputStream(java.io.FileDescriptor) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.FileInputStream FileInputStream(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.FileInputStream int read(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.FileNotFoundException FileNotFoundException(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.FileNotFoundException FileNotFoundException(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.FileOutputStream FileOutputStream(java.io.FileDescriptor) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.FileOutputStream FileOutputStream(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.FileOutputStream FileOutputStream(java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.FileOutputStream void write(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.io.FileReader FileReader(java.io.FileDescriptor) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.FileReader FileReader(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.FileWriter FileWriter(java.io.FileDescriptor) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.FileWriter FileWriter(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.FileWriter FileWriter(java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.FilterOutputStream void write(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -213,6 +281,9 @@ <item name="java.io.ObjectInputStream void access$500(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectInputStream void defaultReadFields(java.lang.Object, java.io.ObjectStreamClass) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.ObjectInputStream void defaultReadFields(java.lang.Object, java.io.ObjectStreamClass) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -225,6 +296,9 @@ <item name="java.io.ObjectInputStream void readFully(byte[], int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectInputStream void readSerialData(java.lang.Object, java.io.ObjectStreamClass) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.ObjectInputStream void readSerialData(java.lang.Object, java.io.ObjectStreamClass) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -239,6 +313,12 @@ <item name="java.io.ObjectOutputStream void access$100(java.io.ObjectOutputStream, java.lang.Object, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectOutputStream void annotateClass(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.ObjectOutputStream void annotateProxyClass(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.ObjectOutputStream void defaultWriteFields(java.lang.Object, java.io.ObjectStreamClass) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -254,6 +334,9 @@ <item name="java.io.ObjectOutputStream void writeArray(java.lang.Object, java.io.ObjectStreamClass, boolean) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectOutputStream void writeClassDesc(java.io.ObjectStreamClass, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.ObjectOutputStream void writeClassDescriptor(java.io.ObjectStreamClass) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -269,6 +352,9 @@ <item name="java.io.ObjectOutputStream void writeNonProxyDesc(java.io.ObjectStreamClass, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectOutputStream void writeObjectOverride(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.ObjectOutputStream void writeOrdinaryObject(java.lang.Object, java.io.ObjectStreamClass, boolean) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -278,6 +364,9 @@ <item name="java.io.ObjectOutputStream void writeSerialData(java.lang.Object, java.io.ObjectStreamClass) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.ObjectOutputStream void writeTypeString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.OutputStream void write(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -323,24 +412,54 @@ <item name="java.io.PrintStream PrintStream(java.io.OutputStream, boolean, java.lang.String) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.PrintStream PrintStream(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.PrintStream PrintStream(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.PrintStream PrintStream(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.io.PrintStream java.io.PrintStream append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.PrintStream java.io.PrintStream append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.PrintStream java.io.PrintStream append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.PrintStream java.io.PrintStream append(java.lang.CharSequence, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.PrintStream java.io.PrintStream append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.PrintStream java.io.PrintStream format(java.lang.String, java.lang.Object...)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="java.io.PrintStream java.io.PrintStream format(java.util.Locale, java.lang.String, java.lang.Object...)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.io.PrintStream void init(java.io.OutputStreamWriter) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.PrintStream void print(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.PrintStream void print(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.io.PrintStream void println(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.RandomAccessFile RandomAccessFile(java.io.File, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.RandomAccessFile RandomAccessFile(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.RandomAccessFile RandomAccessFile(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -377,9 +496,15 @@ <item name="java.io.Writer java.io.Writer append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.Writer java.io.Writer append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.Writer java.io.Writer append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.io.Writer java.io.Writer append(java.lang.CharSequence, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.io.Writer java.io.Writer append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/annotations.xml index 8d157485ada1..4862b313a917 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/annotations.xml @@ -29,9 +29,24 @@ <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.CharSequence, int, int)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> @@ -64,6 +79,18 @@ <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, char[], int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence, int, int)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -73,19 +100,37 @@ <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder replace(int, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.AbstractStringBuilder java.lang.AbstractStringBuilder reverse()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.AbstractStringBuilder java.lang.String substring(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.AssertionError AssertionError(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Boolean Boolean(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Boolean boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Boolean boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.lang.Boolean boolean parseBoolean(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Boolean boolean parseBoolean(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.lang.Boolean boolean toBoolean(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Boolean boolean toBoolean(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -97,6 +142,9 @@ <item name="java.lang.Boolean int compareTo(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Boolean java.lang.Boolean valueOf(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Boolean java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -106,6 +154,9 @@ <item name="java.lang.Byte Byte(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Byte boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Byte boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -147,6 +198,9 @@ <item name="java.lang.Byte java.lang.String toString(byte)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Character boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Character boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -196,6 +250,12 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="java.lang.Class boolean access$100(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Class boolean access$100(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class boolean access$202(boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""false->false;true->true""/> @@ -206,6 +266,12 @@ <val val=""false->false;true->true""/> </annotation> </item> + <item name="java.lang.Class boolean arrayContentsEq(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Class boolean arrayContentsEq(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class boolean isAnnotationPresent(java.lang.Class<? extends java.lang.annotation.Annotation>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -220,6 +286,9 @@ <item name="java.lang.Class java.lang.Class<? extends U> asSubclass(java.lang.Class<U>)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class java.lang.String argumentTypesToString(java.lang.Class[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class java.lang.String argumentTypesToString(java.lang.Class[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -234,6 +303,15 @@ <item name="java.lang.Class java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class java.lang.reflect.Constructor<T> getConstructor(java.lang.Class...) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Class java.lang.reflect.Constructor<T> getConstructor0(java.lang.Class[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Class java.lang.reflect.Constructor<T> getDeclaredConstructor(java.lang.Class...) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class java.lang.reflect.Constructor[] copyConstructors(java.lang.reflect.Constructor[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -255,9 +333,15 @@ <item name="java.lang.Class java.lang.reflect.Field[] copyFields(java.lang.reflect.Field[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class java.lang.reflect.Field[] privateGetPublicFields(java.util.Set) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class java.lang.reflect.Method getDeclaredMethod(java.lang.String, java.lang.Class...) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class java.lang.reflect.Method getDeclaredMethod(java.lang.String, java.lang.Class...) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class java.lang.reflect.Method getMethod(java.lang.String, java.lang.Class...) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -270,15 +354,27 @@ <item name="java.lang.Class java.lang.reflect.Method searchMethods(java.lang.reflect.Method[], java.lang.String, java.lang.Class[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class java.lang.reflect.Method searchMethods(java.lang.reflect.Method[], java.lang.String, java.lang.Class[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Class java.lang.reflect.Method[] copyMethods(java.lang.reflect.Method[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.Class void addAll(java.util.Collection, java.lang.reflect.Field[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Class void checkMemberAccess(int, java.lang.ClassLoader) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ClassLoader boolean compareCerts(java.security.cert.Certificate[], java.security.cert.Certificate[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ClassLoader boolean compareCerts(java.security.cert.Certificate[], java.security.cert.Certificate[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.ClassLoader boolean isAncestor(java.lang.ClassLoader) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ClassLoader boolean loadLibrary0(java.lang.Class, java.io.File)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false""/> @@ -287,6 +383,9 @@ <item name="java.lang.ClassLoader java.lang.Package definePackage(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.net.URL)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ClassLoader java.lang.String findLibrary(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ClassLoader java.lang.String findLibrary(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> @@ -295,11 +394,17 @@ <item name="java.lang.ClassLoader java.lang.String[] initializePath(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ClassLoader java.net.URL findResource(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ClassLoader java.net.URL findResource(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="java.lang.ClassLoader java.util.Enumeration findResources(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ClassLoader java.util.Enumeration findResources(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -318,6 +423,9 @@ <item name="java.lang.ClassLoader void setSigners(java.lang.Class, java.lang.Object[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Double boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Double boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -338,12 +446,18 @@ <item name="java.lang.Enum T valueOf(java.lang.Class<T>, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Enum boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Enum int compareTo(E) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.Enum int compareTo(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Float boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Float boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -364,6 +478,9 @@ <item name="java.lang.Integer Integer(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Integer boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Integer boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -434,6 +551,9 @@ <item name="java.lang.Long Long(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Long boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Long boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -498,15 +618,24 @@ <item name="java.lang.Long void getChars(long, int, char[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.NumberFormatException java.lang.NumberFormatException forInputString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.NumberFormatException java.lang.NumberFormatException forInputString(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Object boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Object java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.Short Short(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Short boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Short boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -605,6 +734,12 @@ <item name="java.lang.String boolean endsWith(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.String boolean equalsIgnoreCase(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.String boolean regionMatches(boolean, int, java.lang.String, int, int) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -662,6 +797,9 @@ <item name="java.lang.String java.lang.String copyValueOf(char[], int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String replace(char, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.String java.lang.String replace(java.lang.CharSequence, java.lang.CharSequence) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -674,15 +812,30 @@ <item name="java.lang.String java.lang.String substring(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String toLowerCase()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.String java.lang.String toLowerCase(java.util.Locale) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String toLowerCase(java.util.Locale)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.String java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String toUpperCase()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.String java.lang.String toUpperCase(java.util.Locale) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String toUpperCase(java.util.Locale)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="java.lang.String java.lang.String trim()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="java.lang.String java.lang.String valueOf(boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -704,6 +857,9 @@ <item name="java.lang.String java.lang.String valueOf(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String java.lang.String valueOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.String java.lang.String valueOf(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> @@ -715,6 +871,9 @@ <item name="java.lang.String void checkBounds(byte[], int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.String.CaseInsensitiveComparator CaseInsensitiveComparator(java.lang.String.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.String.CaseInsensitiveComparator int compare(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -763,18 +922,30 @@ <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -817,15 +988,24 @@ <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.AbstractStringBuilder insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -844,6 +1024,9 @@ <item name="java.lang.StringBuffer java.lang.Appendable append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.Appendable append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.Appendable append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -886,18 +1069,30 @@ <item name="java.lang.StringBuffer java.lang.StringBuffer append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -940,15 +1135,24 @@ <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.CharSequence) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuffer java.lang.StringBuffer insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1012,18 +1216,30 @@ <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1066,15 +1282,24 @@ <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.AbstractStringBuilder insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1093,6 +1318,9 @@ <item name="java.lang.StringBuilder java.lang.Appendable append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.Appendable append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.Appendable append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1126,21 +1354,36 @@ <item name="java.lang.StringBuilder java.lang.StringBuilder append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.CharSequence) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.StringBuilder) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder append(java.lang.StringBuilder)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1183,15 +1426,24 @@ <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.CharSequence) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.CharSequence)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.CharSequence, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.StringBuilder java.lang.StringBuilder insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1228,6 +1480,12 @@ <item name="java.lang.System void checkKey(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.System void setProperties(java.util.Properties) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.System void setSecurityManager0(java.lang.SecurityManager) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.System.2 sun.reflect.ConstantPool getConstantPool(java.lang.Class) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1246,12 +1504,24 @@ <item name="java.lang.Thread Thread(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.Runnable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Thread Thread(java.lang.ThreadGroup, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1261,12 +1531,18 @@ <item name="java.lang.Thread java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Thread void init(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Thread void init(java.lang.ThreadGroup, java.lang.Runnable, java.lang.String, long) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.Thread void setName(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ThreadLocal T childValue(T) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ThreadLocal int access$400(java.lang.ThreadLocal) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1291,6 +1567,9 @@ <item name="java.lang.ThreadLocal.ThreadLocalMap ThreadLocalMap(java.lang.ThreadLocal.ThreadLocalMap, java.lang.ThreadLocal.1) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ThreadLocal.ThreadLocalMap ThreadLocalMap(java.lang.ThreadLocal.ThreadLocalMap, java.lang.ThreadLocal.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ThreadLocal.ThreadLocalMap java.lang.ThreadLocal.ThreadLocalMap.Entry access$000(java.lang.ThreadLocal.ThreadLocalMap, java.lang.ThreadLocal) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1300,6 +1579,12 @@ <item name="java.lang.ThreadLocal.ThreadLocalMap java.lang.ThreadLocal.ThreadLocalMap.Entry getEntry(java.lang.ThreadLocal) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.ThreadLocal.ThreadLocalMap java.lang.ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(java.lang.ThreadLocal, int, java.lang.ThreadLocal.ThreadLocalMap.Entry) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.ThreadLocal.ThreadLocalMap java.lang.ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(java.lang.ThreadLocal, int, java.lang.ThreadLocal.ThreadLocalMap.Entry) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.ThreadLocal.ThreadLocalMap java.lang.ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(java.lang.ThreadLocal, int, java.lang.ThreadLocal.ThreadLocalMap.Entry)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->null""/> @@ -1329,6 +1614,9 @@ <item name="java.lang.Throwable void printEnclosedStackTrace(java.lang.Throwable.PrintStreamOrWriter, java.lang.StackTraceElement[], java.lang.String, java.lang.String, java.util.Set<java.lang.Throwable>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Throwable void printEnclosedStackTrace(java.lang.Throwable.PrintStreamOrWriter, java.lang.StackTraceElement[], java.lang.String, java.lang.String, java.util.Set<java.lang.Throwable>) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.Throwable void printEnclosedStackTrace(java.lang.Throwable.PrintStreamOrWriter, java.lang.StackTraceElement[], java.lang.String, java.lang.String, java.util.Set<java.lang.Throwable>) 4"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1344,4 +1632,7 @@ <item name="java.lang.Throwable void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.Throwable.PrintStreamOrWriter PrintStreamOrWriter(java.lang.Throwable.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/invoke/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/invoke/annotations.xml index f800dab8c906..42a07af318e1 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/invoke/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/lang/invoke/annotations.xml @@ -8,6 +8,15 @@ <item name="java.lang.invoke.AdapterMethodHandle AdapterMethodHandle(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, long, java.lang.invoke.AdapterMethodHandle.1) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.AdapterMethodHandle AdapterMethodHandle(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, long, java.lang.invoke.AdapterMethodHandle.1) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.AdapterMethodHandle boolean canBoxArgument(java.lang.Class<?>, java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.AdapterMethodHandle boolean canBoxArgument(java.lang.Class<?>, java.lang.Class<?>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.AdapterMethodHandle boolean canBoxArgument(java.lang.Class<?>, java.lang.Class<?>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->false;_,!null->false;_,null->false;null,_->false""/> @@ -75,6 +84,9 @@ <val val=""_,null,_,_->false;null,_,_,_->false""/> </annotation> </item> + <item name="java.lang.invoke.AdapterMethodHandle byte basicType(java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.AdapterMethodHandle int diffReturnTypes(java.lang.invoke.MethodType, java.lang.invoke.MethodType, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -87,9 +99,21 @@ <item name="java.lang.invoke.AdapterMethodHandle int diffTypes(java.lang.invoke.MethodType, java.lang.invoke.MethodType, boolean) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.AdapterMethodHandle int type2size(java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.AdapterMethodHandle java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.AdapterMethodHandle java.lang.invoke.MethodHandle makeBoxArgument(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, int, java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.AdapterMethodHandle java.lang.invoke.MethodHandle makeBoxArgument(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, int, java.lang.Class<?>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.AdapterMethodHandle java.lang.invoke.MethodHandle makeBoxArgument(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, int, java.lang.Class<?>) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.AdapterMethodHandle java.lang.invoke.MethodHandle makeBoxArgument(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, int, java.lang.Class<?>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->null;_,!null,_,_->null;_,_,_,!null->null;_,_,_,null->null;_,null,_,_->null;null,_,_,_->null""/> @@ -172,12 +196,18 @@ <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.DirectMethodHandle, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.DirectMethodHandle, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodHandle, java.lang.Object, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodHandle, java.lang.Object, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodType, java.lang.Object, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -187,9 +217,18 @@ <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, java.lang.Object, int) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.BoundMethodHandle BoundMethodHandle(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle, java.lang.Object, int) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.BoundMethodHandle java.lang.Object bindPrimitiveArgument(java.lang.Object, java.lang.invoke.MethodHandle, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.BoundMethodHandle java.lang.Object bindPrimitiveArgument(java.lang.Object, java.lang.invoke.MethodHandle, int) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.BoundMethodHandle java.lang.Object checkReferenceArgument(java.lang.Object, java.lang.invoke.MethodHandle, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.BoundMethodHandle java.lang.Object checkReferenceArgument(java.lang.Object, java.lang.invoke.MethodHandle, int) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -198,6 +237,9 @@ <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="java.lang.invoke.BoundMethodHandle java.lang.RuntimeException badBoundArgumentException(java.lang.Object, java.lang.invoke.MethodHandle, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.BoundMethodHandle java.lang.RuntimeException badBoundArgumentException(java.lang.Object, java.lang.invoke.MethodHandle, int) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -229,6 +271,12 @@ <item name="java.lang.invoke.CallSite java.lang.invoke.CallSite makeSite(java.lang.invoke.MethodHandle, java.lang.String, java.lang.invoke.MethodType, java.lang.Object, java.lang.invoke.MemberName, int) 4"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.CallSite java.lang.invoke.WrongMethodTypeException wrongTargetType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.CallSite java.lang.invoke.WrongMethodTypeException wrongTargetType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.CallSite java.lang.invoke.WrongMethodTypeException wrongTargetType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -238,12 +286,21 @@ <item name="java.lang.invoke.CallSite void checkTargetChange(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.CallSite void initializeFromJVM(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MemberName, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.CallSite void initializeFromJVM(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MemberName, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.CallSite void maybeReBoxElements(java.lang.Object[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.invoke.ConstantCallSite ConstantCallSite(java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.ConstantCallSite void setTarget(java.lang.invoke.MethodHandle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.DirectMethodHandle DirectMethodHandle(java.lang.invoke.MethodType, java.lang.invoke.MemberName, boolean, java.lang.Class<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -259,6 +316,12 @@ <item name="java.lang.invoke.FilterGeneric java.lang.invoke.FilterGeneric of(java.lang.invoke.FilterGeneric.Kind, int, java.lang.invoke.MethodType, java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.FilterGeneric java.lang.invoke.FilterGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType, java.lang.invoke.FilterGeneric.Kind, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.FilterGeneric java.lang.invoke.FilterGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType, java.lang.invoke.FilterGeneric.Kind, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.FilterGeneric java.lang.invoke.FilterGeneric.Adapter findAdapter(java.lang.invoke.MethodType, java.lang.invoke.FilterGeneric.Kind, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -323,6 +386,9 @@ <item name="java.lang.invoke.FilterGeneric.Adapter Adapter(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.FilterGeneric.Adapter java.lang.Class<? extends java.lang.invoke.FilterGeneric.Adapter> findSubClass(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.FilterGeneric.F0 F0(java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -578,6 +644,9 @@ <item name="java.lang.invoke.FilterGeneric.Kind java.lang.String invokerName(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.FilterOneArgument java.lang.invoke.MethodHandle make(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.FilterOneArgument java.lang.invoke.MethodHandle make(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;_,!null->!null""/> @@ -592,6 +661,9 @@ <item name="java.lang.invoke.FromGeneric java.lang.invoke.FromGeneric of(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.FromGeneric java.lang.invoke.FromGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.FromGeneric java.lang.invoke.FromGeneric.Adapter findAdapter(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -751,6 +823,9 @@ <item name="java.lang.invoke.FromGeneric.Adapter Adapter(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.FromGeneric.Adapter java.lang.Class<? extends java.lang.invoke.FromGeneric.Adapter> findSubClass(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.InvokeGeneric boolean returnConversionNeeded(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -762,6 +837,12 @@ <item name="java.lang.invoke.InvokeGeneric java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.InvokeGeneric java.lang.invoke.MethodHandle addReturnConversion(java.lang.invoke.MethodHandle, java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.InvokeGeneric java.lang.invoke.MethodHandle addReturnConversion(java.lang.invoke.MethodHandle, java.lang.Class<?>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.InvokeGeneric java.lang.invoke.MethodHandle dispatch(java.lang.invoke.MethodType, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -812,6 +893,12 @@ <item name="java.lang.invoke.MemberName int access$200(java.lang.invoke.MemberName) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MemberName java.lang.IllegalAccessException makeAccessException(java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MemberName java.lang.IllegalAccessException makeAccessException(java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MemberName java.lang.IllegalAccessException makeAccessException(java.lang.String, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -826,6 +913,9 @@ <val val=""_,!null->!null;_,null->null""/> </annotation> </item> + <item name="java.lang.invoke.MemberName java.lang.ReflectiveOperationException makeAccessException(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MemberName java.lang.ReflectiveOperationException makeAccessException(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -840,6 +930,9 @@ <val val=""_,!null->!null;_,null->null""/> </annotation> </item> + <item name="java.lang.invoke.MemberName java.lang.String getName(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MemberName java.lang.String getName(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> @@ -851,6 +944,9 @@ <item name="java.lang.invoke.MemberName.Factory java.lang.invoke.MemberName resolveOrNull(java.lang.invoke.MemberName, boolean, java.lang.Class<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MemberName.Factory java.util.List<java.lang.invoke.MemberName> getMembers(java.lang.Class<?>, java.lang.String, java.lang.Object, int, java.lang.Class<?>) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandle MethodHandle(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -878,6 +974,9 @@ <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle accessField(java.lang.invoke.MemberName, boolean, java.lang.Class<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle accessField(java.lang.invoke.MemberName, boolean, java.lang.Class<?>) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle accessField(java.lang.invoke.MemberName, boolean, java.lang.Class<?>)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -890,9 +989,18 @@ <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindArgument(java.lang.invoke.MethodHandle, int, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindArgument(java.lang.invoke.MethodHandle, int, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindArgument(java.lang.invoke.MethodHandle, int, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindReceiver(java.lang.invoke.MethodHandle, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindReceiver(java.lang.invoke.MethodHandle, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle bindReceiver(java.lang.invoke.MethodHandle, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> @@ -940,6 +1048,9 @@ <item name="java.lang.invoke.MethodHandleImpl java.lang.invoke.MethodHandle spreadArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleImpl sun.invoke.empty.Empty throwException(T) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleImpl.AllocateObject AllocateObject(java.lang.invoke.MethodHandle, java.lang.Class<C>, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1078,21 +1189,36 @@ <item name="java.lang.invoke.MethodHandleNatives void raiseException(int, java.lang.Object, java.lang.Object) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleNatives void raiseException(int, java.lang.Object, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.Error uncaughtException(java.lang.Exception)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalArgumentException(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalArgumentException(java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalArgumentException(java.lang.String, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalStateException(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalStateException(java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.RuntimeException newIllegalStateException(java.lang.String, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.String addTypeString(java.lang.Object, java.lang.invoke.MethodHandle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.String addTypeString(java.lang.Object, java.lang.invoke.MethodHandle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.String addTypeString(java.lang.Object, java.lang.invoke.MethodHandle)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;null,_->!null""/> @@ -1101,12 +1227,21 @@ <item name="java.lang.invoke.MethodHandleStatics java.lang.String getNameString(java.lang.invoke.MethodHandle)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.String getNameString(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.String getNameString(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.String getNameString(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.String getNameString(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandleStatics java.lang.String message(java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandleStatics java.lang.String message(java.lang.String, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;_,!null->!null""/> @@ -1127,6 +1262,9 @@ <item name="java.lang.invoke.MethodHandles boolean isObjectMethod(java.lang.reflect.Method) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandles boolean isWrapperInstance(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandles java.lang.Class<?> wrapperInstanceType(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1136,6 +1274,15 @@ <item name="java.lang.invoke.MethodHandles java.lang.Object callObjectMethod(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandles java.lang.RuntimeException misMatchedTypes(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MethodType) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MethodHandles java.lang.RuntimeException misMatchedTypes(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MethodType) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MethodHandles java.lang.RuntimeException misMatchedTypes(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MethodType) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandles java.lang.RuntimeException misMatchedTypes(java.lang.String, java.lang.invoke.MethodType, java.lang.invoke.MethodType)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1277,6 +1424,12 @@ <item name="java.lang.invoke.MethodHandles void checkReorder(int[], java.lang.invoke.MethodType, java.lang.invoke.MethodType) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodHandles.1 java.lang.Object getArg(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.MethodHandles.1 java.lang.Object invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodHandles.1 java.lang.Object invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1425,6 +1578,9 @@ <item name="java.lang.invoke.MethodType MethodType(java.lang.Class<?>, java.lang.Class<?>[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodType boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodType boolean equals(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1512,6 +1668,9 @@ <item name="java.lang.invoke.MethodTypeForm MethodTypeForm(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodTypeForm boolean hasTwoArgSlots(java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodTypeForm int[] primsAtEndOrder(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1529,6 +1688,9 @@ <item name="java.lang.invoke.MethodTypeForm java.lang.invoke.MethodType canonicalize(java.lang.invoke.MethodType, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.MethodTypeForm java.lang.invoke.MethodType reorderParameters(java.lang.invoke.MethodType, int[], java.lang.Class<?>[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.MethodTypeForm java.lang.invoke.MethodType reorderParameters(java.lang.invoke.MethodType, int[], java.lang.Class<?>[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> @@ -1572,6 +1734,12 @@ <item name="java.lang.invoke.SpreadGeneric java.lang.invoke.SpreadGeneric of(java.lang.invoke.MethodType, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.SpreadGeneric java.lang.invoke.SpreadGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType, int, java.lang.invoke.MethodHandle[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.lang.invoke.SpreadGeneric java.lang.invoke.SpreadGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType, int, java.lang.invoke.MethodHandle[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.SpreadGeneric java.lang.invoke.SpreadGeneric.Adapter findAdapter(java.lang.invoke.SpreadGeneric, java.lang.invoke.MethodHandle[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1583,6 +1751,9 @@ <item name="java.lang.invoke.SpreadGeneric.Adapter Adapter(java.lang.invoke.SpreadGeneric, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.SpreadGeneric.Adapter java.lang.Class<? extends java.lang.invoke.SpreadGeneric.Adapter> findSubClass(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.SpreadGeneric.S0 S0(java.lang.invoke.SpreadGeneric, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1719,6 +1890,9 @@ <item name="java.lang.invoke.ToGeneric java.lang.invoke.ToGeneric of(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.ToGeneric java.lang.invoke.ToGeneric.Adapter buildAdapterFromBytecodes(java.lang.invoke.MethodType) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.ToGeneric java.lang.invoke.ToGeneric.Adapter findAdapter(java.lang.invoke.MethodType) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1863,6 +2037,9 @@ <item name="java.lang.invoke.ToGeneric.Adapter Adapter(java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle, java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.lang.invoke.ToGeneric.Adapter java.lang.Class<? extends java.lang.invoke.ToGeneric.Adapter> findSubClass(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.lang.invoke.VolatileCallSite VolatileCallSite(java.lang.invoke.MethodHandle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/net/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/net/annotations.xml index 6c410bc4ed65..be6006068f41 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/net/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/net/annotations.xml @@ -38,6 +38,9 @@ <item name="java.net.DatagramSocket DatagramSocket(java.net.DatagramSocketImpl) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.DatagramSocket DatagramSocket(java.net.SocketAddress) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.DatagramSocket void connect(java.net.InetAddress, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -53,6 +56,12 @@ <item name="java.net.DatagramSocket void send(java.net.DatagramPacket) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.DatagramSocket void setDatagramSocketImplFactory(java.net.DatagramSocketImplFactory) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.InetAddress boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.InetAddress boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -90,6 +99,12 @@ <item name="java.net.InetAddress java.net.InetAddress getByAddress(java.lang.String, byte[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.InetAddress java.net.InetAddress getByName(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.InetAddress java.net.InetAddress[] getAllByName(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.InetAddress java.net.InetAddress[] getAllByName(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> @@ -121,24 +136,138 @@ <item name="java.net.ServerSocket void implAccept(java.net.Socket) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.ServerSocket void setSocketFactory(java.net.SocketImplFactory) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.lang.String, int, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.lang.String, int, java.net.InetAddress, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.net.InetAddress, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.net.InetAddress, int, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.Socket Socket(java.net.InetAddress, int, java.net.InetAddress, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.Socket Socket(java.net.SocketAddress, java.net.SocketAddress, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.net.Socket java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.Socket void bind(java.net.SocketAddress) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.Socket void connect(java.net.SocketAddress, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.Socket void setSocketImplFactory(java.net.SocketImplFactory) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 5"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 6"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI URI(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI boolean equal(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI boolean equal(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI boolean equalIgnoringCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI boolean equalIgnoringCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI int access$2502(java.net.URI, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URI int compare(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI int compare(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI int compareIgnoringCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI int compareIgnoringCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI int compareTo(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.net.URI int compareTo(java.net.URI) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URI int hash(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI int hashIgnoringCase(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI int join(char[], int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -255,6 +384,30 @@ <item name="java.net.URI java.lang.String resolvePath(java.lang.String, java.lang.String, boolean) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 6"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 7"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String) 8"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI java.lang.String toString(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -303,9 +456,45 @@ <item name="java.net.URI long lowMask(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URI void appendAuthority(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendAuthority(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, int) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendAuthority(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, int) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI void appendEscape(java.lang.StringBuffer, byte) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URI void appendFragment(java.lang.StringBuffer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 6"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void appendSchemeSpecificPart(java.lang.StringBuffer, java.lang.String, java.lang.String, java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 7"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void checkPath(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URI void checkPath(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URI void maybeAddLeadingDot(char[], int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -345,6 +534,9 @@ <item name="java.net.URL URL(java.net.URL, java.lang.String, java.net.URLStreamHandler) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URL boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URL boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -368,6 +560,9 @@ <item name="java.net.URL void set(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String) 3"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URL void setURLStreamHandlerFactory(java.net.URLStreamHandlerFactory) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URL void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -380,11 +575,17 @@ <item name="java.net.URLConnection java.lang.String getContentHandlerPkgPrefixes()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URLConnection java.lang.String getDefaultRequestProperty(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URLConnection java.lang.String getDefaultRequestProperty(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="java.net.URLConnection java.lang.String getHeaderField(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URLConnection java.lang.String getHeaderField(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> @@ -393,6 +594,9 @@ <item name="java.net.URLConnection java.lang.String guessContentTypeFromStream(java.io.InputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URLConnection java.lang.String stripOffParameters(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URLConnection java.lang.String stripOffParameters(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -416,6 +620,18 @@ <item name="java.net.URLConnection void addRequestProperty(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.net.URLConnection void setContentHandlerFactory(java.net.ContentHandlerFactory) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URLConnection void setDefaultRequestProperty(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URLConnection void setDefaultRequestProperty(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.net.URLConnection void setFileNameMap(java.net.FileNameMap) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.net.URLConnection void setRequestProperty(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/security/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/security/annotations.xml index 756cbfcdd13e..597b80fe0d3f 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/security/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/security/annotations.xml @@ -1,4 +1,7 @@ <root> + <item name="java.security.Identity boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Identity boolean identityEquals(java.security.Identity) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -22,11 +25,17 @@ <item name="java.security.Identity void addCertificate(java.security.Certificate) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Policy java.security.PermissionCollection getPermissions(java.security.ProtectionDomain) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Policy java.security.PermissionCollection getPermissions(java.security.ProtectionDomain)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> </annotation> </item> + <item name="java.security.Policy void addStaticPerms(java.security.PermissionCollection, java.security.PermissionCollection) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Policy void initPolicy(java.security.Policy) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -45,6 +54,9 @@ <item name="java.security.Provider void implPutAll(java.util.Map) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Provider void implRemoveService(java.security.Provider.Service) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Provider void parseLegacyPut(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -72,6 +84,15 @@ <item name="java.security.Security boolean isCriterionSatisfied(java.security.Provider, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Security boolean isCriterionSatisfied(java.security.Provider, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security boolean isCriterionSatisfied(java.security.Provider, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security boolean isCriterionSatisfied(java.security.Provider, java.lang.String, java.lang.String, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Security boolean isStandardAttr(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -81,9 +102,24 @@ <item name="java.security.Security int insertProviderAt(java.security.Provider, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Security java.io.File securityPropFile(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Security java.io.File securityPropFile(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Security java.lang.Object[] getImpl(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security java.lang.Object[] getImpl(java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security java.lang.String getAlgorithmProperty(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security java.lang.String getAlgorithmProperty(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Security java.lang.String getProviderProperty(java.lang.String, java.security.Provider) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -111,9 +147,21 @@ <item name="java.security.Security java.util.LinkedHashSet getAllQualifyingCandidates(java.lang.String, java.lang.String, java.security.Provider[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Security java.util.LinkedHashSet getProvidersNotUsingCache(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.security.Provider[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security java.util.LinkedHashSet getProvidersNotUsingCache(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.security.Provider[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.security.Security java.util.LinkedHashSet getProvidersNotUsingCache(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.security.Provider[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Security java.util.LinkedHashSet getProvidersNotUsingCache(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.security.Provider[]) 4"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.security.Security java.util.Set getAlgorithms(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.security.Security void invalidateSMCache(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/sql/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/sql/annotations.xml index 2aaa71e67f39..1938616b2fff 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/sql/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/sql/annotations.xml @@ -1,10 +1,37 @@ <root> + <item name="java.sql.BatchUpdateException BatchUpdateException(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(int[], java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, int[], java.lang.Throwable) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, java.lang.String, int, int[]) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, java.lang.String, int, int[], java.lang.Throwable) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, java.lang.String, int[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.BatchUpdateException BatchUpdateException(java.lang.String, java.lang.String, int[], java.lang.Throwable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.Date java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.sql.Date java.sql.Date valueOf(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.DriverInfo boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.DriverInfo boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -13,11 +40,20 @@ <item name="java.sql.DriverInfo java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.DriverManager boolean isDriverAllowed(java.sql.Driver, java.lang.Class<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.DriverManager boolean isDriverAllowed(java.sql.Driver, java.lang.Class<?>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.DriverManager boolean isDriverAllowed(java.sql.Driver, java.lang.Class<?>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->false""/> </annotation> </item> + <item name="java.sql.DriverManager boolean isDriverAllowed(java.sql.Driver, java.lang.ClassLoader) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.DriverManager boolean isDriverAllowed(java.sql.Driver, java.lang.ClassLoader)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->false""/> @@ -29,15 +65,30 @@ <item name="java.sql.DriverManager java.sql.Connection getConnection(java.lang.String, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.DriverManager java.sql.Connection getConnection(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.DriverManager java.sql.Connection getConnection(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.DriverManager java.sql.Connection getConnection(java.lang.String, java.util.Properties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.sql.DriverManager java.sql.Connection getConnection(java.lang.String, java.util.Properties, java.lang.Class<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.DriverManager void deregisterDriver(java.sql.Driver) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.DriverManager void registerDriver(java.sql.Driver) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.DriverManager void setLogStream(java.io.PrintStream) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.sql.DriverManager void setLogWriter(java.io.PrintWriter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.SQLException java.util.Iterator<java.lang.Throwable> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -50,6 +101,9 @@ <item name="java.sql.Time java.sql.Time valueOf(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.sql.Timestamp boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.sql.Timestamp boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/annotations.xml index 363b81c827b4..5e73e2012e79 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/annotations.xml @@ -2,15 +2,27 @@ <item name="java.util.AbstractCollection T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractCollection boolean add(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractCollection boolean addAll(java.util.Collection<? extends E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractCollection boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractCollection boolean containsAll(java.util.Collection<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractCollection boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractCollection java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractList E set(int, E) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractList boolean add(E)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->true;null->true""/> @@ -19,6 +31,15 @@ <item name="java.util.AbstractList boolean addAll(int, java.util.Collection<? extends E>) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractList boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractList int indexOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractList int lastIndexOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractList java.lang.String outOfBoundsMsg(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -31,6 +52,33 @@ <item name="java.util.AbstractList java.util.ListIterator<E> listIterator(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractList void add(int, E) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractList.Itr Itr(java.util.AbstractList, java.util.AbstractList.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap V get(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap V put(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap V put(K, V) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap V remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractMap java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -46,6 +94,12 @@ <item name="java.util.AbstractMap.SimpleEntry SimpleEntry(java.util.Map.Entry<K,V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractMap.SimpleEntry boolean eq(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.AbstractMap.SimpleEntry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractMap.SimpleEntry boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -65,6 +119,9 @@ <item name="java.util.AbstractSequentialList boolean addAll(int, java.util.Collection<? extends E>) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.AbstractSet boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.AbstractSet boolean removeAll(java.util.Collection<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -85,6 +142,15 @@ <item name="java.util.ArrayList boolean addAll(java.util.Collection<? extends E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.ArrayList boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.ArrayList int indexOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.ArrayList int lastIndexOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.ArrayList java.lang.Object[] toArray()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -97,9 +163,72 @@ <item name="java.util.Arrays T[] cloneSubarray(T[], int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays boolean deepEquals(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean deepEquals(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(boolean[], boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(boolean[], boolean[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(byte[], byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(byte[], byte[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(char[], char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(char[], char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(double[], double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(double[], double[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(float[], float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(float[], float[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(int[], int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(int[], int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(long[], long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(long[], long[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(short[], short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays boolean equals(short[], short[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays int binarySearch(T[], T, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays int binarySearch(T[], T, java.util.Comparator<? super T>) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays int binarySearch(byte[], byte) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -124,6 +253,36 @@ <item name="java.util.Arrays int binarySearch(short[], short) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays int deepHashCode(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Arrays int hashCode(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays int med3(byte[], int, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -145,33 +304,63 @@ <item name="java.util.Arrays int med3(short[], int, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String deepToString(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String deepToString(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(boolean[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(byte[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(char[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(double[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(float[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(int[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(long[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays java.lang.String toString(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays java.lang.String toString(short[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -181,6 +370,9 @@ <item name="java.util.Arrays java.util.List<T> asList(T...)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays void deepToString(java.lang.Object[], java.lang.StringBuilder, java.util.Set<java.lang.Object[]>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays void deepToString(java.lang.Object[], java.lang.StringBuilder, java.util.Set<java.lang.Object[]>) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -241,9 +433,15 @@ <item name="java.util.Arrays void sort(T[], int, int, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays void sort(T[], int, int, java.util.Comparator<? super T>) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays void sort(T[], java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays void sort(T[], java.util.Comparator<? super T>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Arrays void sort(byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -319,16 +517,28 @@ <item name="java.util.Arrays.ArrayList ArrayList(E[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Arrays.ArrayList int indexOf(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Calendar boolean after(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Calendar boolean after(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.Calendar boolean before(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Calendar boolean before(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.Calendar boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Calendar java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -377,12 +587,18 @@ <item name="java.util.Collections T max(java.util.Collection<? extends T>, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections T max(java.util.Collection<? extends T>, java.util.Comparator<? super T>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections T min(java.util.Collection<? extends T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections T min(java.util.Collection<? extends T>, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections T min(java.util.Collection<? extends T>, java.util.Comparator<? super T>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections boolean addAll(java.util.Collection<? super T>, T...) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -392,18 +608,30 @@ <item name="java.util.Collections boolean disjoint(java.util.Collection<?>, java.util.Collection<?>) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections boolean eq(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections boolean replaceAll(java.util.List<T>, T, T) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections boolean replaceAll(java.util.List<T>, T, T) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections int binarySearch(java.util.List<? extends T>, T, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections int binarySearch(java.util.List<? extends T>, T, java.util.Comparator<? super T>) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections int binarySearch(java.util.List<? extends java.lang.Comparable<? super T>>, T) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections int frequency(java.util.Collection<?>, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections int frequency(java.util.Collection<?>, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections int indexOfSubList(java.util.List<?>, java.util.List<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -455,6 +683,9 @@ <item name="java.util.Collections java.util.Collection<T> unmodifiableCollection(java.util.Collection<? extends T>)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections java.util.Comparator<T> reverseOrder(java.util.Comparator<T>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections java.util.Enumeration<T> enumeration(java.util.Collection<T>)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -632,6 +863,9 @@ <item name="java.util.Collections void sort(java.util.List<T>, java.util.Comparator<? super T>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections void sort(java.util.List<T>, java.util.Comparator<? super T>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections void swap(java.lang.Object[], int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -664,6 +898,9 @@ <item name="java.util.Collections.CheckedCollection java.util.Iterator<E> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CheckedCollection void typeCheck(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CheckedList CheckedList(java.util.List<E>, java.lang.Class<E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -700,9 +937,21 @@ <item name="java.util.Collections.CheckedMap void putAll(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CheckedMap void typeCheck(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CheckedMap.CheckedEntrySet T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean add(java.util.Map.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean addAll(java.util.Collection<? extends java.util.Map.Entry<K,V>>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -711,6 +960,12 @@ <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean containsAll(java.util.Collection<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CheckedMap.CheckedEntrySet boolean remove(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -725,6 +980,9 @@ <item name="java.util.Collections.CheckedMap.CheckedEntrySet.1 java.util.Map.Entry<K,V> next()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CheckedMap.CheckedEntrySet.CheckedEntry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CheckedMap.CheckedEntrySet.CheckedEntry java.lang.String badValueMsg(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -782,12 +1040,21 @@ <item name="java.util.Collections.CopiesList T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.CopiesList boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.CopiesList java.lang.Object[] toArray()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections.CopiesList java.util.List<E> subList(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.EmptyIterator EmptyIterator(java.util.Collections.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.EmptyList EmptyList(java.util.Collections.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyList T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -796,6 +1063,9 @@ <val val=""!null->!null""/> </annotation> </item> + <item name="java.util.Collections.EmptyList boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyList boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -804,6 +1074,9 @@ <item name="java.util.Collections.EmptyList boolean containsAll(java.util.Collection<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.EmptyList boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyList boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -812,26 +1085,50 @@ <item name="java.util.Collections.EmptyList java.lang.Object[] toArray()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.EmptyListIterator void add(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.EmptyListIterator void set(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.EmptyMap EmptyMap(java.util.Collections.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.EmptyMap V get(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyMap V get(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="java.util.Collections.EmptyMap boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyMap boolean containsKey(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> </annotation> </item> + <item name="java.util.Collections.EmptyMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyMap boolean containsValue(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> </annotation> </item> + <item name="java.util.Collections.EmptyMap boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptyMap boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.Collections.EmptySet EmptySet(java.util.Collections.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptySet T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -840,6 +1137,9 @@ <val val=""!null->!null""/> </annotation> </item> + <item name="java.util.Collections.EmptySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.EmptySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -854,15 +1154,33 @@ <item name="java.util.Collections.ReverseComparator int compare(java.lang.Comparable<java.lang.Object>, java.lang.Comparable<java.lang.Object>) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.ReverseComparator2 boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.SetFromMap SetFromMap(java.util.Map<E,java.lang.Boolean>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections.SetFromMap void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.SingletonList boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.SingletonList java.util.Iterator<E> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.SingletonMap V get(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.SingletonMap boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.SingletonMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.SingletonSet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.SingletonSet java.util.Iterator<E> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -926,12 +1244,33 @@ <item name="java.util.Collections.UnmodifiableCollection UnmodifiableCollection(java.util.Collection<? extends E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableCollection boolean add(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableCollection boolean addAll(java.util.Collection<? extends E>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableCollection boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableCollection boolean removeAll(java.util.Collection<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableCollection boolean retainAll(java.util.Collection<?>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableCollection java.util.Iterator<E> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableList E set(int, E) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableList UnmodifiableList(java.util.List<? extends E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableList boolean addAll(int, java.util.Collection<? extends E>) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableList java.lang.Object readResolve()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -941,15 +1280,39 @@ <item name="java.util.Collections.UnmodifiableList java.util.ListIterator<E> listIterator(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableList void add(int, E) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableList.1 void add(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableList.1 void set(E) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableMap UnmodifiableMap(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableMap V put(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableMap V put(K, V) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableMap V remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableMap void putAll(java.util.Map<? extends K,? extends V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet UnmodifiableEntrySet(java.util.Set<? extends java.util.Map.Entry<? extends K,? extends V>>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -958,12 +1321,21 @@ <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet boolean containsAll(java.util.Collection<?>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet java.util.Iterator<java.util.Map.Entry<K,V>> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet.1 java.util.Map.Entry<K,V> next()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet.UnmodifiableEntry V setValue(V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet.UnmodifiableEntry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Collections.UnmodifiableRandomAccessList UnmodifiableRandomAccessList(java.util.List<? extends E>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1009,6 +1381,9 @@ <item name="java.util.Date boolean before(java.util.Date) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Date boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Date boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -1026,6 +1401,9 @@ <item name="java.util.Date void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.GregorianCalendar boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.GregorianCalendar boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -1052,6 +1430,9 @@ <item name="java.util.HashMap HashMap(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.HashMap T maskNull(T) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.HashMap T maskNull(T)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> @@ -1062,6 +1443,18 @@ <val val=""null->null""/> </annotation> </item> + <item name="java.util.HashMap V get(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.HashMap V put(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.HashMap boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.HashMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.HashMap boolean eq(java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->true""/> @@ -1070,6 +1463,15 @@ <item name="java.util.HashMap int hash(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.HashMap java.util.HashMap.Entry<K,V> getEntry(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.HashMap java.util.HashMap.Entry<K,V> removeEntryForKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.HashMap java.util.HashMap.Entry<K,V> removeMapping(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.HashMap java.util.HashMap.Entry<K,V> removeMapping(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -1090,6 +1492,9 @@ <item name="java.util.HashMap void putAllForCreate(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.HashMap void putForCreate(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.HashMap void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1120,6 +1525,9 @@ <item name="java.util.Hashtable boolean containsKey(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Hashtable boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Hashtable int access$200(java.util.Hashtable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1162,6 +1570,9 @@ <item name="java.util.Hashtable.Entry V setValue(V) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Hashtable.Entry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Hashtable.Entry boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -1173,25 +1584,82 @@ <item name="java.util.Hashtable.Entry java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Hashtable.EntrySet EntrySet(java.util.Hashtable, java.util.Hashtable.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Hashtable.EntrySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Hashtable.EntrySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.Hashtable.EntrySet boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Hashtable.EntrySet boolean remove(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.Hashtable.KeySet KeySet(java.util.Hashtable, java.util.Hashtable.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Hashtable.ValueCollection ValueCollection(java.util.Hashtable, java.util.Hashtable.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap IdentityHashMap(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap V get(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap V put(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap V remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap boolean access$1500(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap boolean access$1500(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean access$1500(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap boolean access$1600(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap boolean access$1600(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean access$1600(java.util.IdentityHashMap, java.lang.Object, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean containsMapping(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean containsMapping(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean removeMapping(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap boolean removeMapping(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap int access$000(java.util.IdentityHashMap) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1209,6 +1677,9 @@ <val val=""null->null""/> </annotation> </item> + <item name="java.util.IdentityHashMap java.lang.Object maskNull(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap java.lang.Object maskNull(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> @@ -1225,12 +1696,24 @@ <item name="java.util.IdentityHashMap void putAll(java.util.Map<? extends K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap void putForCreate(K, V) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.IdentityHashMap void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap.EntryIterator EntryIterator(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.EntryIterator.Entry Entry(java.util.IdentityHashMap.EntryIterator, int, java.util.IdentityHashMap.1) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.EntryIterator.Entry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.EntryIterator.Entry int access$800(java.util.IdentityHashMap.EntryIterator.Entry) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1240,14 +1723,23 @@ <item name="java.util.IdentityHashMap.EntryIterator.Entry java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap.EntrySet EntrySet(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.EntrySet T[] toArray(T[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap.EntrySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.EntrySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="java.util.IdentityHashMap.EntrySet boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.EntrySet boolean remove(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -1256,9 +1748,27 @@ <item name="java.util.IdentityHashMap.EntrySet java.util.Iterator<java.util.Map.Entry<K,V>> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap.IdentityHashMapIterator IdentityHashMapIterator(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.KeyIterator KeyIterator(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.KeySet KeySet(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.KeySet java.util.Iterator<K> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.IdentityHashMap.ValueIterator ValueIterator(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.Values Values(java.util.IdentityHashMap, java.util.IdentityHashMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.IdentityHashMap.Values boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.IdentityHashMap.Values java.util.Iterator<V> iterator()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1280,12 +1790,21 @@ <item name="java.util.Locale Locale(java.lang.String, java.lang.String, java.lang.String) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Locale boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Locale java.lang.String convertOldISOCodes(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="java.util.Locale java.lang.String formatList(java.lang.String[], java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Locale java.lang.String formatList(java.lang.String[], java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.Locale java.lang.String formatList(java.lang.String[], java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Locale java.lang.String formatList(java.lang.String[], java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->!null;_,null,_->!null""/> @@ -1335,6 +1854,9 @@ <item name="java.util.Locale java.lang.String[] composeList(java.text.MessageFormat, java.lang.String[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.Locale java.lang.String[] getDisplayVariantArray(sun.util.resources.OpenListResourceBundle, java.util.Locale) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.Locale java.lang.String[] getISO2Table(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1422,11 +1944,23 @@ <item name="java.util.TreeMap TreeMap(java.util.SortedMap<K,? extends V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.TreeMap boolean access$500(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.TreeMap boolean colorOf(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap boolean colorOf(java.util.TreeMap.Entry<K,V>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="java.util.TreeMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.TreeMap boolean valEquals(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap boolean valueSearchNonNull(java.util.TreeMap.Entry, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1475,6 +2009,9 @@ <item name="java.util.TreeMap java.util.TreeMap.Entry access$400(java.util.TreeMap, java.util.TreeMap.Entry) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.TreeMap java.util.TreeMap.Entry access$400(java.util.TreeMap, java.util.TreeMap.Entry) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap java.util.TreeMap.Entry access$400(java.util.TreeMap, java.util.TreeMap.Entry)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->null""/> @@ -1483,21 +2020,33 @@ <item name="java.util.TreeMap java.util.TreeMap.Entry access$800(java.util.TreeMap, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> leftOf(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> leftOf(java.util.TreeMap.Entry<K,V>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> parentOf(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> parentOf(java.util.TreeMap.Entry<K,V>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> rightOf(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> rightOf(java.util.TreeMap.Entry<K,V>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> successor(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap java.util.TreeMap.Entry<K,V> successor(java.util.TreeMap.Entry<K,V>)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -1512,6 +2061,9 @@ <item name="java.util.TreeMap void deleteEntry(java.util.TreeMap.Entry<K,V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.TreeMap void fixAfterDeletion(java.util.TreeMap.Entry<K,V>) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap void fixAfterInsertion(java.util.TreeMap.Entry<K,V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1527,6 +2079,9 @@ <item name="java.util.TreeMap void rotateRight(java.util.TreeMap.Entry<K,V>) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.TreeMap void setColor(java.util.TreeMap.Entry<K,V>, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.TreeMap void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/atomic/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/atomic/annotations.xml index def395c4cf42..30e85d4f3ee8 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/atomic/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/atomic/annotations.xml @@ -59,6 +59,12 @@ <item name="java.util.concurrent.atomic.AtomicMarkableReference V get(boolean[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.atomic.AtomicMarkableReference boolean compareAndSet(V, V, boolean, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.concurrent.atomic.AtomicMarkableReference boolean weakCompareAndSet(V, V, boolean, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.atomic.AtomicMarkableReference.ReferenceBooleanPair boolean access$100(java.util.concurrent.atomic.AtomicMarkableReference.ReferenceBooleanPair) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -86,9 +92,18 @@ <item name="java.util.concurrent.atomic.AtomicReferenceFieldUpdater.AtomicReferenceFieldUpdaterImpl AtomicReferenceFieldUpdaterImpl(java.lang.Class<T>, java.lang.Class<V>, java.lang.String) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.atomic.AtomicReferenceFieldUpdater.AtomicReferenceFieldUpdaterImpl void updateCheck(T, V) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.atomic.AtomicStampedReference V get(int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.atomic.AtomicStampedReference boolean compareAndSet(V, V, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="java.util.concurrent.atomic.AtomicStampedReference boolean weakCompareAndSet(V, V, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.atomic.AtomicStampedReference.ReferenceIntegerPair int access$100(java.util.concurrent.atomic.AtomicStampedReference.ReferenceIntegerPair) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/locks/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/locks/annotations.xml index a5aef3c11bb8..08c07b4d957f 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/locks/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/java/util/concurrent/locks/annotations.xml @@ -2,6 +2,9 @@ <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer boolean acquireQueued(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer boolean findNodeFromTail(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer boolean hasWaiters(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -35,6 +38,9 @@ <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer java.util.concurrent.locks.AbstractQueuedSynchronizer.Node enq(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer void cancelAcquire(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer void setHead(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -50,6 +56,9 @@ <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject boolean awaitUntil(java.util.Date) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject boolean isOwnedBy(java.util.concurrent.locks.AbstractQueuedSynchronizer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject java.util.concurrent.locks.AbstractQueuedSynchronizer.Node addConditionWaiter()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -59,6 +68,9 @@ <item name="java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject void doSignalAll(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="java.util.concurrent.locks.LockSupport void unpark(java.lang.Thread) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="java.util.concurrent.locks.ReentrantLock boolean hasWaiters(java.util.concurrent.locks.Condition) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/javax/swing/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/javax/swing/annotations.xml index c0738eb8897d..910842a47153 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/javax/swing/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/javax/swing/annotations.xml @@ -1,4 +1,10 @@ <root> + <item name="javax.swing.AbstractButton boolean isListener(java.lang.Class, java.awt.event.ActionListener) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton boolean isListener(java.lang.Class, java.awt.event.ActionListener) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.AbstractButton java.beans.PropertyChangeListener createActionPropertyChangeListener(javax.swing.Action)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -11,6 +17,24 @@ <item name="javax.swing.AbstractButton void access$100(javax.swing.AbstractButton) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.AbstractButton void configurePropertiesFromAction(javax.swing.Action, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton void configurePropertiesFromAction(javax.swing.Action, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton void init(java.lang.String, javax.swing.Icon) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton void init(java.lang.String, javax.swing.Icon) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton void setUIProperty(java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.AbstractButton void updateDisplayedMnemonicIndex(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JButton java.lang.String getUIClassID()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -39,6 +63,9 @@ <item name="javax.swing.JComponent byte getWriteObjCounter(javax.swing.JComponent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent java.awt.Dimension getSize(java.awt.Dimension) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.awt.Dimension getSize(java.awt.Dimension)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> @@ -49,21 +76,36 @@ <val val=""!null->!null;null->!null""/> </annotation> </item> + <item name="javax.swing.JComponent java.awt.Insets getInsets(java.awt.Insets) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JComponent java.awt.Point getLocation(java.awt.Point) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.awt.Point getLocation(java.awt.Point)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> </annotation> </item> + <item name="javax.swing.JComponent java.awt.Point getPopupLocation(java.awt.event.MouseEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.awt.Point getPopupLocation(java.awt.event.MouseEvent)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="javax.swing.JComponent java.awt.Point getToolTipLocation(java.awt.event.MouseEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.awt.Point getToolTipLocation(java.awt.event.MouseEvent)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="javax.swing.JComponent java.awt.Rectangle getBounds(java.awt.Rectangle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.awt.Rectangle getBounds(java.awt.Rectangle)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> @@ -72,6 +114,9 @@ <item name="javax.swing.JComponent java.awt.Rectangle getVisibleRect()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent java.lang.String getToolTipText(java.awt.event.MouseEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent java.lang.String getUIClassID()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -81,6 +126,9 @@ <item name="javax.swing.JComponent javax.swing.JToolTip createToolTip()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent void componentInputMapChanged(javax.swing.ComponentInputMap) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent void computeVisibleRect(java.awt.Component, java.awt.Rectangle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -99,21 +147,33 @@ <item name="javax.swing.JComponent void paintWithOffscreenBuffer(javax.swing.JComponent, java.awt.Graphics, int, int, int, int, java.awt.Image) 6"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent void processComponentKeyEvent(java.awt.event.KeyEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent void processKeyEvent(java.awt.event.KeyEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.JComponent void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent void registerNextFocusableComponent(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent void repaint(java.awt.Rectangle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent void setUIProperty(java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent void setWriteObjCounter(javax.swing.JComponent, byte) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.JComponent void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JComponent.AccessibleJComponent java.lang.String getBorderTitle(javax.swing.border.Border) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JComponent.AccessibleJComponent java.lang.String getBorderTitle(javax.swing.border.Border)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -125,6 +185,21 @@ <item name="javax.swing.JComponent.AccessibleJComponent javax.swing.JComponent access$100(javax.swing.JComponent.AccessibleJComponent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JDialog JDialog(java.awt.Frame) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JDialog JDialog(java.awt.Frame, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JDialog JDialog(java.awt.Frame, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JDialog JDialog(java.awt.Frame, java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JDialog JDialog(java.awt.Frame, java.lang.String, boolean, java.awt.GraphicsConfiguration) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JDialog java.lang.String paramString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -161,6 +236,12 @@ <item name="javax.swing.JPanel void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JScrollPane JScrollPane(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JScrollPane JScrollPane(java.awt.Component, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JScrollPane java.awt.Component getCorner(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -188,6 +269,24 @@ <item name="javax.swing.JScrollPane void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel, javax.swing.ListSelectionModel) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel, javax.swing.ListSelectionModel) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable JTable(javax.swing.table.TableModel, javax.swing.table.TableColumnModel, javax.swing.ListSelectionModel) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable boolean print(int, java.text.MessageFormat, java.text.MessageFormat, boolean, javax.print.attribute.PrintRequestAttributeSet)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,_,false,_->true""/> @@ -199,9 +298,15 @@ <item name="javax.swing.JTable int getScrollableBlockIncrement(java.awt.Rectangle, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable int getScrollableUnitIncrement(java.awt.Rectangle, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable int rowAtPoint(java.awt.Point) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable int viewIndexForColumn(javax.swing.table.TableColumn) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable int[] getSelectedRows()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -226,6 +331,9 @@ <item name="javax.swing.JTable java.lang.String paramString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable javax.swing.JScrollPane createScrollPaneForTable(javax.swing.JTable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable javax.swing.JScrollPane createScrollPaneForTable(javax.swing.JTable)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -235,11 +343,17 @@ <item name="javax.swing.JTable javax.swing.table.JTableHeader createDefaultTableHeader()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable javax.swing.table.TableCellEditor getDefaultEditor(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable javax.swing.table.TableCellEditor getDefaultEditor(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="javax.swing.JTable javax.swing.table.TableCellRenderer getDefaultRenderer(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable javax.swing.table.TableCellRenderer getDefaultRenderer(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -263,15 +377,39 @@ <item name="javax.swing.JTable void changeSelectionModel(javax.swing.ListSelectionModel, int, boolean, boolean, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable void columnAdded(javax.swing.event.TableColumnModelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void columnMarginChanged(javax.swing.event.ChangeEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void columnMoved(javax.swing.event.TableColumnModelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void columnRemoved(javax.swing.event.TableColumnModelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable void columnSelectionChanged(javax.swing.event.ListSelectionEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable void editingCanceled(javax.swing.event.ChangeEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void editingStopped(javax.swing.event.ChangeEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable void readObject(java.io.ObjectInputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.JTable void setColumnModel(javax.swing.table.TableColumnModel) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable void setDefaultEditor(java.lang.Class, javax.swing.table.TableCellEditor) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void setDefaultRenderer(java.lang.Class, javax.swing.table.TableCellRenderer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable void setGridColor(java.awt.Color) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -293,18 +431,36 @@ <item name="javax.swing.JTable void setSelectionModel(javax.swing.ListSelectionModel) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable void setUIProperty(java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.JTable void tableChanged(javax.swing.event.TableModelEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable void tableRowsDeleted(javax.swing.event.TableModelEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.JTable void tableRowsInserted(javax.swing.event.TableModelEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.JTable void updateSubComponentUI(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.JTable void valueChanged(javax.swing.event.ListSelectionEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.JTable void writeObject(java.io.ObjectOutputStream) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities boolean doesIconReferenceImage(javax.swing.Icon, java.awt.Image) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities boolean doesIconReferenceImage(javax.swing.Icon, java.awt.Image) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities boolean isDescendingFrom(java.awt.Component, java.awt.Component) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities boolean isDescendingFrom(java.awt.Component, java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->true""/> @@ -331,11 +487,20 @@ <item name="javax.swing.SwingUtilities boolean isValidKeyEventForKeyBindings(java.awt.event.KeyEvent) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities boolean notifyAction(javax.swing.Action, javax.swing.KeyStroke, java.awt.event.KeyEvent, java.lang.Object, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities boolean notifyAction(javax.swing.Action, javax.swing.KeyStroke, java.awt.event.KeyEvent, java.lang.Object, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities boolean notifyAction(javax.swing.Action, javax.swing.KeyStroke, java.awt.event.KeyEvent, java.lang.Object, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null,_,_->false;null,_,_,_,_->false""/> </annotation> </item> + <item name="javax.swing.SwingUtilities boolean processKeyBindings(java.awt.event.KeyEvent) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities boolean processKeyBindings(java.awt.event.KeyEvent)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -344,20 +509,41 @@ <item name="javax.swing.SwingUtilities int computeStringWidth(java.awt.FontMetrics, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities int findDisplayedMnemonicIndex(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities int getAccessibleChildrenCount(java.awt.Component) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="javax.swing.SwingUtilities int getAccessibleIndexInParent(java.awt.Component) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.awt.Component findFocusOwner(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.awt.Component getDeepestComponentAt(java.awt.Component, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.awt.Component getRoot(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities java.awt.Container getAncestorNamed(java.lang.String, java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities java.awt.Container getAncestorNamed(java.lang.String, java.awt.Component) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.awt.Container getAncestorNamed(java.lang.String, java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->null;null,_->null""/> </annotation> </item> + <item name="javax.swing.SwingUtilities java.awt.Container getAncestorOfClass(java.lang.Class, java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities java.awt.Container getAncestorOfClass(java.lang.Class, java.awt.Component) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.awt.Container getAncestorOfClass(java.lang.Class, java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->null;null,_->null""/> @@ -379,6 +565,12 @@ <item name="javax.swing.SwingUtilities java.awt.Point convertScreenLocationToParent(java.awt.Container, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.awt.Rectangle calculateInnerArea(javax.swing.JComponent, java.awt.Rectangle) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="javax.swing.SwingUtilities java.awt.Rectangle calculateInnerArea(javax.swing.JComponent, java.awt.Rectangle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.awt.Rectangle calculateInnerArea(javax.swing.JComponent, java.awt.Rectangle)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> @@ -412,6 +604,9 @@ <item name="javax.swing.SwingUtilities java.awt.Rectangle getLocalBounds(java.awt.Component)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.awt.Rectangle[] computeDifference(java.awt.Rectangle, java.awt.Rectangle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.awt.Rectangle[] computeDifference(java.awt.Rectangle, java.awt.Rectangle)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -427,6 +622,9 @@ <item name="javax.swing.SwingUtilities java.awt.event.MouseEvent convertMouseEvent(java.awt.Component, java.awt.event.MouseEvent, java.awt.Component)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 7"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -441,9 +639,15 @@ <val val=""_,!null,_,_,_,_,_,_,_,_,_->!null""/> </annotation> </item> + <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 10"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabel(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 8"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -455,9 +659,15 @@ <val val=""_,_,!null,_,_,_,_,_,_,_,_,_->!null""/> </annotation> </item> + <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabelImpl(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabelImpl(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 10"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabelImpl(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities java.lang.String layoutCompoundLabelImpl(javax.swing.JComponent, java.awt.FontMetrics, java.lang.String, javax.swing.Icon, int, int, int, int, java.awt.Rectangle, java.awt.Rectangle, java.awt.Rectangle, int) 8"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -469,6 +679,9 @@ <val val=""_,_,!null,_,_,_,_,_,_,_,_,_->!null""/> </annotation> </item> + <item name="javax.swing.SwingUtilities javax.accessibility.Accessible getAccessibleAt(java.awt.Component, java.awt.Point) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities javax.accessibility.Accessible getAccessibleAt(java.awt.Component, java.awt.Point)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> @@ -489,6 +702,9 @@ <item name="javax.swing.SwingUtilities javax.swing.InputMap getUIInputMap(javax.swing.JComponent, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities javax.swing.JRootPane getRootPane(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="javax.swing.SwingUtilities javax.swing.JRootPane getRootPane(java.awt.Component)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -524,4 +740,7 @@ <item name="javax.swing.SwingUtilities void updateComponentTreeUI(java.awt.Component) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="javax.swing.SwingUtilities void updateComponentTreeUI0(java.awt.Component) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/annotations.xml index 08e265e17fcf..89a90c53dae2 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/annotations.xml @@ -5,6 +5,9 @@ <item name="org.apache.commons.collections.ExtendedProperties ExtendedProperties(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.ExtendedProperties ExtendedProperties(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.ExtendedProperties boolean access$000(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -17,6 +20,9 @@ <item name="org.apache.commons.collections.ExtendedProperties java.lang.String escape(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.ExtendedProperties java.lang.String interpolateHelper(java.lang.String, java.util.List) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.ExtendedProperties java.lang.String interpolateHelper(java.lang.String, java.util.List)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -37,4 +43,16 @@ <item name="org.apache.commons.collections.ExtendedProperties void combine(org.apache.commons.collections.ExtendedProperties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.ExtendedProperties void save(java.io.OutputStream, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.ExtendedProperties void save(java.io.OutputStream, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.ExtendedProperties void setInclude(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.ExtendedProperties.PropertiesTokenizer java.lang.String nextToken()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/iterators/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/iterators/annotations.xml new file mode 100644 index 000000000000..d4cfb7e5dfde --- /dev/null +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/iterators/annotations.xml @@ -0,0 +1,11 @@ +<root> + <item name="org.apache.commons.collections.iterators.AbstractEmptyIterator java.lang.Object setValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.iterators.AbstractEmptyIterator void add(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.iterators.AbstractEmptyIterator void set(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> +</root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/map/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/map/annotations.xml index 26b98c6bdf92..bd99ae8b862d 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/map/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/collections/map/annotations.xml @@ -2,6 +2,12 @@ <item name="org.apache.commons.collections.map.AbstractHashedMap AbstractHashedMap(java.util.Map) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap boolean isEqualKey(java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->true""/> @@ -18,6 +24,9 @@ <item name="org.apache.commons.collections.map.AbstractHashedMap int hash(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap java.lang.Object convertKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap java.lang.Object convertKey(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> @@ -53,17 +62,26 @@ <item name="org.apache.commons.collections.map.AbstractHashedMap void removeEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, org.apache.commons.collections.map.AbstractHashedMap.HashEntry) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap void removeEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, org.apache.commons.collections.map.AbstractHashedMap.HashEntry) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap void reuseEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, int, java.lang.Object, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.collections.map.AbstractHashedMap void updateEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap.EntrySet boolean contains(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap.EntrySet boolean contains(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap.EntrySet boolean remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap.EntrySet boolean remove(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -72,6 +90,9 @@ <item name="org.apache.commons.collections.map.AbstractHashedMap.EntrySetIterator EntrySetIterator(org.apache.commons.collections.map.AbstractHashedMap) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractHashedMap.HashEntry boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractHashedMap.HashEntry java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -93,6 +114,9 @@ <item name="org.apache.commons.collections.map.AbstractLinkedMap AbstractLinkedMap(java.util.Map) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractLinkedMap boolean containsValue(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractLinkedMap org.apache.commons.collections.map.AbstractHashedMap.HashEntry createEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -108,6 +132,9 @@ <item name="org.apache.commons.collections.map.AbstractLinkedMap void removeEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, org.apache.commons.collections.map.AbstractHashedMap.HashEntry) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.AbstractLinkedMap void removeEntry(org.apache.commons.collections.map.AbstractHashedMap.HashEntry, int, org.apache.commons.collections.map.AbstractHashedMap.HashEntry) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.AbstractLinkedMap.EntrySetIterator EntrySetIterator(org.apache.commons.collections.map.AbstractLinkedMap) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -132,6 +159,9 @@ <item name="org.apache.commons.collections.map.LRUMap LRUMap(java.util.Map, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.collections.map.LRUMap boolean removeLRU(org.apache.commons.collections.map.AbstractLinkedMap.LinkEntry) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.collections.map.LRUMap boolean removeLRU(org.apache.commons.collections.map.AbstractLinkedMap.LinkEntry)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->true;null->true""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/annotations.xml index e36a5e269c9a..7115dfb72473 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/annotations.xml @@ -1,55 +1,169 @@ <root> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(byte[], byte) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(char[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(int[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(java.lang.Object[], java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(java.lang.Object[], java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(long[], long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean contains(short[], short) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(boolean[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(byte[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(double[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(float[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(int[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(long[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isEmpty(short[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(boolean[], boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(boolean[], boolean[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(byte[], byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(byte[], byte[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(char[], char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(char[], char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(double[], double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(double[], double[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(float[], float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(float[], float[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(int[], int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(int[], int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(long[], long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(long[], long[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(short[], short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean isSameLength(short[], short[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean isSameType(java.lang.Object, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.ArrayUtils boolean isSameType(java.lang.Object, java.lang.Object) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] add(boolean[], boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] addAll(boolean[], boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] addAll(boolean[], boolean[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] clone(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean[] clone(boolean[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -58,21 +172,42 @@ <item name="org.apache.commons.lang.ArrayUtils boolean[] remove(boolean[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] subarray(boolean[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean[] subarray(boolean[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] toPrimitive(java.lang.Boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean[] toPrimitive(java.lang.Boolean[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils boolean[] toPrimitive(java.lang.Boolean[], boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils boolean[] toPrimitive(java.lang.Boolean[], boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] add(byte[], byte) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] addAll(byte[], byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] addAll(byte[], byte[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] clone(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils byte[] clone(byte[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -81,21 +216,42 @@ <item name="org.apache.commons.lang.ArrayUtils byte[] remove(byte[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] subarray(byte[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils byte[] subarray(byte[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] toPrimitive(java.lang.Byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils byte[] toPrimitive(java.lang.Byte[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils byte[] toPrimitive(java.lang.Byte[], byte) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils byte[] toPrimitive(java.lang.Byte[], byte)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils char[] add(char[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils char[] addAll(char[], char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils char[] addAll(char[], char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils char[] clone(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils char[] clone(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -104,21 +260,42 @@ <item name="org.apache.commons.lang.ArrayUtils char[] remove(char[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils char[] subarray(char[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils char[] subarray(char[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils char[] toPrimitive(java.lang.Character[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils char[] toPrimitive(java.lang.Character[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils char[] toPrimitive(java.lang.Character[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils char[] toPrimitive(java.lang.Character[], char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils double[] add(double[], double) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils double[] addAll(double[], double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils double[] addAll(double[], double[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils double[] clone(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils double[] clone(double[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -127,21 +304,42 @@ <item name="org.apache.commons.lang.ArrayUtils double[] remove(double[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils double[] subarray(double[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils double[] subarray(double[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils double[] toPrimitive(java.lang.Double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils double[] toPrimitive(java.lang.Double[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils double[] toPrimitive(java.lang.Double[], double) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils double[] toPrimitive(java.lang.Double[], double)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils float[] add(float[], float) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils float[] addAll(float[], float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils float[] addAll(float[], float[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils float[] clone(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils float[] clone(float[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -150,21 +348,129 @@ <item name="org.apache.commons.lang.ArrayUtils float[] remove(float[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils float[] subarray(float[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils float[] subarray(float[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils float[] toPrimitive(java.lang.Float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils float[] toPrimitive(java.lang.Float[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils float[] toPrimitive(java.lang.Float[], float) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils float[] toPrimitive(java.lang.Float[], float)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils int getLength(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(byte[], byte) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(byte[], byte, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(char[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(char[], char, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(int[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(int[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(java.lang.Object[], java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(java.lang.Object[], java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(java.lang.Object[], java.lang.Object, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(java.lang.Object[], java.lang.Object, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(long[], long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(long[], long, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(short[], short) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int indexOf(short[], short, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(byte[], byte) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(byte[], byte, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(char[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(char[], char, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(int[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(int[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(java.lang.Object[], java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(java.lang.Object[], java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(java.lang.Object[], java.lang.Object, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(java.lang.Object[], java.lang.Object, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(long[], long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(long[], long, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(short[], short) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int lastIndexOf(short[], short, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int[] add(int[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int[] addAll(int[], int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int[] addAll(int[], int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils int[] clone(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils int[] clone(int[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -173,59 +479,104 @@ <item name="org.apache.commons.lang.ArrayUtils int[] remove(int[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils int[] subarray(int[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils int[] subarray(int[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils int[] toPrimitive(java.lang.Integer[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils int[] toPrimitive(java.lang.Integer[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils int[] toPrimitive(java.lang.Integer[], int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils int[] toPrimitive(java.lang.Integer[], int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Boolean[] toObject(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Boolean[] toObject(boolean[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Byte[] toObject(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Byte[] toObject(byte[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Character[] toObject(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Character[] toObject(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Double[] toObject(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Double[] toObject(double[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Float[] toObject(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Float[] toObject(float[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Integer[] toObject(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Integer[] toObject(int[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Long[] toObject(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Long[] toObject(long[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object copyArrayGrow1(java.lang.Object, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Object remove(java.lang.Object, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] add(java.lang.Object[], java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] addAll(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] addAll(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] clone(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] clone(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -234,21 +585,51 @@ <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] remove(java.lang.Object[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] removeElement(java.lang.Object[], java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] subarray(java.lang.Object[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Object[] subarray(java.lang.Object[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.Short[] toObject(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.lang.Short[] toObject(short[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.String toString(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.lang.String toString(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils java.util.Map toMap(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils java.util.Map toMap(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils long[] add(long[], long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils long[] addAll(long[], long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils long[] addAll(long[], long[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils long[] clone(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils long[] clone(long[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -257,21 +638,42 @@ <item name="org.apache.commons.lang.ArrayUtils long[] remove(long[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils long[] subarray(long[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils long[] subarray(long[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils long[] toPrimitive(java.lang.Long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils long[] toPrimitive(java.lang.Long[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils long[] toPrimitive(java.lang.Long[], long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils long[] toPrimitive(java.lang.Long[], long)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils short[] add(short[], short) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils short[] addAll(short[], short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils short[] addAll(short[], short[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils short[] clone(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils short[] clone(short[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -280,57 +682,177 @@ <item name="org.apache.commons.lang.ArrayUtils short[] remove(short[], int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ArrayUtils short[] subarray(short[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils short[] subarray(short[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils short[] toPrimitive(java.lang.Short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils short[] toPrimitive(java.lang.Short[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils short[] toPrimitive(java.lang.Short[], short) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ArrayUtils short[] toPrimitive(java.lang.Short[], short)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ArrayUtils void reverse(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean isFalse(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils boolean isFalse(java.lang.Boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils boolean isNotFalse(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean isNotTrue(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean isTrue(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils boolean isTrue(java.lang.Boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.Boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.Integer, java.lang.Integer, java.lang.Integer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.Integer, java.lang.Integer, java.lang.Integer) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBoolean(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils boolean toBooleanDefaultIfNull(java.lang.Boolean, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils boolean xor(boolean[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.BooleanUtils int toInteger(java.lang.Boolean, int, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean negate(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean negate(java.lang.Boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.Integer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.Integer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.Integer, java.lang.Integer, java.lang.Integer, java.lang.Integer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.Integer, java.lang.Integer, java.lang.Integer, java.lang.Integer) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.Integer, java.lang.Integer, java.lang.Integer, java.lang.Integer) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean toBooleanObject(java.lang.String, java.lang.String, java.lang.String, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils java.lang.Boolean xor(java.lang.Boolean[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Integer toIntegerObject(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.BooleanUtils java.lang.Integer toIntegerObject(java.lang.Boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.Integer toIntegerObject(java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.lang.Integer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.String toString(java.lang.Boolean, java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.String toStringOnOff(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.String toStringTrueFalse(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.BooleanUtils java.lang.String toStringYesNo(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.CharEncoding boolean isSupported(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharEncoding boolean isSupported(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -339,29 +861,56 @@ <item name="org.apache.commons.lang.CharRange boolean contains(org.apache.commons.lang.CharRange) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSet CharSet(java.lang.String[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharSet boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.CharSet org.apache.commons.lang.CharSet getInstance(java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSet org.apache.commons.lang.CharSet getInstance(java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSet void add(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.CharSetUtils int count(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String delete(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String delete(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String delete(java.lang.String, java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String keep(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String keep(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String keep(java.lang.String, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String keep(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String keep(java.lang.String, java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -370,6 +919,9 @@ <item name="org.apache.commons.lang.CharSetUtils java.lang.String modify(java.lang.String, java.lang.String[], boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String modify(java.lang.String, java.lang.String[], boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String modify(java.lang.String, java.lang.String[], boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -378,6 +930,9 @@ <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSetUtils java.lang.String squeeze(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils java.lang.String squeeze(java.lang.String, java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -388,6 +943,9 @@ <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharSetUtils org.apache.commons.lang.CharSet evaluateSet(java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharSetUtils org.apache.commons.lang.CharSet evaluateSet(java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -396,17 +954,26 @@ <item name="org.apache.commons.lang.CharUtils char toChar(java.lang.Character) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharUtils char toChar(java.lang.Character, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharUtils char toChar(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.CharUtils int toIntValue(java.lang.Character) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharUtils int toIntValue(java.lang.Character, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharUtils java.lang.Character toCharacterObject(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.CharUtils java.lang.String toString(java.lang.Character) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharUtils java.lang.String toString(java.lang.Character)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -415,16 +982,34 @@ <item name="org.apache.commons.lang.CharUtils java.lang.String unicodeEscaped(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.CharUtils java.lang.String unicodeEscaped(java.lang.Character) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.CharUtils java.lang.String unicodeEscaped(java.lang.Character)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils boolean isAssignable(java.lang.Class, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ClassUtils boolean isAssignable(java.lang.Class, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils boolean isAssignable(java.lang.Class, java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils boolean isAssignable(java.lang.Class[], java.lang.Class[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ClassUtils boolean isAssignable(java.lang.Class[], java.lang.Class[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ClassUtils boolean isInnerClass(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils boolean isInnerClass(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -435,24 +1020,39 @@ <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] primitivesToWrappers(java.lang.Class[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] primitivesToWrappers(java.lang.Class[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] toClass(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] toClass(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] wrappersToPrimitives(java.lang.Class[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.Class[] wrappersToPrimitives(java.lang.Class[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageCanonicalName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageCanonicalName(java.lang.Class)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageCanonicalName(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageCanonicalName(java.lang.Object, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;_,!null->!null""/> @@ -461,31 +1061,62 @@ <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageCanonicalName(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.Class)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.Object, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getPackageName(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortCanonicalName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortCanonicalName(java.lang.Class)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortCanonicalName(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortCanonicalName(java.lang.Object, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> + <val val=""!null,_->!null;_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortCanonicalName(java.lang.String)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.Class)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.Object, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> + <val val=""!null,_->!null;_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String getShortClassName(java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.ClassUtils java.lang.String toCanonicalName(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> @@ -498,21 +1129,33 @@ <item name="org.apache.commons.lang.ClassUtils java.lang.reflect.Method getPublicMethod(java.lang.Class, java.lang.String, java.lang.Class[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ClassUtils java.util.List convertClassNamesToClasses(java.util.List) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.util.List convertClassNamesToClasses(java.util.List)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.util.List convertClassesToClassNames(java.util.List) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.util.List convertClassesToClassNames(java.util.List)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.util.List getAllInterfaces(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.util.List getAllInterfaces(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ClassUtils java.util.List getAllSuperclasses(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ClassUtils java.util.List getAllSuperclasses(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -551,11 +1194,41 @@ <item name="org.apache.commons.lang.Entities void unescape(java.io.Writer, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.Entities.ArrayEntityMap int value(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IllegalClassException IllegalClassException(java.lang.Class, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IllegalClassException IllegalClassException(java.lang.Class, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IllegalClassException IllegalClassException(java.lang.Class, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IllegalClassException IllegalClassException(java.lang.Class, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IllegalClassException java.lang.String safeGetClassName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.IllegalClassException java.lang.String safeGetClassName(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.IncompleteArgumentException IncompleteArgumentException(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IncompleteArgumentException IncompleteArgumentException(java.lang.String, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IncompleteArgumentException IncompleteArgumentException(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.IncompleteArgumentException java.lang.String safeArrayToString(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.IncompleteArgumentException java.lang.String safeArrayToString(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -567,14 +1240,32 @@ <item name="org.apache.commons.lang.LocaleUtils java.util.List localeLookupList(java.util.Locale)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.LocaleUtils java.util.List localeLookupList(java.util.Locale, java.util.Locale) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.LocaleUtils java.util.List localeLookupList(java.util.Locale, java.util.Locale)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.LocaleUtils java.util.Locale toLocale(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.LocaleUtils java.util.Locale toLocale(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.NotImplementedException NotImplementedException(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.NotImplementedException NotImplementedException(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.NotImplementedException NotImplementedException(java.lang.String, java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.NullArgumentException NullArgumentException(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberRange NumberRange(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -584,16 +1275,28 @@ <item name="org.apache.commons.lang.NumberRange NumberRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.NumberRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.NumberRange boolean includesNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberRange boolean includesNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.NumberRange boolean includesRange(org.apache.commons.lang.NumberRange) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberRange boolean includesRange(org.apache.commons.lang.NumberRange)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.NumberRange boolean overlaps(org.apache.commons.lang.NumberRange) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberRange boolean overlaps(org.apache.commons.lang.NumberRange)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -602,11 +1305,17 @@ <item name="org.apache.commons.lang.NumberRange java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.NumberUtils boolean isAllZeros(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberUtils boolean isAllZeros(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.NumberUtils boolean isDigits(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberUtils boolean isDigits(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -635,6 +1344,9 @@ <item name="org.apache.commons.lang.NumberUtils java.lang.Long createLong(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.NumberUtils java.lang.Number createNumber(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.NumberUtils java.lang.Number createNumber(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -646,21 +1358,54 @@ <item name="org.apache.commons.lang.NumberUtils java.math.BigInteger createBigInteger(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.ObjectUtils boolean equals(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils boolean equals(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils int hashCode(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.Object defaultIfNull(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ObjectUtils java.lang.Object defaultIfNull(java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.Object max(java.lang.Comparable, java.lang.Comparable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.Object min(java.lang.Comparable, java.lang.Comparable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.String identityToString(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ObjectUtils java.lang.String identityToString(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.String toString(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ObjectUtils java.lang.String toString(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.String toString(java.lang.Object, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.StringBuffer appendIdentityToString(java.lang.StringBuffer, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.ObjectUtils java.lang.StringBuffer appendIdentityToString(java.lang.StringBuffer, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.ObjectUtils java.lang.StringBuffer appendIdentityToString(java.lang.StringBuffer, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -678,18 +1423,30 @@ <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, boolean, boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, char[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, int, int, boolean, boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, int, int, boolean, boolean, char[]) 5"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, int, int, boolean, boolean, char[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, int, int, boolean, boolean, char[], java.util.Random) 5"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, int, int, boolean, boolean, char[], java.util.Random)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.RandomStringUtils java.lang.String random(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -714,41 +1471,77 @@ <item name="org.apache.commons.lang.SerializationUtils void serialize(java.io.Serializable, java.io.OutputStream) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeHtml(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeHtml(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeJava(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeJavaScript(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeJavaStyleString(java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeJavaStyleString(java.lang.String, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeSql(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeSql(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeXml(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String escapeXml(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String hex(char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeCsv(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeCsv(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeHtml(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeHtml(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeJava(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeJava(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeJavaScript(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeXml(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils java.lang.String unescapeXml(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -757,136 +1550,358 @@ <item name="org.apache.commons.lang.StringEscapeUtils void escapeHtml(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void escapeHtml(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void escapeJava(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void escapeJava(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void escapeJavaScript(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void escapeJavaScript(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void escapeJavaStyleString(java.io.Writer, java.lang.String, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void escapeJavaStyleString(java.io.Writer, java.lang.String, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void escapeXml(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void escapeXml(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringEscapeUtils void unescapeCsv(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void unescapeHtml(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void unescapeHtml(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void unescapeJava(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void unescapeJava(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void unescapeJavaScript(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void unescapeJavaScript(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringEscapeUtils void unescapeXml(java.io.Writer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringEscapeUtils void unescapeXml(java.io.Writer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean contains(java.lang.String, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean contains(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean contains(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean contains(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsAny(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsIgnoreCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsIgnoreCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsIgnoreCase(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsNone(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean containsOnly(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->false;null,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWith(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWith(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWith(java.lang.String, java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWith(java.lang.String, java.lang.String, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWithIgnoreCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean endsWithIgnoreCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean equals(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean equals(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean equalsIgnoreCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean equalsIgnoreCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean isAlpha(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isAlpha(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isAlphaSpace(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isAlphaSpace(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isAlphanumeric(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isAlphanumeric(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isAlphanumericSpace(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isAlphanumericSpace(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isAsciiPrintable(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isAsciiPrintable(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isBlank(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isBlank(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isEmpty(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isEmpty(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isNotBlank(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean isNotEmpty(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean isNumeric(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isNumeric(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isNumericSpace(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isNumericSpace(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean isWhitespace(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils boolean isWhitespace(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWith(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWith(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWith(java.lang.String, java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWith(java.lang.String, java.lang.String, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWithIgnoreCase(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils boolean startsWithIgnoreCase(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils int getLevenshteinDistance(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.StringUtils int getLevenshteinDistance(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringUtils int indexOf(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOf(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOf(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOf(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOfAny(java.lang.String, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOfAny(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOfDifference(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOfDifference(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int indexOfDifference(java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOf(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOf(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOf(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOf(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOfAny(java.lang.String, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int lastIndexOfAny(java.lang.String, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int length(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int ordinalIndexOf(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils int ordinalIndexOf(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String abbreviate(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String abbreviate(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String abbreviate(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String abbreviate(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> @@ -927,6 +1942,9 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String chomp(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String chomp(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -948,6 +1966,9 @@ <val val=""!null,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String chop(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String chop(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -959,26 +1980,39 @@ <item name="org.apache.commons.lang.StringUtils java.lang.String chopNewline(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String clean(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String clean(java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String concatenate(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.StringUtils java.lang.String concatenate(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String defaultString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String defaultString(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String defaultString(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String defaultString(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String deleteSpaces(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String deleteSpaces(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -989,11 +2023,17 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String difference(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String difference(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String escape(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String getChomp(java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1005,16 +2045,34 @@ <val val=""_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getCommonPrefix(java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String getCommonPrefix(java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String getNestedString(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->null;_,null,_->null;null,_,_->null""/> @@ -1029,81 +2087,144 @@ <item name="org.apache.commons.lang.StringUtils java.lang.String getPrechomp(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], char, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], char, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String, int, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.lang.Object[], java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Collection, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Collection, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Collection, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Collection, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Collection, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Iterator, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Iterator, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Iterator, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Iterator, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String join(java.util.Iterator, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String left(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String left(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String leftPad(java.lang.String, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String lowerCase(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String lowerCase(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->null""/> + <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String mid(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String mid(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String overlay(java.lang.String, java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String overlay(java.lang.String, java.lang.String, int, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String overlay(java.lang.String, java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> @@ -1162,116 +2283,200 @@ <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String repeat(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String repeat(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replace(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replace(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replace(java.lang.String, java.lang.String, java.lang.String, int) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replace(java.lang.String, java.lang.String, java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceChars(java.lang.String, char, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceChars(java.lang.String, char, char)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_,_->null""/> + <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceChars(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceChars(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[], boolean, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[], boolean, int) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEach(java.lang.String, java.lang.String[], java.lang.String[], boolean, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEachRepeatedly(java.lang.String, java.lang.String[], java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEachRepeatedly(java.lang.String, java.lang.String[], java.lang.String[]) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceEachRepeatedly(java.lang.String, java.lang.String[], java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String replaceOnce(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String replaceOnce(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String reverse(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String reverse(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String reverseDelimited(java.lang.String, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String reverseDelimited(java.lang.String, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String reverseDelimitedString(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String reverseDelimitedString(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String reverseDelimitedString(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String right(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String right(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String rightPad(java.lang.String, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String strip(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String stripEnd(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String stripEnd(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String stripStart(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String stripStart(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String stripToEmpty(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String stripToEmpty(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String stripToNull(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String stripToNull(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substring(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substring(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substring(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substring(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringAfter(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substringAfter(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null""/> @@ -1282,6 +2487,9 @@ <val val=""!null,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBefore(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substringBefore(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null""/> @@ -1292,11 +2500,26 @@ <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null->null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String substringBetween(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->null;_,null,_->null;null,_,_->null""/> @@ -1307,15 +2530,22 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String trim(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String trim(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->null""/> + <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String trimToEmpty(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String trimToEmpty(java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String trimToNull(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.StringUtils java.lang.String trimToNull(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> @@ -1332,96 +2562,183 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String upperCase(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String upperCase(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->null""/> + <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] split(java.lang.String, java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterType(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterType(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterType(java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterType(java.lang.String, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterTypeCamelCase(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByCharacterTypeCamelCase(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparator(java.lang.String, java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorPreserveAllTokens(java.lang.String, java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorWorker(java.lang.String, java.lang.String, int, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorWorker(java.lang.String, java.lang.String, int, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitByWholeSeparatorWorker(java.lang.String, java.lang.String, int, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, char)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitPreserveAllTokens(java.lang.String, java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitWorker(java.lang.String, char, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitWorker(java.lang.String, char, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitWorker(java.lang.String, java.lang.String, int, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitWorker(java.lang.String, java.lang.String, int, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] splitWorker(java.lang.String, java.lang.String, int, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_,_->null""/> @@ -1432,11 +2749,17 @@ <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] stripAll(java.lang.String[], java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] stripAll(java.lang.String[], java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.StringUtils java.lang.String[] substringsBetween(java.lang.String, java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.StringUtils java.lang.String[] substringsBetween(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> @@ -1476,6 +2799,18 @@ <item name="org.apache.commons.lang.Validate void allElementsOfType(java.util.Collection, java.lang.Class, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.Validate void isTrue(boolean, java.lang.String, double) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.Validate void isTrue(boolean, java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.Validate void isTrue(boolean, java.lang.String, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.Validate void isTrue(boolean, java.lang.String, long) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.Validate void noNullElements(java.lang.Object[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -1518,6 +2853,15 @@ <item name="org.apache.commons.lang.Validate void notNull(java.lang.Object, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.WordUtils boolean isDelimiter(char, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String abbreviate(java.lang.String, int, int, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String abbreviate(java.lang.String, int, int, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String abbreviate(java.lang.String, int, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> @@ -1528,6 +2872,9 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String capitalize(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String capitalize(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -1538,6 +2885,9 @@ <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String capitalizeFully(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String capitalizeFully(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> @@ -1548,6 +2898,9 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String initials(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String initials(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> @@ -1563,16 +2916,28 @@ <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String uncapitalize(java.lang.String, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String uncapitalize(java.lang.String, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String wrap(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String wrap(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String wrap(java.lang.String, int, java.lang.String, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.WordUtils java.lang.String wrap(java.lang.String, int, java.lang.String, boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.WordUtils java.lang.String wrap(java.lang.String, int, java.lang.String, boolean)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_,_->!null;null,_,_,_->null""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/builder/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/builder/annotations.xml index c46c851e0fa1..4cd0e1e34b32 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/builder/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/builder/annotations.xml @@ -1,75 +1,126 @@ <root> + <item name="org.apache.commons.lang.builder.CompareToBuilder int reflectionCompare(java.lang.Object, java.lang.Object, boolean, java.lang.Class) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder int reflectionCompare(java.lang.Object, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder int reflectionCompare(java.lang.Object, java.lang.Object, java.util.Collection) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(boolean, boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(boolean[], boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(boolean[], boolean[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(boolean[], boolean[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(byte, byte)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(byte[], byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(byte[], byte[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(byte[], byte[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(char, char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(char[], char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(char[], char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(char[], char[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(double, double)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(double[], double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(double[], double[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(double[], double[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(float, float)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(float[], float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(float[], float[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(float[], float[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(int[], int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(int[], int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(int[], int[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object, java.lang.Object, java.util.Comparator) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object, java.lang.Object, java.util.Comparator) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object, java.lang.Object, java.util.Comparator)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object[], java.lang.Object[], java.util.Comparator) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object[], java.lang.Object[], java.util.Comparator) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(java.lang.Object[], java.lang.Object[], java.util.Comparator)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null,_->!null;null,_,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(long, long)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(long[], long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(long[], long[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(long[], long[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(short, short)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(short[], short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(short[], short[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder append(short[], short[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.CompareToBuilder org.apache.commons.lang.builder.CompareToBuilder appendSuper(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -77,71 +128,158 @@ <item name="org.apache.commons.lang.builder.CompareToBuilder void reflectionAppend(java.lang.Object, java.lang.Object, java.lang.Class, org.apache.commons.lang.builder.CompareToBuilder, boolean, java.lang.String[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, java.lang.String[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, java.util.Collection) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, java.util.Collection) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder boolean reflectionEquals(java.lang.Object, java.lang.Object, java.util.Collection) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(boolean, boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(boolean[], boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(boolean[], boolean[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(boolean[], boolean[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(byte, byte)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(byte[], byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(byte[], byte[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(byte[], byte[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(char, char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(char[], char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(char[], char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(char[], char[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(double[], double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(double[], double[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(double[], double[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(float[], float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(float[], float[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(float[], float[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(int[], int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(int[], int[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(int[], int[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object[], java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object[], java.lang.Object[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(java.lang.Object[], java.lang.Object[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(long, long)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(long[], long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(long[], long[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(long[], long[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(short, short)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(short[], short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(short[], short[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder append(short[], short[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""_,null->!null;null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.EqualsBuilder org.apache.commons.lang.builder.EqualsBuilder appendSuper(boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -158,9 +296,15 @@ <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(int, int, java.lang.Object, boolean, java.lang.Class) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(int, int, java.lang.Object, boolean, java.lang.Class) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(int, int, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(int, int, java.lang.Object, boolean, java.lang.Class, java.lang.String[]) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -173,77 +317,92 @@ <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(java.lang.Object, java.util.Collection) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder int reflectionHashCode(java.lang.Object, java.util.Collection) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder java.lang.Integer toIdentityHashCodeInteger(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(boolean[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(boolean[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(byte)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(byte[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(char[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(double[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(double[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(float)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(float[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(float[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(int[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(int[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(java.lang.Object[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(long)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(long[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(long[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(short)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(short[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder append(short[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.HashCodeBuilder org.apache.commons.lang.builder.HashCodeBuilder appendSuper(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -251,15 +410,60 @@ <item name="org.apache.commons.lang.builder.HashCodeBuilder.1 java.lang.Object initialValue()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer, java.lang.Class, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer, java.lang.Class, boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer, java.lang.Class, boolean, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder ReflectionToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer, java.lang.Class, boolean, boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder boolean accept(java.lang.reflect.Field) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.Object getValue(java.lang.reflect.Field) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean, boolean, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String toStringExclude(java.lang.Object, java.util.Collection) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String[] toNoNullStringArray(java.lang.Object[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder java.lang.String[] toNoNullStringArray(java.util.Collection) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder org.apache.commons.lang.builder.ReflectionToStringBuilder setExcludeFieldNames(java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder org.apache.commons.lang.builder.ReflectionToStringBuilder setExcludeFieldNames(java.lang.String[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -269,6 +473,60 @@ <item name="org.apache.commons.lang.builder.ReflectionToStringBuilder void appendFieldsIn(java.lang.Class) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setArrayEnd(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setArraySeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setArrayStart(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setContentEnd(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setContentStart(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setFieldNameValueSeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setFieldSeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setNullText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setSizeEndText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setSizeStartText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setSummaryObjectEndText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.StandardToStringStyle void setSummaryObjectStartText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder ToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder ToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder ToStringBuilder(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, java.lang.StringBuffer) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder java.lang.String reflectionToString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder java.lang.String reflectionToString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder java.lang.String reflectionToString(java.lang.Object, org.apache.commons.lang.builder.ToStringStyle, boolean, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringBuilder java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -410,22 +668,68 @@ <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder append(short[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendAsObjectToString(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendAsObjectToString(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendSuper(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendSuper(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendToString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringBuilder org.apache.commons.lang.builder.ToStringBuilder appendToString(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.ToStringBuilder void setDefaultStyle(org.apache.commons.lang.builder.ToStringStyle) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle boolean isFullDetail(java.lang.Boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle java.lang.String getShortClassName(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle java.lang.String getShortClassName(java.lang.Class)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, boolean[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, byte[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, char[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, double[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, float[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, int[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, java.lang.Object, java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, java.lang.Object[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, long[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void append(java.lang.StringBuffer, java.lang.String, short[], java.lang.Boolean) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendClassName(java.lang.StringBuffer, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendContentEnd(java.lang.StringBuffer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -433,9 +737,21 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendContentStart(java.lang.StringBuffer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendCyclicObject(java.lang.StringBuffer, java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendCyclicObject(java.lang.StringBuffer, java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendCyclicObject(java.lang.StringBuffer, java.lang.String, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, boolean[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -445,6 +761,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, byte) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, byte) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, byte[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -454,6 +773,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, char) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, char) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, char[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -463,6 +785,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, double) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, double) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, double[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -472,6 +797,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, float) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, float) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, float[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -481,6 +809,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -490,6 +821,12 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.lang.Object[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -499,12 +836,27 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Collection) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Collection) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Collection) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Map) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Map) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, java.util.Map) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, long) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, long) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, long[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -514,18 +866,36 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, short) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, short) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, short[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendDetail(java.lang.StringBuffer, java.lang.String, short[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendFieldEnd(java.lang.StringBuffer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendFieldSeparator(java.lang.StringBuffer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendFieldStart(java.lang.StringBuffer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendIdentityHashCode(java.lang.StringBuffer, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendNullText(java.lang.StringBuffer, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendNullText(java.lang.StringBuffer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendStart(java.lang.StringBuffer, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummary(java.lang.StringBuffer, java.lang.String, boolean[]) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -547,6 +917,9 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummary(java.lang.StringBuffer, java.lang.String, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummary(java.lang.StringBuffer, java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummary(java.lang.StringBuffer, java.lang.String, java.lang.Object) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -562,12 +935,57 @@ <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummarySize(java.lang.StringBuffer, java.lang.String, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendSummarySize(java.lang.StringBuffer, java.lang.String, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void appendToString(java.lang.StringBuffer, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void reflectionAppendArrayDetail(java.lang.StringBuffer, java.lang.String, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void register(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle void removeLastFieldSeparator(java.lang.StringBuffer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setArrayEnd(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setArraySeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setArrayStart(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setContentEnd(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setContentStart(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setFieldNameValueSeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setFieldSeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setNullText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setSizeEndText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setSizeStartText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setSummaryObjectEndText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.builder.ToStringStyle void setSummaryObjectStartText(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.builder.ToStringStyle.1 java.lang.Object initialValue()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enum/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enum/annotations.xml index be5d5ca8d20e..05b15d3460ce 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enum/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enum/annotations.xml @@ -2,6 +2,9 @@ <item name="org.apache.commons.lang.enum.Enum Enum(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.enum.Enum boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.enum.Enum java.lang.String getNameInOtherClassLoader(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enums/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enums/annotations.xml index 0e7d219fd30a..3b827c118787 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enums/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/enums/annotations.xml @@ -2,6 +2,9 @@ <item name="org.apache.commons.lang.enums.Enum Enum(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.enums.Enum boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.enums.Enum java.lang.String getNameInOtherClassLoader(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/exception/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/exception/annotations.xml index 2924cb9a5731..585584b958f2 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/exception/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/exception/annotations.xml @@ -1,4 +1,10 @@ <root> + <item name="org.apache.commons.lang.exception.ExceptionUtils boolean isCauseMethodName(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils boolean isNestedThrowable(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils boolean isNestedThrowable(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -7,12 +13,54 @@ <item name="org.apache.commons.lang.exception.ExceptionUtils boolean setCause(java.lang.Throwable, java.lang.Throwable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int getThrowableCount(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOf(java.lang.Throwable, java.lang.Class, int, boolean) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOf(java.lang.Throwable, java.lang.Class, int, boolean) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfThrowable(java.lang.Throwable, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfThrowable(java.lang.Throwable, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfThrowable(java.lang.Throwable, java.lang.Class, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfThrowable(java.lang.Throwable, java.lang.Class, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfType(java.lang.Throwable, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfType(java.lang.Throwable, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfType(java.lang.Throwable, java.lang.Class, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils int indexOfType(java.lang.Throwable, java.lang.Class, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getFullStackTrace(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getFullStackTrace(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getMessage(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getMessage(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getRootCauseMessage(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getRootCauseMessage(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -22,30 +70,63 @@ <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String getStackTrace(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String[] getRootCauseStackTrace(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String[] getStackFrames(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.String[] toArray(java.util.List) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCause(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCause(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCause(java.lang.Throwable, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCause(java.lang.Throwable, java.lang.String[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCauseUsingWellKnownTypes(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getCauseUsingWellKnownTypes(java.lang.Throwable)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable getRootCause(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.lang.Throwable[] getThrowables(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.util.ArrayList getCauseMethodNameList()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.exception.ExceptionUtils java.util.List getStackFrameList(java.lang.Throwable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils java.util.List getThrowableList(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils void printRootCauseStackTrace(java.lang.Throwable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils void printRootCauseStackTrace(java.lang.Throwable, java.io.PrintStream) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.exception.ExceptionUtils void printRootCauseStackTrace(java.lang.Throwable, java.io.PrintWriter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.ExceptionUtils void removeCommonFrames(java.util.List, java.util.List) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -55,6 +136,9 @@ <item name="org.apache.commons.lang.exception.NestableDelegate NestableDelegate(org.apache.commons.lang.exception.Nestable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.exception.NestableDelegate int indexOfThrowable(java.lang.Class, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.exception.NestableDelegate java.lang.String getMessage(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/math/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/math/annotations.xml index c799fc9bc0fd..567cb620681f 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/math/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/math/annotations.xml @@ -8,16 +8,28 @@ <item name="org.apache.commons.lang.math.DoubleRange DoubleRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.DoubleRange boolean containsNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.DoubleRange boolean containsNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.DoubleRange boolean containsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.DoubleRange boolean containsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.DoubleRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.DoubleRange boolean overlapsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.DoubleRange boolean overlapsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -32,21 +44,36 @@ <item name="org.apache.commons.lang.math.FloatRange FloatRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.FloatRange boolean containsNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.FloatRange boolean containsNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.FloatRange boolean containsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.FloatRange boolean containsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.FloatRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.FloatRange boolean overlapsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.FloatRange boolean overlapsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Fraction boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Fraction org.apache.commons.lang.math.Fraction abs()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -116,21 +143,36 @@ <item name="org.apache.commons.lang.math.IntRange IntRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.IntRange boolean containsNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.IntRange boolean containsNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.IntRange boolean containsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.IntRange boolean containsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.IntRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.IntRange boolean overlapsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.IntRange boolean overlapsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.JVMRandom void nextBytes(byte[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.LongRange LongRange(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -140,16 +182,28 @@ <item name="org.apache.commons.lang.math.LongRange LongRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.LongRange boolean containsNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.LongRange boolean containsNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.LongRange boolean containsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.LongRange boolean containsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.LongRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.LongRange boolean overlapsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.LongRange boolean overlapsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -164,11 +218,20 @@ <item name="org.apache.commons.lang.math.NumberRange NumberRange(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.NumberRange boolean containsNumber(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberRange boolean containsNumber(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberRange boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils boolean isAllZeros(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils boolean isAllZeros(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->true""/> @@ -196,48 +259,93 @@ <item name="org.apache.commons.lang.math.NumberUtils double min(double[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.NumberUtils double toDouble(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils double toDouble(java.lang.String, double) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils float max(float[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.math.NumberUtils float min(float[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.NumberUtils float toFloat(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils float toFloat(java.lang.String, float) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils int max(int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.math.NumberUtils int min(int[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.NumberUtils int stringToInt(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils int stringToInt(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils int toInt(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils int toInt(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils java.lang.Double createDouble(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.lang.Double createDouble(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.lang.Float createFloat(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.lang.Float createFloat(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.lang.Integer createInteger(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.lang.Integer createInteger(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.lang.Long createLong(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.lang.Long createLong(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.lang.Number createNumber(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.lang.Number createNumber(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.math.BigDecimal createBigDecimal(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.math.BigDecimal createBigDecimal(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.math.NumberUtils java.math.BigInteger createBigInteger(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils java.math.BigInteger createBigInteger(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> @@ -249,6 +357,12 @@ <item name="org.apache.commons.lang.math.NumberUtils long min(long[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.NumberUtils long toLong(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.NumberUtils long toLong(java.lang.String, long) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.NumberUtils short max(short[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -273,31 +387,52 @@ <item name="org.apache.commons.lang.math.RandomUtils long nextLong(java.util.Random) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.math.Range boolean containsDouble(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean containsDouble(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Range boolean containsFloat(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean containsFloat(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Range boolean containsInteger(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean containsInteger(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Range boolean containsLong(java.lang.Number) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean containsLong(java.lang.Number)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Range boolean containsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean containsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.math.Range boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.math.Range boolean overlapsRange(org.apache.commons.lang.math.Range) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.math.Range boolean overlapsRange(org.apache.commons.lang.math.Range)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/mutable/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/mutable/annotations.xml index dd2d7d0d82ab..acf730ff9e41 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/mutable/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/mutable/annotations.xml @@ -2,6 +2,9 @@ <item name="org.apache.commons.lang.mutable.MutableBoolean MutableBoolean(java.lang.Boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableBoolean boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableBoolean boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -19,6 +22,9 @@ <item name="org.apache.commons.lang.mutable.MutableByte MutableByte(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableByte boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableByte boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -48,6 +54,9 @@ <item name="org.apache.commons.lang.mutable.MutableDouble MutableDouble(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableDouble boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableDouble boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -74,6 +83,9 @@ <item name="org.apache.commons.lang.mutable.MutableFloat MutableFloat(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableFloat boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableFloat boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -100,6 +112,9 @@ <item name="org.apache.commons.lang.mutable.MutableInt MutableInt(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableInt boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableInt boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -129,6 +144,9 @@ <item name="org.apache.commons.lang.mutable.MutableLong MutableLong(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableLong boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableLong boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -155,6 +173,9 @@ <item name="org.apache.commons.lang.mutable.MutableLong void subtract(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableObject boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableObject boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -163,6 +184,9 @@ <item name="org.apache.commons.lang.mutable.MutableShort MutableShort(java.lang.Number) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.mutable.MutableShort boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.mutable.MutableShort boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/text/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/text/annotations.xml index d6d4e6ec1483..0e46f59ecbed 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/text/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/text/annotations.xml @@ -1,4 +1,7 @@ <root> + <item name="org.apache.commons.lang.text.ExtendedMessageFormat boolean containsElements(java.util.Collection) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.ExtendedMessageFormat boolean containsElements(java.util.Collection)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -60,11 +63,32 @@ <item name="org.apache.commons.lang.text.ExtendedMessageFormat void seekNonWs(java.lang.String, java.text.ParsePosition) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.ExtendedMessageFormat void setFormat(int, java.text.Format) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.ExtendedMessageFormat void setFormatByArgumentIndex(int, java.text.Format) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.ExtendedMessageFormat void setFormats(java.text.Format[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.ExtendedMessageFormat void setFormatsByArgumentIndex(java.text.Format[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder StrBuilder(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder boolean endsWith(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder boolean endsWith(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -80,16 +104,34 @@ <val val=""null->true""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder boolean startsWith(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder boolean startsWith(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder char[] getChars(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder char[] getChars(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder int indexOf(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder int indexOf(org.apache.commons.lang.text.StrMatcher, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder int lastIndexOf(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder int lastIndexOf(org.apache.commons.lang.text.StrMatcher, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder java.io.Reader asReader()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -120,60 +162,105 @@ <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(char[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(char[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.StringBuffer, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(java.lang.StringBuffer, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(org.apache.commons.lang.text.StrBuilder) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(org.apache.commons.lang.text.StrBuilder)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(org.apache.commons.lang.text.StrBuilder, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder append(org.apache.commons.lang.text.StrBuilder, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.lang.Object[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.lang.Object[])"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.util.Collection) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.util.Collection)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.util.Iterator) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendAll(java.util.Iterator)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendFixedWidthPadLeft(java.lang.Object, int, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendFixedWidthPadLeft(java.lang.Object, int, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendFixedWidthPadRight(java.lang.Object, int, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendFixedWidthPadRight(java.lang.Object, int, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendPadding(int, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -181,26 +268,44 @@ <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(char, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendSeparator(java.lang.String, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.lang.Object[], java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.lang.Object[], java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.lang.Object[], java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Collection, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Collection, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Collection, java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Iterator, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Iterator, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder appendWithSeparators(java.util.Iterator, java.lang.String)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder clear()"> <annotation name="org.jetbrains.annotations.NotNull"/> @@ -208,9 +313,18 @@ <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder delete(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder deleteAll(char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder deleteAll(java.lang.String)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder deleteCharAt(int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder deleteFirst(char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder deleteFirst(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -223,16 +337,28 @@ <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, char[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, char[], int, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, char[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null,_,_->!null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder insert(int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -242,34 +368,57 @@ <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replace(int, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replace(org.apache.commons.lang.text.StrMatcher, java.lang.String, int, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replace(org.apache.commons.lang.text.StrMatcher, java.lang.String, int, int, int)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_,_,_,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceAll(char, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceAll(java.lang.String, java.lang.String)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceFirst(char, char)"> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceFirst(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceImpl(org.apache.commons.lang.text.StrMatcher, java.lang.String, int, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder replaceImpl(org.apache.commons.lang.text.StrMatcher, java.lang.String, int, int, int)"> - <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null,_,_,_,_->!null""/> - </annotation> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder reverse()"> + <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder setCharAt(int, char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder setLength(int)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder setNewLineText(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder setNullText(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrBuilder trim()"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="org.apache.commons.lang.text.StrBuilder org.apache.commons.lang.text.StrTokenizer asTokenizer()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrBuilder.StrBuilderReader int read(char[], int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrBuilder.StrBuilderTokenizer java.util.List tokenize(char[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrLookup org.apache.commons.lang.text.StrLookup mapLookup(java.util.Map)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -279,6 +428,15 @@ <item name="org.apache.commons.lang.text.StrMatcher org.apache.commons.lang.text.StrMatcher charMatcher(char)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrMatcher org.apache.commons.lang.text.StrMatcher charSetMatcher(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrMatcher org.apache.commons.lang.text.StrMatcher charSetMatcher(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrMatcher org.apache.commons.lang.text.StrMatcher stringMatcher(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrMatcher.CharMatcher int isMatch(char[], int, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -288,27 +446,42 @@ <item name="org.apache.commons.lang.text.StrMatcher.CharSetMatcher int isMatch(char[], int, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrMatcher.NoMatcher int isMatch(char[], int, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrMatcher.StringMatcher StringMatcher(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrMatcher.TrimMatcher int isMatch(char[], int, int, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(java.lang.StringBuffer, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(java.lang.StringBuffer, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->false""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(org.apache.commons.lang.text.StrBuilder) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(org.apache.commons.lang.text.StrBuilder)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(org.apache.commons.lang.text.StrBuilder, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor boolean replaceIn(org.apache.commons.lang.text.StrBuilder, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->false""/> @@ -320,51 +493,84 @@ <item name="org.apache.commons.lang.text.StrSubstitutor int substitute(org.apache.commons.lang.text.StrBuilder, int, int, java.util.List) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor int substitute(org.apache.commons.lang.text.StrBuilder, int, int, java.util.List) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(char[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(char[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(char[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(char[], int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.StringBuffer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.StringBuffer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.StringBuffer, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(java.lang.StringBuffer, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(org.apache.commons.lang.text.StrBuilder) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(org.apache.commons.lang.text.StrBuilder)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(org.apache.commons.lang.text.StrBuilder, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String replace(org.apache.commons.lang.text.StrBuilder, int, int)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.commons.lang.text.StrSubstitutor java.lang.String resolveVariable(java.lang.String, org.apache.commons.lang.text.StrBuilder, int, int) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrSubstitutor org.apache.commons.lang.text.StrSubstitutor setVariablePrefix(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -386,37 +592,82 @@ <item name="org.apache.commons.lang.text.StrSubstitutor void checkCyclicSubstitution(java.lang.String, java.util.List) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String, char, char) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String, org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer StrTokenizer(java.lang.String, org.apache.commons.lang.text.StrMatcher, org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer int readWithQuotes(char[], int, int, org.apache.commons.lang.text.StrBuilder, java.util.List, int, int) 3"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrTokenizer java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer java.util.List tokenize(char[], int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer reset()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer reset(char[])"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer reset(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer reset(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setDelimiterMatcher(org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setDelimiterMatcher(org.apache.commons.lang.text.StrMatcher)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setDelimiterString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setEmptyTokenAsNull(boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setIgnoreEmptyTokens(boolean)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setIgnoredMatcher(org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setIgnoredMatcher(org.apache.commons.lang.text.StrMatcher)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setQuoteMatcher(org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setQuoteMatcher(org.apache.commons.lang.text.StrMatcher)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setTrimmerMatcher(org.apache.commons.lang.text.StrMatcher) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.text.StrTokenizer org.apache.commons.lang.text.StrTokenizer setTrimmerMatcher(org.apache.commons.lang.text.StrMatcher)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.text.StrTokenizer void add(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.text.StrTokenizer void set(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/time/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/time/annotations.xml index b392cffbce52..12183165228a 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/time/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/commons/lang/time/annotations.xml @@ -5,48 +5,90 @@ <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.TimeZone) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.TimeZone) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.TimeZone, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.TimeZone, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Calendar, java.lang.String, java.util.TimeZone, java.util.Locale) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.TimeZone) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.TimeZone) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.TimeZone, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.TimeZone, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(java.util.Date, java.lang.String, java.util.TimeZone, java.util.Locale) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.TimeZone) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.TimeZone) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.TimeZone, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.TimeZone, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String format(long, java.lang.String, java.util.TimeZone, java.util.Locale) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(java.util.Date, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(java.util.Date, java.lang.String, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(java.util.Date, java.lang.String, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(long, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(long, java.lang.String, java.util.Locale) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DateFormatUtils java.lang.String formatUTC(long, java.lang.String, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DateUtils boolean isSameDay(java.util.Calendar, java.util.Calendar) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -296,6 +338,9 @@ <item name="org.apache.commons.lang.time.DurationFormatUtils java.lang.String formatDurationISO(long)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DurationFormatUtils java.lang.String formatDurationWords(long, boolean, boolean)"> + <annotation name="org.jetbrains.annotations.NotNull"/> + </item> <item name="org.apache.commons.lang.time.DurationFormatUtils java.lang.String formatPeriod(long, long, java.lang.String) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -317,6 +362,12 @@ <item name="org.apache.commons.lang.time.DurationFormatUtils.Token boolean containsTokenWithValue(org.apache.commons.lang.time.DurationFormatUtils.Token[], java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.DurationFormatUtils.Token boolean containsTokenWithValue(org.apache.commons.lang.time.DurationFormatUtils.Token[], java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.DurationFormatUtils.Token boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.DurationFormatUtils.Token boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -325,11 +376,23 @@ <item name="org.apache.commons.lang.time.FastDateFormat FastDateFormat(java.lang.String, java.util.TimeZone, java.util.Locale) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat FastDateFormat(java.lang.String, java.util.TimeZone, java.util.Locale) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.FastDateFormat FastDateFormat(java.lang.String, java.util.TimeZone, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.FastDateFormat boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.commons.lang.time.FastDateFormat java.lang.Object parseObject(java.lang.String, java.text.ParsePosition) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat java.lang.Object parseObject(java.lang.String, java.text.ParsePosition) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -367,6 +430,9 @@ <item name="org.apache.commons.lang.time.FastDateFormat java.lang.StringBuffer format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat java.lang.StringBuffer format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat java.lang.StringBuffer format(java.util.Date, java.lang.StringBuffer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -376,12 +442,24 @@ <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.Locale) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.Locale) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.TimeZone) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.TimeZone) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.TimeZone, java.util.Locale) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.TimeZone, java.util.Locale) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat getInstance(java.lang.String, java.util.TimeZone, java.util.Locale) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat org.apache.commons.lang.time.FastDateFormat.NumberRule selectNumberRule(int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -391,6 +469,9 @@ <item name="org.apache.commons.lang.time.FastDateFormat.CharacterLiteral void appendTo(java.lang.StringBuffer, java.util.Calendar) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat.CharacterLiteral void appendTo(java.lang.StringBuffer, java.util.Calendar) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat.PaddedNumberField void appendTo(java.lang.StringBuffer, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -400,18 +481,27 @@ <item name="org.apache.commons.lang.time.FastDateFormat.PaddedNumberField void appendTo(java.lang.StringBuffer, java.util.Calendar) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat.Pair boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat.Pair java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.FastDateFormat.StringLiteral void appendTo(java.lang.StringBuffer, java.util.Calendar) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat.StringLiteral void appendTo(java.lang.StringBuffer, java.util.Calendar) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat.TextField void appendTo(java.lang.StringBuffer, java.util.Calendar) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.commons.lang.time.FastDateFormat.TextField void appendTo(java.lang.StringBuffer, java.util.Calendar) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.commons.lang.time.FastDateFormat.TimeZoneDisplayKey boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.commons.lang.time.FastDateFormat.TimeZoneNameRule void appendTo(java.lang.StringBuffer, java.util.Calendar) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/anakia/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/anakia/annotations.xml index a2e1c91b68a7..81935a0dc483 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/anakia/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/anakia/annotations.xml @@ -29,6 +29,9 @@ <item name="org.apache.velocity.anakia.AnakiaJDOMFactory org.jdom.Element element(java.lang.String, org.jdom.Namespace)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.anakia.AnakiaTask java.lang.String getRelativePath(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.anakia.AnakiaTask java.lang.String getRelativePath(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> @@ -70,6 +73,9 @@ <item name="org.apache.velocity.anakia.NodeList NodeList(org.jdom.Element) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.anakia.NodeList boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.anakia.NodeList boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -81,6 +87,9 @@ <item name="org.apache.velocity.anakia.NodeList org.apache.velocity.anakia.NodeList selectNodes(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.anakia.NodeList.AttributeXMLOutputter AttributeXMLOutputter(org.apache.velocity.anakia.NodeList.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.anakia.NodeList.AttributeXMLOutputter void output(org.jdom.Attribute, java.io.Writer) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/annotations.xml new file mode 100644 index 000000000000..7ef87f095569 --- /dev/null +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/annotations.xml @@ -0,0 +1,8 @@ +<root> + <item name="org.apache.velocity.VelocityContext VelocityContext(java.util.Map) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.VelocityContext VelocityContext(java.util.Map, org.apache.velocity.context.Context) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> +</root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/annotations.xml index ad9def7fd362..d1987cbafc38 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/annotations.xml @@ -1,14 +1,23 @@ <root> + <item name="org.apache.velocity.app.event.EventCartridge boolean addEventHandler(org.apache.velocity.app.event.EventHandler) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.EventCartridge boolean addEventHandler(org.apache.velocity.app.event.EventHandler)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.velocity.app.event.EventCartridge boolean attachToContext(org.apache.velocity.context.Context) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.EventCartridge boolean attachToContext(org.apache.velocity.context.Context)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.velocity.app.event.EventCartridge boolean removeEventHandler(org.apache.velocity.app.event.EventHandler) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.EventCartridge boolean removeEventHandler(org.apache.velocity.app.event.EventHandler)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -59,12 +68,24 @@ <item name="org.apache.velocity.app.event.EventHandlerUtil java.lang.String includeEvent(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.EventHandlerUtil void callEventHandlers(java.util.Iterator, java.util.Iterator, org.apache.velocity.app.event.EventHandlerMethodExecutor) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.EventHandlerUtil void callEventHandlers(java.util.Iterator, java.util.Iterator, org.apache.velocity.app.event.EventHandlerMethodExecutor) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.EventHandlerUtil void initializeEventCartridge(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.app.event.EventCartridge) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.EventHandlerUtil void invalidSetMethod(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, org.apache.velocity.util.introspection.Info) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.app.event.EventHandlerUtil void invalidSetMethod(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, org.apache.velocity.util.introspection.Info) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.EventHandlerUtil void iterateOverEventHandlers(java.util.Iterator, org.apache.velocity.app.event.EventHandlerMethodExecutor) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.IncludeEventHandler.IncludeEventExecutor void execute(org.apache.velocity.app.event.EventHandler) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/implement/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/implement/annotations.xml index 5591ed681847..643ea130fd54 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/implement/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/event/implement/annotations.xml @@ -31,12 +31,21 @@ <item name="org.apache.velocity.app.event.implement.EscapeXmlReference java.lang.String getMatchAttribute()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.implement.IncludeNotFound java.lang.String includeEvent(java.lang.String, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.IncludeNotFound java.lang.String includeEvent(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.IncludeNotFound void setRuntimeServices(org.apache.velocity.runtime.RuntimeServices) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.app.event.implement.IncludeRelativePath java.lang.String includeEvent(java.lang.String, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.implement.IncludeRelativePath java.lang.String includeEvent(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.IncludeRelativePath java.lang.String includeEvent(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null""/> @@ -48,6 +57,12 @@ <item name="org.apache.velocity.app.event.implement.InvalidReferenceInfo java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.implement.PrintExceptions java.lang.Object methodException(java.lang.Class, java.lang.String, java.lang.Exception) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.PrintExceptions java.lang.Object methodException(java.lang.Class, java.lang.String, java.lang.Exception) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.PrintExceptions java.lang.Object methodException(java.lang.Class, java.lang.String, java.lang.Exception) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -57,6 +72,12 @@ <item name="org.apache.velocity.app.event.implement.PrintExceptions java.lang.String getStackTrace(java.lang.Throwable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences boolean invalidSetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.String, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences boolean invalidSetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.String, org.apache.velocity.util.introspection.Info) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences boolean invalidSetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.String, org.apache.velocity.util.introspection.Info) 3"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -65,6 +86,15 @@ <val val=""!null,_,_,_->false;_,!null,_,_->false;_,_,!null,_->false;_,_,_,!null->false;_,_,_,null->false;_,_,null,_->false;_,null,_,_->false;null,_,_,_->false""/> </annotation> </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidGetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidGetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidGetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidGetMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 4"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -73,6 +103,15 @@ <val val=""!null,_,_,_,_->null;_,!null,_,_,_->null;_,_,!null,_,_->null;_,_,_,!null,_->null;_,_,_,_,!null->null;_,_,_,_,null->null;_,_,_,null,_->null;_,_,null,_,_->null;_,null,_,_,_->null;null,_,_,_,_->null""/> </annotation> </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.event.implement.ReportInvalidReferences java.lang.Object invalidMethod(org.apache.velocity.context.Context, java.lang.String, java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 4"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/tools/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/tools/annotations.xml index 855a668ec63b..0117ad6dfb45 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/tools/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/app/tools/annotations.xml @@ -1,15 +1,30 @@ <root> + <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.Object isNull(java.lang.Object, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.Object isNull(java.lang.Object, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->!null""/> </annotation> </item> + <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatArray(java.lang.Object, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatArray(java.lang.Object, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatArray(java.lang.Object, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatVector(java.util.List, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatVector(java.util.List, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatVector(java.util.List, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.app.tools.VelocityFormatter java.lang.String formatVector(java.util.List, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/context/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/context/annotations.xml index 2e739fb35c61..62279b8f44db 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/context/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/context/annotations.xml @@ -1,19 +1,31 @@ <root> + <item name="org.apache.velocity.context.AbstractContext boolean containsKey(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.context.AbstractContext boolean containsKey(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.velocity.context.AbstractContext java.lang.Object get(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.context.AbstractContext java.lang.Object get(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> </annotation> </item> + <item name="org.apache.velocity.context.AbstractContext java.lang.Object put(java.lang.String, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.context.AbstractContext java.lang.Object put(java.lang.String, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> </annotation> </item> + <item name="org.apache.velocity.context.AbstractContext java.lang.Object remove(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.context.AbstractContext java.lang.Object remove(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->null""/> @@ -31,6 +43,12 @@ <item name="org.apache.velocity.context.ProxyVMContext boolean isConstant(org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.context.ProxyVMContext void addVMProxyArg(org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, org.apache.velocity.runtime.Renderable) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.context.ProxyVMContext void addVMProxyArg(org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, org.apache.velocity.runtime.Renderable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.context.ProxyVMContext void addVMProxyArg(org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.String, org.apache.velocity.runtime.parser.node.Node) 3"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/convert/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/convert/annotations.xml index 8303b86a3cba..0f266c90651e 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/convert/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/convert/annotations.xml @@ -2,6 +2,9 @@ <item name="org.apache.velocity.convert.WebMacro boolean writeTemplate(java.lang.String, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.convert.WebMacro boolean writeTemplate(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.convert.WebMacro boolean writeTemplate(java.lang.String, java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null,_->false""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/exception/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/exception/annotations.xml index d7d2ee1dcb64..d9611079bfb5 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/exception/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/exception/annotations.xml @@ -11,7 +11,13 @@ <item name="org.apache.velocity.exception.ParseErrorException ParseErrorException(org.apache.velocity.exception.VelocityException, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.exception.ParseErrorException ParseErrorException(org.apache.velocity.exception.VelocityException, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.exception.ParseErrorException ParseErrorException(org.apache.velocity.runtime.parser.ParseException, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.exception.ParseErrorException ParseErrorException(org.apache.velocity.runtime.parser.ParseException, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/io/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/io/annotations.xml index 75ca57304d5b..f55b4257f29a 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/io/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/io/annotations.xml @@ -2,7 +2,16 @@ <item name="org.apache.velocity.io.UnicodeInputStream org.apache.velocity.io.UnicodeInputStream.UnicodeBOM match(org.apache.velocity.io.UnicodeInputStream.UnicodeBOM, org.apache.velocity.io.UnicodeInputStream.UnicodeBOM) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.io.UnicodeInputStream void pushback(org.apache.velocity.io.UnicodeInputStream.UnicodeBOM) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.io.UnicodeInputStream.UnicodeBOM UnicodeBOM(java.lang.String, byte[], org.apache.velocity.io.UnicodeInputStream.1) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.io.VelocityWriter void write(char[]) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.io.VelocityWriter void write(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/annotations.xml index 457ea7d9dd4b..1dd01a70efdd 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/annotations.xml @@ -31,6 +31,12 @@ <val val=""!null,_,_,_->true;_,!null,_,_->true;_,_,!null,_->true;_,_,_,!null->true;_,_,_,null->true;_,_,null,_->true;_,null,_,_->true;null,_,_,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.RuntimeInstance org.apache.velocity.app.event.EventHandler initializeSpecificEventHandler(java.lang.String, java.lang.String, java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.RuntimeInstance org.apache.velocity.app.event.EventHandler initializeSpecificEventHandler(java.lang.String, java.lang.String, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.RuntimeInstance org.apache.velocity.app.event.EventHandler initializeSpecificEventHandler(java.lang.String, java.lang.String, java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->null;null,_,_->null""/> @@ -81,6 +87,9 @@ <item name="org.apache.velocity.runtime.VelocimacroFactory boolean addVelocimacro(java.lang.String, org.apache.velocity.runtime.parser.node.Node, java.lang.String[], java.lang.String) 3"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.VelocimacroFactory.Twonk Twonk(org.apache.velocity.runtime.VelocimacroFactory.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.VelocimacroManager boolean addVM(java.lang.String, org.apache.velocity.runtime.parser.node.Node, java.lang.String[], java.lang.String, boolean) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -89,10 +98,22 @@ <val val=""!null,_,_,_,_->true;_,!null,_,_,_->true;_,_,!null,_,_->true;_,_,_,!null,_->true;_,_,_,_,false->true;_,_,_,_,true->true;_,_,_,null,_->true;_,_,null,_,_->true;null,_,_,_,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.VelocimacroManager boolean usingNamespaces(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.VelocimacroManager org.apache.velocity.runtime.directive.VelocimacroProxy get(java.lang.String, java.lang.String, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.VelocimacroManager.MacroEntry MacroEntry(java.lang.String, org.apache.velocity.runtime.parser.node.Node, java.lang.String[], java.lang.String, org.apache.velocity.runtime.RuntimeServices) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.VelocimacroManager.MacroEntry MacroEntry(java.lang.String, org.apache.velocity.runtime.parser.node.Node, java.lang.String[], java.lang.String, org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.runtime.VelocimacroManager.1) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.VelocimacroManager.MacroEntry MacroEntry(java.lang.String, org.apache.velocity.runtime.parser.node.Node, java.lang.String[], java.lang.String, org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.runtime.VelocimacroManager.1) 5"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.VelocimacroManager.MacroEntry org.apache.velocity.runtime.directive.VelocimacroProxy getProxy(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/directive/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/directive/annotations.xml index f6cd67632cb8..e9d35d5e61e8 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/directive/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/directive/annotations.xml @@ -5,6 +5,9 @@ <item name="org.apache.velocity.runtime.directive.Block void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Block void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Block void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -14,6 +17,9 @@ <item name="org.apache.velocity.runtime.directive.BlockMacro void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Break boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Break boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -25,12 +31,21 @@ <item name="org.apache.velocity.runtime.directive.Break java.lang.String getName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Break void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Break void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.directive.Define boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Define boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Define boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Define boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->true;_,!null,_->true;_,_,!null->true;_,_,null->true;_,null,_->true""/> @@ -42,12 +57,24 @@ <item name="org.apache.velocity.runtime.directive.Define void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Define void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Define void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Directive org.apache.velocity.runtime.directive.Scope makeScope(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Directive org.apache.velocity.runtime.directive.Scope makeScope(java.lang.Object)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Directive void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Directive void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Evaluate boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -74,12 +101,36 @@ <item name="org.apache.velocity.runtime.directive.Foreach void clean(org.apache.velocity.context.InternalContextAdapter, java.lang.Object, java.lang.Object, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Foreach void clean(org.apache.velocity.context.InternalContextAdapter, java.lang.Object, java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Foreach void clean(org.apache.velocity.context.InternalContextAdapter, java.lang.Object, java.lang.Object, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Foreach void clean(org.apache.velocity.context.InternalContextAdapter, java.lang.Object, java.lang.Object, java.lang.Object) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Foreach void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Foreach void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.directive.Foreach void put(org.apache.velocity.context.InternalContextAdapter, java.lang.String, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Foreach.NullHolderContext NullHolderContext(java.lang.String, org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Foreach.NullHolderContext NullHolderContext(java.lang.String, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.directive.Foreach.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Foreach.NullHolderContext NullHolderContext(java.lang.String, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.directive.Foreach.1) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.ForeachScope ForeachScope(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Include boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -88,6 +139,9 @@ <val val=""!null,_,_->true;_,!null,_->true;_,_,!null->true;_,null,_->true;null,_,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.directive.Include boolean renderOutput(org.apache.velocity.runtime.parser.node.Node, org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Include boolean renderOutput(org.apache.velocity.runtime.parser.node.Node, org.apache.velocity.context.InternalContextAdapter, java.io.Writer)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,null,_->false;null,_,_->false""/> @@ -99,9 +153,15 @@ <item name="org.apache.velocity.runtime.directive.InputBase java.lang.String getInputEncoding(org.apache.velocity.context.InternalContextAdapter) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Literal boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Literal boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Literal boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Literal boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->true;_,!null,_->true;_,_,!null->true;_,_,null->true;null,_,_->true""/> @@ -110,9 +170,21 @@ <item name="org.apache.velocity.runtime.directive.Literal java.lang.String getName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Literal void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Literal void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Macro boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Macro boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Macro boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Macro boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->true;_,!null,_->true;_,_,!null->true;_,_,null->true;_,null,_->true;null,_,_->true""/> @@ -121,6 +193,9 @@ <item name="org.apache.velocity.runtime.directive.Macro java.lang.String getName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Macro java.lang.StringBuffer macroToString(java.lang.StringBuffer, java.lang.String[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Macro java.lang.StringBuffer macroToString(java.lang.StringBuffer, java.lang.String[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -138,9 +213,15 @@ <item name="org.apache.velocity.runtime.directive.Macro void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Macro void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Macro void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.MacroParseException MacroParseException(java.lang.String, java.lang.String, org.apache.velocity.runtime.parser.Token) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.MacroParseException java.lang.String getMessage()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -171,15 +252,27 @@ <item name="org.apache.velocity.runtime.directive.RuntimeMacro void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Scope Scope(java.lang.Object, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.directive.Scope.Info Info(org.apache.velocity.runtime.directive.Scope, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Scope.Info java.lang.String toString()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Stop boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Stop boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.directive.Stop java.lang.String getName()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.directive.Stop void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.Stop void init(org.apache.velocity.runtime.RuntimeServices, org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.Node) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -194,6 +287,9 @@ <val val=""!null,_,_,_->true;_,!null,_,_->true;_,_,!null,_->true;_,_,_,!null->true;_,_,_,null->true;_,null,_,_->true;null,_,_,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.directive.VelocimacroProxy java.lang.String buildErrorMsg(org.apache.velocity.runtime.parser.node.Node, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.directive.VelocimacroProxy java.lang.String buildErrorMsg(org.apache.velocity.runtime.parser.node.Node, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/log/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/log/annotations.xml index b49c0f73e389..f3dd5bc117e1 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/log/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/log/annotations.xml @@ -8,9 +8,18 @@ <item name="org.apache.velocity.runtime.log.CommonsLogLogChute void init(org.apache.velocity.runtime.RuntimeServices) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.HoldingLogChute void init(org.apache.velocity.runtime.RuntimeServices) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.JdkLogChute void init(org.apache.velocity.runtime.RuntimeServices) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.JdkLogChute void log(int, java.lang.String, java.lang.Throwable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.Log java.lang.String formatFileString(java.lang.String, int, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.Log java.lang.String formatFileString(java.lang.String, int, int)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -32,12 +41,30 @@ <item name="org.apache.velocity.runtime.log.Log java.lang.String formatFileString(org.apache.velocity.util.introspection.Info)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.Log void log(int, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.Log void log(int, java.lang.Object, java.lang.Throwable) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.Log void setLogChute(org.apache.velocity.runtime.log.LogChute) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.log.LogDisplayWrapper LogDisplayWrapper(org.apache.velocity.runtime.log.Log, java.lang.String, boolean) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.LogDisplayWrapper void log(boolean, int, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.LogDisplayWrapper void log(boolean, int, java.lang.Object, java.lang.Throwable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.LogDisplayWrapper void log(int, java.lang.Object, java.lang.Throwable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.LogManager boolean isProbablyProvidedLogChute(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.LogManager boolean isProbablyProvidedLogChute(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -52,15 +79,39 @@ <item name="org.apache.velocity.runtime.log.LogManager void updateLog(org.apache.velocity.runtime.log.Log, org.apache.velocity.runtime.RuntimeServices) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.NullLogChute void init(org.apache.velocity.runtime.RuntimeServices) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.NullLogChute void log(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.NullLogChute void log(int, java.lang.String, java.lang.Throwable) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.NullLogChute void log(int, java.lang.String, java.lang.Throwable) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.NullLogSystem void logVelocityMessage(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.RuntimeLoggerLog RuntimeLoggerLog(org.apache.velocity.runtime.RuntimeLogger) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.RuntimeLoggerLog void setLogChute(org.apache.velocity.runtime.log.LogChute) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.ServletLogChute int toLevel(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.log.ServletLogChute void init(org.apache.velocity.runtime.RuntimeServices) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.ServletLogChute void log(int, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.ServletLogChute void log(int, java.lang.String, java.lang.Throwable) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.log.SystemLogChute int toLevel(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -73,4 +124,10 @@ <item name="org.apache.velocity.runtime.log.SystemLogChute void write(java.io.PrintStream, java.lang.String, java.lang.String, java.lang.Throwable) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.log.SystemLogChute void write(java.io.PrintStream, java.lang.String, java.lang.String, java.lang.Throwable) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.log.VelocityFormatter java.lang.String getTime(long, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> </root> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/annotations.xml index 7d0bc8cdefa1..88ac417b986d 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/annotations.xml @@ -1,4 +1,7 @@ <root> + <item name="org.apache.velocity.runtime.parser.JJTParserState void clearNodeScope(org.apache.velocity.runtime.parser.node.Node) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.JJTParserState void closeNodeScope(org.apache.velocity.runtime.parser.node.Node, int) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -25,9 +28,18 @@ <item name="org.apache.velocity.runtime.parser.Parser org.apache.velocity.runtime.parser.ParseException generateParseException()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.Parser.LookaheadSuccess LookaheadSuccess(org.apache.velocity.runtime.parser.Parser.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.ParserTokenManager org.apache.velocity.runtime.parser.Token jjFillToken()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.ParserTokenManager void SkipLexicalActions(org.apache.velocity.runtime.parser.Token) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.ParserTokenManager.ParserState ParserState(org.apache.velocity.runtime.parser.ParserTokenManager.1) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.TemplateParseException java.lang.String getMessage()"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/node/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/node/annotations.xml index 5f78c94ea501..b6a2face76a9 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/node/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/parser/node/annotations.xml @@ -5,6 +5,15 @@ <item name="org.apache.velocity.runtime.parser.node.ASTAddNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTAddNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTAddNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTAddNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTAndNode java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -19,6 +28,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTBlock java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTComment boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTComment boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -27,6 +39,9 @@ <val val=""!null,_->true;_,!null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTComment java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTComment java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -57,6 +72,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTElseIfStatement java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTElseStatement boolean evaluate(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTElseStatement boolean evaluate(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->true;null->true""/> @@ -65,6 +83,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTElseStatement java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTEscape boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTEscape boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -73,6 +94,9 @@ <val val=""!null,_->true;_,!null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTEscape java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTEscape java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -81,6 +105,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTEscape java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTEscapedDirective boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTEscapedDirective boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -95,6 +122,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTExpression java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTFalse boolean evaluate(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTFalse boolean evaluate(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -103,6 +133,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTFalse java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTFalse java.lang.Object value(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTFloatingPointLiteral java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -111,6 +144,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTFloatingPointLiteral java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTFloatingPointLiteral java.lang.Object value(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTGENode java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -136,6 +172,12 @@ <item name="org.apache.velocity.runtime.parser.node.ASTIfStatement java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTIfStatement void process(org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.ParserVisitor) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTIfStatement void process(org.apache.velocity.context.InternalContextAdapter, org.apache.velocity.runtime.parser.node.ParserVisitor) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTIncludeStatement java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -160,6 +202,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTIntegerLiteral java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTIntegerLiteral java.lang.Object value(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTIntegerRange java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -172,6 +217,15 @@ <item name="org.apache.velocity.runtime.parser.node.ASTMap java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMathNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMathNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMathNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTMathNode java.lang.Object handleSpecial(java.lang.Object, java.lang.Object, org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->null;_,!null,_->null;_,_,!null->null;_,_,null->null;_,null,_->null;null,_,_->null""/> @@ -205,6 +259,15 @@ <item name="org.apache.velocity.runtime.parser.node.ASTMethod java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMethod.MethodCacheKey MethodCacheKey(java.lang.String, java.lang.Class[]) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMethod.MethodCacheKey MethodCacheKey(java.lang.String, java.lang.Class[]) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMethod.MethodCacheKey boolean equals(java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTMethod.MethodCacheKey boolean equals(java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -219,6 +282,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTMulNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTMulNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTNENode java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -239,6 +305,9 @@ <val val=""!null,_->true;_,!null->true;_,null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTReference java.lang.Object execute(java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTReference java.lang.Object getVariableValue(org.apache.velocity.context.Context, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -256,11 +325,17 @@ <item name="org.apache.velocity.runtime.parser.node.ASTReference java.lang.String getNullString(org.apache.velocity.context.InternalContextAdapter) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTReference java.lang.String printClass(java.lang.Class) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTReference java.lang.String printClass(java.lang.Class)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->!null""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTSetDirective boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTSetDirective java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -292,6 +367,12 @@ <item name="org.apache.velocity.runtime.parser.node.ASTSubtractNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTSubtractNode java.lang.Number perform(java.lang.Number, java.lang.Number, org.apache.velocity.context.InternalContextAdapter) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.ASTText boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTText boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -300,6 +381,9 @@ <val val=""!null,_->true;_,!null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTText java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTText java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -308,6 +392,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTText java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTTextblock boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTTextblock boolean render(org.apache.velocity.context.InternalContextAdapter, java.io.Writer) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -316,6 +403,9 @@ <val val=""!null,_->true;_,!null->true;null,_->true""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTTextblock java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTTextblock java.lang.Object init(org.apache.velocity.context.InternalContextAdapter, java.lang.Object)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,!null->!null;_,null->null""/> @@ -324,6 +414,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTTextblock java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTTrue boolean evaluate(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTTrue boolean evaluate(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->true;null->true""/> @@ -332,6 +425,9 @@ <item name="org.apache.velocity.runtime.parser.node.ASTTrue java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.ASTTrue java.lang.Object value(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.ASTVariable java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -344,9 +440,18 @@ <item name="org.apache.velocity.runtime.parser.node.BooleanPropertyExecutor BooleanPropertyExecutor(org.apache.velocity.runtime.RuntimeLogger, org.apache.velocity.util.introspection.Introspector, java.lang.Class, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.BooleanPropertyExecutor void discover(java.lang.Class, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.GetExecutor GetExecutor(org.apache.velocity.runtime.RuntimeLogger, org.apache.velocity.util.introspection.Introspector, java.lang.Class, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.GetExecutor GetExecutor(org.apache.velocity.runtime.RuntimeLogger, org.apache.velocity.util.introspection.Introspector, java.lang.Class, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.GetExecutor GetExecutor(org.apache.velocity.runtime.log.Log, org.apache.velocity.util.introspection.Introspector, java.lang.Class, java.lang.String) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.MapGetExecutor java.lang.Object execute(java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -401,6 +506,9 @@ <item name="org.apache.velocity.runtime.parser.node.MathUtils java.lang.Number subtract(java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.MathUtils java.lang.Number wrapPrimitive(long, java.lang.Class) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.MathUtils java.lang.Number wrapPrimitive(long, java.lang.Number, java.lang.Number) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -433,6 +541,12 @@ <item name="org.apache.velocity.runtime.parser.node.PropertyExecutor PropertyExecutor(org.apache.velocity.runtime.RuntimeLogger, org.apache.velocity.util.introspection.Introspector, java.lang.Class, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.PropertyExecutor void discover(java.lang.Class, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode boolean evaluate(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.SimpleNode boolean evaluate(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -448,6 +562,12 @@ <val val=""_,!null->!null;_,null->null""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object execute(java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object execute(java.lang.Object, org.apache.velocity.context.InternalContextAdapter) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object execute(java.lang.Object, org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_->null;_,!null->null;_,null->null;null,_->null""/> @@ -461,14 +581,23 @@ <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object jjtAccept(org.apache.velocity.runtime.parser.node.ParserVisitor, java.lang.Object) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object value(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.Object value(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->null;null->null""/> </annotation> </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.String getLocation(org.apache.velocity.context.InternalContextAdapter) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.String getLocation(org.apache.velocity.context.InternalContextAdapter)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.String toString(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.parser.node.SimpleNode java.lang.String toString(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/annotations.xml index c85589b43d33..6d9f27bfe3ff 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/annotations.xml @@ -1,4 +1,10 @@ <root> + <item name="org.apache.velocity.runtime.resource.ResourceFactory org.apache.velocity.runtime.resource.Resource getResource(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.resource.ResourceManagerImpl org.apache.velocity.runtime.resource.Resource createResource(java.lang.String, int) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.ResourceManagerImpl org.apache.velocity.runtime.resource.Resource refreshResource(org.apache.velocity.runtime.resource.Resource, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/loader/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/loader/annotations.xml index 5fc5b3a6b8f0..ca5b1efb729c 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/loader/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/runtime/resource/loader/annotations.xml @@ -1,4 +1,7 @@ <root> + <item name="org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->false;null->false""/> @@ -7,6 +10,12 @@ <item name="org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader java.io.InputStream getResourceStream(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader long getLastModified(org.apache.velocity.runtime.resource.Resource) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader void init(org.apache.commons.collections.ExtendedProperties) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -16,41 +25,71 @@ <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader java.sql.PreparedStatement getStatement(java.sql.Connection, java.lang.String, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader java.sql.PreparedStatement getStatement(java.sql.Connection, java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader long getLastModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader long readLastModified(org.apache.velocity.runtime.resource.Resource, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader long readLastModified(org.apache.velocity.runtime.resource.Resource, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader void closeDbConnection(java.sql.Connection) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader void closeResultSet(java.sql.ResultSet) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader void closeStatement(java.sql.PreparedStatement) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader void init(org.apache.commons.collections.ExtendedProperties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader boolean resourceExists(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader boolean resourceExists(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> </annotation> </item> + <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader java.io.File getFile(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader java.io.File getFile(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader java.io.File getFile(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader java.io.InputStream findTemplate(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader java.io.InputStream getResourceStream(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader long getLastModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader void closeQuiet(java.io.InputStream) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.FileResourceLoader void init(org.apache.commons.collections.ExtendedProperties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.runtime.resource.loader.JarHolder JarHolder(org.apache.velocity.runtime.RuntimeServices, java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.JarResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.JarResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->true;null->true""/> @@ -59,6 +98,9 @@ <item name="org.apache.velocity.runtime.resource.loader.JarResourceLoader java.io.InputStream getResourceStream(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.JarResourceLoader long getLastModified(org.apache.velocity.runtime.resource.Resource) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.JarResourceLoader void init(org.apache.commons.collections.ExtendedProperties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -74,6 +116,9 @@ <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader boolean isSourceModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader boolean resourceExists(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader boolean resourceExists(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null->false""/> @@ -85,6 +130,9 @@ <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader long getLastModified(org.apache.velocity.runtime.resource.Resource) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader org.apache.velocity.runtime.resource.util.StringResourceRepository createRepository(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.runtime.resource.loader.StringResourceLoader void init(org.apache.commons.collections.ExtendedProperties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/servlet/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/servlet/annotations.xml index a1d5f80fe4ca..8c2789a533bf 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/servlet/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/servlet/annotations.xml @@ -1,13 +1,28 @@ <root> + <item name="org.apache.velocity.servlet.VelocityServlet java.lang.String chooseCharacterEncoding(javax.servlet.http.HttpServletRequest) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.servlet.VelocityServlet java.util.Properties loadConfiguration(javax.servlet.ServletConfig) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> <item name="org.apache.velocity.servlet.VelocityServlet java.util.Properties loadConfiguration(javax.servlet.ServletConfig)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.servlet.VelocityServlet org.apache.velocity.Template handleRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.apache.velocity.context.Context) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.servlet.VelocityServlet org.apache.velocity.Template handleRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.apache.velocity.context.Context) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.servlet.VelocityServlet org.apache.velocity.Template handleRequest(org.apache.velocity.context.Context) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.servlet.VelocityServlet org.apache.velocity.context.Context createContext(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.servlet.VelocityServlet void error(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Exception) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.servlet.VelocityServlet void error(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Exception) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -17,6 +32,15 @@ <item name="org.apache.velocity.servlet.VelocityServlet void mergeTemplate(org.apache.velocity.Template, org.apache.velocity.context.Context, javax.servlet.http.HttpServletResponse) 2"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.servlet.VelocityServlet void requestCleanup(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.apache.velocity.context.Context) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.servlet.VelocityServlet void requestCleanup(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.apache.velocity.context.Context) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.servlet.VelocityServlet void requestCleanup(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, org.apache.velocity.context.Context) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.servlet.VelocityServlet void setContentType(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/annotations.xml index bea0f093ad72..8dbb538e058e 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/annotations.xml @@ -1,10 +1,37 @@ <root> + <item name="org.apache.velocity.texen.Generator Generator(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.texen.Generator Generator(java.util.Properties) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.texen.Generator java.io.Writer getWriter(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator java.io.Writer getWriter(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.texen.Generator java.io.Writer getWriter(java.lang.String, java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.texen.Generator java.lang.String parse(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator java.lang.String parse(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator java.lang.String parse(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator java.lang.String parse(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 4"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator java.lang.String parse(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Object) 5"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.texen.Generator org.apache.velocity.Template getTemplate(java.lang.String, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.texen.Generator void fillContextDefaults(org.apache.velocity.context.Context) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/util/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/util/annotations.xml index 353ade77c7bc..20c60fde4b7b 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/util/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/texen/util/annotations.xml @@ -5,6 +5,9 @@ <item name="org.apache.velocity.texen.util.FileUtil java.io.File file(java.lang.String)"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.texen.util.FileUtil java.io.File file(java.lang.String, java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.texen.util.FileUtil java.io.File file(java.lang.String, java.lang.String) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/annotations.xml index e60004f3fd63..8b1334446ad3 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/annotations.xml @@ -27,6 +27,9 @@ <val val=""!null,_->!null;null,_->null""/> </annotation> </item> + <item name="org.apache.velocity.util.StringUtils java.lang.String chop(java.lang.String, int, java.lang.String) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.StringUtils java.lang.String chop(java.lang.String, int, java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null,_,_->!null;null,_,_->null""/> @@ -65,9 +68,12 @@ <item name="org.apache.velocity.util.StringUtils java.lang.String normalizePath(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.util.StringUtils java.lang.String nullTrim(java.lang.String) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.StringUtils java.lang.String nullTrim(java.lang.String)"> <annotation name="org.jetbrains.annotations.Contract"> - <val val=""null->null""/> + <val val=""!null->!null;null->null""/> </annotation> </item> <item name="org.apache.velocity.util.StringUtils java.lang.String removeAndHump(java.lang.String)"> @@ -101,6 +107,9 @@ <item name="org.apache.velocity.util.StringUtils java.lang.StringBuffer stringSubstitution(java.lang.String, java.util.Map) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.util.StringUtils java.util.List trimStrings(java.util.List) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.StringUtils java.util.List trimStrings(java.util.List)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""!null->!null;null->null""/> diff --git a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/introspection/annotations.xml b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/introspection/annotations.xml index 4518a467c463..4fd41ea336be 100644 --- a/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/introspection/annotations.xml +++ b/java/java-tests/testData/codeInspection/bytecodeAnalysis/annotations/org/apache/velocity/util/introspection/annotations.xml @@ -5,6 +5,9 @@ <item name="org.apache.velocity.util.introspection.ClassMap void populateMethodCacheWithInterface(org.apache.velocity.util.introspection.ClassMap.MethodCache, java.lang.Class) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.util.introspection.ClassMap.MethodCache MethodCache(org.apache.velocity.runtime.log.Log, org.apache.velocity.util.introspection.ClassMap.1) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.ClassMap.MethodCache java.lang.String makeMethodKey(java.lang.String, java.lang.Object[]) 1"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> @@ -90,11 +93,20 @@ <item name="org.apache.velocity.util.introspection.MethodMap void add(java.lang.reflect.Method) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.util.introspection.SecureIntrospectorImpl boolean checkObjectExecutePermission(java.lang.Class, java.lang.String) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.SecureIntrospectorImpl java.lang.reflect.Method getMethod(java.lang.Class, java.lang.String, java.lang.Object[])"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""_,_,null->null;null,_,_->null""/> </annotation> </item> + <item name="org.apache.velocity.util.introspection.SecureUberspector java.util.Iterator getIterator(java.lang.Object, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.util.introspection.SecureUberspector java.util.Iterator getIterator(java.lang.Object, org.apache.velocity.util.introspection.Info) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.SecureUberspector java.util.Iterator getIterator(java.lang.Object, org.apache.velocity.util.introspection.Info)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_->null""/> @@ -103,16 +115,37 @@ <item name="org.apache.velocity.util.introspection.UberspectImpl java.util.Iterator getIterator(java.lang.Object, org.apache.velocity.util.introspection.Info) 0"> <annotation name="org.jetbrains.annotations.NotNull"/> </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl java.util.Iterator getIterator(java.lang.Object, org.apache.velocity.util.introspection.Info) 1"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelMethod getMethod(java.lang.Object, java.lang.String, java.lang.Object[], org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelMethod getMethod(java.lang.Object, java.lang.String, java.lang.Object[], org.apache.velocity.util.introspection.Info) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelMethod getMethod(java.lang.Object, java.lang.String, java.lang.Object[], org.apache.velocity.util.introspection.Info)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_,_->null""/> </annotation> </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertyGet getPropertyGet(java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertyGet getPropertyGet(java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info) 2"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertyGet getPropertyGet(java.lang.Object, java.lang.String, org.apache.velocity.util.introspection.Info)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_->null""/> </annotation> </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertySet getPropertySet(java.lang.Object, java.lang.String, java.lang.Object, org.apache.velocity.util.introspection.Info) 0"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> + <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertySet getPropertySet(java.lang.Object, java.lang.String, java.lang.Object, org.apache.velocity.util.introspection.Info) 3"> + <annotation name="org.jetbrains.annotations.Nullable"/> + </item> <item name="org.apache.velocity.util.introspection.UberspectImpl org.apache.velocity.util.introspection.VelPropertySet getPropertySet(java.lang.Object, java.lang.String, java.lang.Object, org.apache.velocity.util.introspection.Info)"> <annotation name="org.jetbrains.annotations.Contract"> <val val=""null,_,_,_->null""/> diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/GetterResultsNotSame.java b/java/java-tests/testData/inspection/dataFlow/fixture/GetterResultsNotSame.java new file mode 100644 index 000000000000..1b60a7373900 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/GetterResultsNotSame.java @@ -0,0 +1,26 @@ +class Main { + + public static String getSameObject() { + return ""; // same object for any call + } + + public static Main getNewObject() { + return new Main(); // different objects for different subsequent calls + } + + public static void main(String[] args) { + Main m = new Main(); + + if (m.getSameObject() == m.getSameObject()) { + System.out.println("This will get printed"); + } + + if (m.getNewObject() == m.getNewObject()) { + System.out.println("This will not get printed"); + } + + if (Main.getNewObject() == Main.getNewObject()) { + System.out.println("This will not get printed"); + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/SwitchOnNullable.java b/java/java-tests/testData/inspection/dataFlow/fixture/SwitchOnNullable.java new file mode 100644 index 000000000000..c74852064bf4 --- /dev/null +++ b/java/java-tests/testData/inspection/dataFlow/fixture/SwitchOnNullable.java @@ -0,0 +1,10 @@ +import org.jetbrains.annotations.Nullable; + +class BrokenAlignment { + + void test(@Nullable String n) { + switch (<warning descr="Dereference of 'n' may produce 'java.lang.NullPointerException'">n</warning>) { + + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/psi/repositoryUse/scr17094/classes/a/a/a/a/e/f/i.class b/java/java-tests/testData/psi/repositoryUse/deepPackages/classes/a/a/a/a/e/f/i.class Binary files differindex 3b64eb80cda2..3b64eb80cda2 100644 --- a/java/java-tests/testData/psi/repositoryUse/scr17094/classes/a/a/a/a/e/f/i.class +++ b/java/java-tests/testData/psi/repositoryUse/deepPackages/classes/a/a/a/a/e/f/i.class diff --git a/java/java-tests/testData/psi/repositoryUse/scr17094/classes2/com/intellij/internal/a/b/a/i.class b/java/java-tests/testData/psi/repositoryUse/deepPackages/classes2/com/intellij/internal/a/b/a/i.class Binary files differindex 26bf433c204a..26bf433c204a 100644 --- a/java/java-tests/testData/psi/repositoryUse/scr17094/classes2/com/intellij/internal/a/b/a/i.class +++ b/java/java-tests/testData/psi/repositoryUse/deepPackages/classes2/com/intellij/internal/a/b/a/i.class diff --git a/java/java-tests/testData/psi/repositoryUse/scr17094/classes1/com/intellij/util/d/bw.class b/java/java-tests/testData/psi/repositoryUse/scr17094/classes1/com/intellij/util/d/bw.class Binary files differdeleted file mode 100644 index 46b8238fc620..000000000000 --- a/java/java-tests/testData/psi/repositoryUse/scr17094/classes1/com/intellij/util/d/bw.class +++ /dev/null diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Bar.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Bar.java new file mode 100644 index 000000000000..8ca1dc15c524 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Bar.java @@ -0,0 +1,6 @@ +import static Foo.foo; +public class Bar { + void bar() { + foo(1); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Foo.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Foo.java new file mode 100644 index 000000000000..a72e7b529652 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/after/Foo.java @@ -0,0 +1,3 @@ +public class Foo { + public static void foo(int i){} +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Bar.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Bar.java new file mode 100644 index 000000000000..19bfccb3a7cf --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Bar.java @@ -0,0 +1,7 @@ +import static Foo.foo; +public class Bar { + void bar() { + foo(); + foo(1); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Foo.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Foo.java new file mode 100644 index 000000000000..9b8067c73350 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/preserveStaticImportsIfOverloaded/before/Foo.java @@ -0,0 +1,4 @@ +public class Foo { + public static void foo(){} + public static void foo(int i){} +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Bar.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Bar.java new file mode 100644 index 000000000000..2f1dfde98c09 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Bar.java @@ -0,0 +1,4 @@ +public class Bar { + void bar() { + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Foo.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Foo.java new file mode 100644 index 000000000000..a72e7b529652 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/after/Foo.java @@ -0,0 +1,3 @@ +public class Foo { + public static void foo(int i){} +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Bar.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Bar.java new file mode 100644 index 000000000000..0d111602e175 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Bar.java @@ -0,0 +1,6 @@ +import static Foo.foo; +public class Bar { + void bar() { + foo(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Foo.java b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Foo.java new file mode 100644 index 000000000000..9b8067c73350 --- /dev/null +++ b/java/java-tests/testData/refactoring/inlineMethod/multifile/removeStaticImportsIfOverloadedUnused/before/Foo.java @@ -0,0 +1,4 @@ +public class Foo { + public static void foo(){} + public static void foo(int i){} +}
\ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/GenerateGetterSetterTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/GenerateGetterSetterTest.groovy index 273ab150d8c5..4aabc1448492 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/GenerateGetterSetterTest.groovy +++ b/java/java-tests/testSrc/com/intellij/codeInsight/GenerateGetterSetterTest.groovy @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ import com.intellij.openapi.command.WriteCommandAction import com.intellij.openapi.editor.Editor import com.intellij.openapi.project.Project import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase +import com.intellij.util.ui.UIUtil import com.siyeh.ig.style.UnqualifiedFieldAccessInspection import org.jetbrains.annotations.Nullable /** @@ -103,5 +104,6 @@ class Foo { } }.invoke(project, myFixture.editor, myFixture.file) }) + UIUtil.dispatchAllInvocationEvents() } } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/JavaTypingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/JavaTypingTest.java index 9ca3b6084a43..37aa8852136b 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/JavaTypingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/JavaTypingTest.java @@ -74,6 +74,22 @@ public class JavaTypingTest extends LightPlatformCodeInsightFixtureTestCase { myFixture.checkResultByFile(getTestName(true) + "_after.java"); } + public void testFixIfByBrace() { + doTest('{'); + } + + public void testFixIfByBraceNewObject() { + doTest('{'); + } + + public void testFixIfByBraceCompositeCondition() { + doTest('{'); + } + + public void testFixWhileByBrace() { + doTest('{'); + } + private void doTest(char c) { myFixture.configureByFile(getTestName(true) + "_before.java"); myFixture.type(c); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy index 7391f93a1ab2..1dd75011d3b8 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy @@ -14,6 +14,7 @@ * limitations under the License. */ package com.intellij.codeInsight.completion + import com.intellij.codeInsight.CodeInsightSettings import com.intellij.codeInsight.TargetElementUtil import com.intellij.codeInsight.completion.impl.CompletionServiceImpl @@ -24,10 +25,7 @@ import com.intellij.codeInsight.lookup.LookupManager import com.intellij.codeInsight.lookup.PsiTypeLookupItem import com.intellij.codeInsight.lookup.impl.LookupImpl import com.intellij.codeInsight.template.* -import com.intellij.codeInsight.template.impl.LiveTemplateDocumentationProvider -import com.intellij.codeInsight.template.impl.TemplateImpl -import com.intellij.codeInsight.template.impl.TemplateManagerImpl -import com.intellij.codeInsight.template.impl.TemplateSettings +import com.intellij.codeInsight.template.impl.* import com.intellij.ide.DataManager import com.intellij.ide.ui.UISettings import com.intellij.openapi.Disposable @@ -53,6 +51,7 @@ import com.intellij.openapi.util.Disposer import com.intellij.psi.PsiClass import com.intellij.psi.PsiFile import com.intellij.psi.PsiJavaFile +import com.intellij.psi.PsiMethod import com.intellij.psi.statistics.StatisticsManager import com.intellij.psi.statistics.impl.StatisticsManagerImpl import com.intellij.testFramework.EditorTestUtil @@ -60,6 +59,7 @@ import com.intellij.util.containers.ContainerUtil import org.jetbrains.annotations.NotNull import java.awt.event.KeyEvent + /** * @author peter */ @@ -974,8 +974,15 @@ class Foo { return ((PsiJavaFile)myFixture.file).getClasses()[0]; } }); - def foo = cls.methods[0] - def goo = cls.methods[2] + + PsiMethod[] methods = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod[]>() { + @Override + public PsiMethod[] compute() { + return cls.methods; + } + }) + def foo = methods[0] + def goo = methods[2] type('x') assertContains 'x__foo', 'x__goo' edt { @@ -1292,7 +1299,7 @@ class Foo {{ type '.' assert myFixture.lookupElementStrings == ['Util.bar', 'Util.CONSTANT', 'Util.foo'] - def p = LookupElementPresentation.renderElement(myFixture.lookupElements[1]) + def p = ApplicationManager.application.runReadAction ({ LookupElementPresentation.renderElement(myFixture.lookupElements[1]) } as Computable) assert p.itemText == 'Util.CONSTANT' assert p.tailText == ' (foo)' assert p.typeText == 'int' @@ -1653,4 +1660,25 @@ class Foo {{ type 'toStr' assert lookup } + + public void "test show popup with single live template if show_live_tempate_in_completion option is enabled"() { + def oldValue = LiveTemplateCompletionContributor.ourShowTemplatesInTests + try { + LiveTemplateCompletionContributor.ourShowTemplatesInTests = false + myFixture.configureByText "a.java", """ +class Foo {{ + ita<caret> +""" + type 'r' + assert lookup == null + + LiveTemplateCompletionContributor.ourShowTemplatesInTests = true + type '\br' + assert lookup + assert myFixture.lookupElementStrings == ['itar'] + } + finally { + LiveTemplateCompletionContributor.ourShowTemplatesInTests = oldValue + } + } } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/KeywordCompletionTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/completion/KeywordCompletionTest.java index 6b9cff3f6149..59029a2fb05a 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/KeywordCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/KeywordCompletionTest.java @@ -106,7 +106,9 @@ public class KeywordCompletionTest extends LightCompletionTestCase { public void testReturnInTernary() throws Exception { doTest(1, "return"); } public void testFinalAfterParameterAnno() throws Exception { doTest(2, "final", "float", "class"); } public void testFinalAfterParameterAnno2() throws Exception { doTest(2, "final", "float", "class"); } - public void testFinalAfterCase() throws Exception { doTest(3, "final", "float", "class"); } + public void testFinalAfterCase() { doTest(3, "final", "float", "class"); } + public void testFinalInCatch() { doTest(1, "final"); } + public void testFinalInIncompleteCatch() { doTest(1, "final"); } public void testFinalInTryWithResources() throws Exception { doTest(1, "final", "float", "class"); } public void testNoFinalAfterTryBody() throws Exception { doTest(1, "final", "finally"); } public void testClassInMethod() throws Exception { doTest(2, "class", "char"); } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy index 900555d21ab9..821e5f31fb91 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy @@ -638,7 +638,7 @@ interface TxANotAnno {} } public void testPreferThrownExceptionsInCatch() { - checkPreferredItems 0, 'FileNotFoundException', 'File' + checkPreferredItems 0, 'final', 'FileNotFoundException', 'File' } public void testHonorFirstLetterCase() { diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/SmartTypeCompletionTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/completion/SmartTypeCompletionTest.java index 5153f19fe94a..967de28820e8 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/SmartTypeCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/SmartTypeCompletionTest.java @@ -777,6 +777,11 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { myFixture.assertPreferredCompletionItems(0, "i", "z", "zz", "i, z, zz"); } + public void testSuggestTypeParametersInTypeArgumentList() { + configureByTestName(); + myFixture.assertPreferredCompletionItems(0, "T", "String"); + } + public void testWrongAnonymous() throws Throwable { configureByTestName(); select(); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java index 688e83b5b198..09225b64bc1d 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/GenericsHighlightingTest.java @@ -372,6 +372,8 @@ public class GenericsHighlightingTest extends LightDaemonAnalyzerTestCase { public void testIDEA126633() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_7, false); } public void testIDEA124363() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_7, false); } public void testIDEA78402() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_7, false); } + public void testSuperCaptureSubstitutionWhenTypeParameterHasUpperBounds() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_7, false); } + public void testParameterBoundsWithCapturedWildcard() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_7, false); } //jdk should propagate LL 1.4 but actually it provides LL 1.7?! public void testCastObjectToIntJdk14() { doTest(LanguageLevel.JDK_1_7, JavaSdkVersion.JDK_1_4, false); } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FindFunctionalInterfaceTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FindFunctionalInterfaceTest.java index a6a75b7c061c..2427748b22d4 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FindFunctionalInterfaceTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FindFunctionalInterfaceTest.java @@ -16,6 +16,7 @@ package com.intellij.codeInsight.daemon.lambda; import com.intellij.JavaTestUtil; +import com.intellij.idea.Bombed; import com.intellij.psi.*; import com.intellij.psi.search.searches.FunctionalExpressionSearch; import com.intellij.psi.search.searches.ReferencesSearch; @@ -24,6 +25,7 @@ import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; +import java.util.Calendar; import java.util.Collection; public class FindFunctionalInterfaceTest extends LightCodeInsightFixtureTestCase { @@ -40,6 +42,7 @@ public class FindFunctionalInterfaceTest extends LightCodeInsightFixtureTestCase assertEquals("() -> {}", next.getText()); } + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testFieldFromAnonymousClassScope() throws Exception { myFixture.configureByFile(getTestName(false) + ".java"); final PsiElement elementAtCaret = myFixture.getElementAtCaret(); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlighting8Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlighting8Test.java index d23dfea6daf0..a66d999b283c 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlighting8Test.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlighting8Test.java @@ -688,7 +688,7 @@ public class GenericsHighlighting8Test extends LightDaemonAnalyzerTestCase { public void testIDEA110869() { doTest(); } - /*public void testIDEA110947() { doTest5(false); }*/ + public void testIDEA110947() { doTest(false); } public void testIDEA112122() { doTest(); } @@ -759,6 +759,10 @@ public class GenericsHighlighting8Test extends LightDaemonAnalyzerTestCase { doTest(); } + public void testIDEA128333() throws Exception { + doTest(); + } + public void testIDEA78402() { doTest(); } private void doTest() { diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java index c2ab020f09f3..7585d661b289 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java @@ -47,16 +47,20 @@ public class GraphInferenceHighlightingTest extends LightDaemonAnalyzerTestCase doTest(); } - @Bombed(day = 20, month = Calendar.AUGUST) + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testInferenceFromSiblings() throws Exception { doTest(); } - @Bombed(day = 20, month = Calendar.AUGUST) + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testChainedInferenceTypeParamsOrderIndependent() throws Exception { doTest(); } + public void testCyclicParamsDependency() throws Exception { + doTest(); + } + public void testInferenceForFirstArg() throws Exception { doTest(); } @@ -216,6 +220,21 @@ public class GraphInferenceHighlightingTest extends LightDaemonAnalyzerTestCase public void testIDEA127928() throws Exception { doTest(); } + public void testIDEA128766() throws Exception { + doTest(); + } + + public void testSameMethodNestedChainedCallsNearFunctionInterfaces() throws Exception { + doTest(); + } + + public void testInfiniteTypes() throws Exception { + doTest(); + } + + public void testIDEA126163() throws Exception { + doTest(); + } private void doTest() throws Exception { doTest(false); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewLambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewLambdaHighlightingTest.java index 1411249b3dcc..1da75f51ba6f 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewLambdaHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewLambdaHighlightingTest.java @@ -76,8 +76,9 @@ public class NewLambdaHighlightingTest extends LightDaemonAnalyzerTestCase { public void testIDEA122616() { doTest(); } public void testIDEA122700() { doTest(); } public void testIDEA122406() { doTest(); } + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testNestedCallsInsideLambdaReturnExpression() { doTest(); } - @Bombed(day = 20, month = Calendar.AUGUST) + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testIDEA123731() { doTest(); } public void testIDEA123869() { doTest(); } public void testIDEA123848() { doTest(); } @@ -98,7 +99,7 @@ public class NewLambdaHighlightingTest extends LightDaemonAnalyzerTestCase { doTest(); } - @Bombed(day = 20, month = Calendar.AUGUST) + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testIDEA124983() throws Exception { doTest(); } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewMethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewMethodRefHighlightingTest.java index c48ef71d92d4..c981137d0253 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewMethodRefHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/NewMethodRefHighlightingTest.java @@ -288,7 +288,7 @@ public class NewMethodRefHighlightingTest extends LightDaemonAnalyzerTestCase { doTest(); } - @Bombed(day = 20, month = Calendar.AUGUST) + @Bombed(day = 30, month = Calendar.SEPTEMBER) public void testIDEA127275_() throws Exception { doTest(); } @@ -305,6 +305,15 @@ public class NewMethodRefHighlightingTest extends LightDaemonAnalyzerTestCase { doTest(); } + @Bombed(day = 30, month = Calendar.SEPTEMBER) + public void testAdditionalConstraints3Level() throws Exception { + doTest(); + } + + public void testWildcardParametrization() throws Exception { + doTest(); + } + private void doTest() { doTest(false); } diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/ContractInferenceFromSourceTest.groovy b/java/java-tests/testSrc/com/intellij/codeInspection/ContractInferenceFromSourceTest.groovy index 89762efe5dd2..c3bb014d8342 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/ContractInferenceFromSourceTest.groovy +++ b/java/java-tests/testSrc/com/intellij/codeInspection/ContractInferenceFromSourceTest.groovy @@ -27,7 +27,7 @@ class ContractInferenceFromSourceTest extends LightCodeInsightFixtureTestCase { def c = inferContract(""" String smth(String s) { if (s == null) return null; - return s.substring(1); + return smth(); } """) assert c == 'null -> null' @@ -310,6 +310,55 @@ class ContractInferenceFromSourceTest extends LightCodeInsightFixtureTestCase { assert c == [] } + public void "test skip empty declarations"() { + def c = inferContracts(""" + final Object foo(Object bar) { + Object o = 2; + if (bar == null) return null; + return new String("abc"); + } + """) + assert c == ['null -> null', '!null -> !null'] + } + + public void "test go inside do-while"() { + def c = inferContracts(""" + final Object foo(Object bar) { + do { + if (bar == null) return null; + bar = smth(bar); + } while (smthElse()); + return new String("abc"); + } + """) + assert c == ['null -> null'] + } + + public void "test go inside try"() { + def c = inferContracts(""" + final Object foo(Object bar) { + try { + if (bar == null) return null; + bar = smth(bar); + } finally {} + return new String("abc"); + } + """) + assert c == ['null -> null'] + } + + public void "test use invoked method notnull"() { + def c = inferContracts(""" + final Object foo(Object bar) { + if (bar == null) return null; + return doo(); + } + + @org.jetbrains.annotations.NotNull Object doo() {} + """) + assert c == ['null -> null', '!null -> !null'] + } + private String inferContract(String method) { return assertOneElement(inferContracts(method)) } diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java index 33eb32eb0ec6..a10d02d31fca 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java @@ -109,6 +109,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase { public void testAssigningClassLiteralToNullable() throws Throwable { doTest(); } public void testSynchronizingOnNullable() throws Throwable { doTest(); } + public void testSwitchOnNullable() { doTest(); } public void testReturningNullFromVoidMethod() throws Throwable { doTest(); } public void testCatchRuntimeException() throws Throwable { doTest(); } @@ -214,6 +215,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase { public void testNoConfusionWithAnonymousConstantInitializer() { doTest(); } public void testForeachOverWildcards() { doTest(); } public void testFinalGetter() { doTest(); } + public void testGetterResultsNotSame() { doTest(); } public void testByteBufferGetter() { myFixture.addClass("package java.nio; public class MappedByteBuffer { public int getInt() {} }"); diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/UnusedLibraryInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/UnusedLibraryInspectionTest.java index bb6195a94aa7..938a86da7587 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/UnusedLibraryInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/UnusedLibraryInspectionTest.java @@ -25,6 +25,7 @@ package com.intellij.codeInspection; import com.intellij.JavaTestUtil; +import com.intellij.analysis.AnalysisScope; import com.intellij.codeInspection.ex.LocalInspectionToolWrapper; import com.intellij.codeInspection.magicConstant.MagicConstantInspection; import com.intellij.codeInspection.unusedLibraries.UnusedLibrariesInspection; @@ -37,6 +38,7 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.InspectionTestCase; import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.PsiTestUtil; +import org.jetbrains.annotations.NotNull; public class UnusedLibraryInspectionTest extends InspectionTestCase { @Override @@ -54,5 +56,11 @@ public class UnusedLibraryInspectionTest extends InspectionTestCase { doTest("/" + getTestName(true), new UnusedLibrariesInspection()); } + @NotNull + @Override + protected AnalysisScope createAnalysisScope(VirtualFile sourceDir) { + return new AnalysisScope(getProject()); + } + public void testSimple() throws Exception { doTest(); } } diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIntegrationTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIntegrationTest.java index 516b140cc0b1..ab6d92263162 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIntegrationTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisIntegrationTest.java @@ -38,7 +38,7 @@ import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase; import com.intellij.util.AsynchConsumer; import org.jetbrains.annotations.Contract; -import java.io.IOException; +import java.security.MessageDigest; import java.util.ArrayList; import java.util.List; @@ -50,7 +50,7 @@ public class BytecodeAnalysisIntegrationTest extends JavaCodeInsightFixtureTestC private InferredAnnotationsManager myInferredAnnotationsManager; private ExternalAnnotationsManager myExternalAnnotationsManager; - + private MessageDigest myMessageDigest; private List<String> diffs = new ArrayList<String>(); @Override @@ -62,6 +62,7 @@ public class BytecodeAnalysisIntegrationTest extends JavaCodeInsightFixtureTestC myInferredAnnotationsManager = InferredAnnotationsManager.getInstance(myModule.getProject()); myExternalAnnotationsManager = ExternalAnnotationsManager.getInstance(myModule.getProject()); + myMessageDigest = BytecodeAnalysisConverter.getMessageDigest(); } private void setUpLibraries() { @@ -127,13 +128,9 @@ public class BytecodeAnalysisIntegrationTest extends JavaCodeInsightFixtureTestC } private void checkMethodAnnotations(PsiMethod method) { - try { - if (ProjectBytecodeAnalysis.getKey(method) == -1) { - return; - } - } - catch (IOException e) { - fail(); + + if (ProjectBytecodeAnalysis.getKey(method, myMessageDigest) == null) { + return; } // not null-result @@ -149,12 +146,27 @@ public class BytecodeAnalysisIntegrationTest extends JavaCodeInsightFixtureTestC for (PsiParameter parameter : method.getParameterList().getParameters()) { String parameterKey = PsiFormatUtil.getExternalName(parameter, false, Integer.MAX_VALUE); - String externalParameterAnnotation = - myExternalAnnotationsManager.findExternalAnnotation(parameter, AnnotationUtil.NOT_NULL) == null ? "null" : "@NotNull"; - String inferredParameterAnnotation = - myInferredAnnotationsManager.findInferredAnnotation(parameter, AnnotationUtil.NOT_NULL) == null ? "null" : "@NotNull"; - if (!externalParameterAnnotation.equals(inferredParameterAnnotation)) { - diffs.add(parameterKey + ": " + externalParameterAnnotation + " != " + inferredParameterAnnotation); + + { + // @NotNull + String externalNotNull = + myExternalAnnotationsManager.findExternalAnnotation(parameter, AnnotationUtil.NOT_NULL) == null ? "null" : "@NotNull"; + String inferredNotNull = + myInferredAnnotationsManager.findInferredAnnotation(parameter, AnnotationUtil.NOT_NULL) == null ? "null" : "@NotNull"; + if (!externalNotNull.equals(inferredNotNull)) { + diffs.add(parameterKey + ": " + externalNotNull + " != " + inferredNotNull); + } + } + + { + // @Nullable + String externalNullable = + myExternalAnnotationsManager.findExternalAnnotation(parameter, AnnotationUtil.NULLABLE) == null ? "null" : "@Nullable"; + String inferredNullable = + myInferredAnnotationsManager.findInferredAnnotation(parameter, AnnotationUtil.NULLABLE) == null ? "null" : "@Nullable"; + if (!externalNullable.equals(inferredNullable)) { + diffs.add(parameterKey + ": " + externalNullable + " != " + inferredNullable); + } } } diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisTest.java index 9d26fd804f68..2cbf3fbdfd6c 100644 --- a/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInspection/bytecodeAnalysis/BytecodeAnalysisTest.java @@ -17,6 +17,7 @@ package com.intellij.codeInspection.bytecodeAnalysis; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.InferredAnnotationsManager; +import com.intellij.codeInspection.bytecodeAnalysis.asm.LeakingParameters; import com.intellij.codeInspection.bytecodeAnalysis.data.*; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; @@ -37,6 +38,7 @@ import java.io.FileInputStream; import java.io.IOException; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; +import java.security.MessageDigest; import java.util.HashMap; /** @@ -47,15 +49,15 @@ public class BytecodeAnalysisTest extends JavaCodeInsightFixtureTestCase { private final String myClassesProjectRelativePath = "/classes/" + Test01.class.getPackage().getName().replace('.', '/'); private JavaPsiFacade myJavaPsiFacade; private InferredAnnotationsManager myInferredAnnotationsManager; - private BytecodeAnalysisConverter myBytecodeAnalysisConverter; + private MessageDigest myMessageDigest; + @Override protected void setUp() throws Exception { super.setUp(); myJavaPsiFacade = JavaPsiFacade.getInstance(myModule.getProject()); myInferredAnnotationsManager = InferredAnnotationsManager.getInstance(myModule.getProject()); - myBytecodeAnalysisConverter = BytecodeAnalysisConverter.getInstance(); - + myMessageDigest = MessageDigest.getInstance("MD5"); setUpDataClasses(); } @@ -93,7 +95,7 @@ public class BytecodeAnalysisTest extends JavaCodeInsightFixtureTestCase { public void visitEnd() { super.visitEnd(); try { - map.put(method, cfg.leakingParameters(classReader.getClassName(), node)); + map.put(method, LeakingParameters.build(classReader.getClassName(), node, false).parameters); } catch (AnalyzerException ignore) {} } @@ -183,17 +185,21 @@ public class BytecodeAnalysisTest extends JavaCodeInsightFixtureTestCase { private void checkCompoundId(Method method, PsiMethod psiMethod, boolean noKey) throws IOException { Direction direction = new Out(); - long psiKey = myBytecodeAnalysisConverter.mkPsiKey(psiMethod, direction); + System.out.println(); + System.out.println(method.internalClassName); + System.out.println(method.methodName); + System.out.println(method.methodDesc); + + + HKey psiKey = BytecodeAnalysisConverter.psiKey(psiMethod, direction, myMessageDigest); if (noKey) { - assertTrue(-1 == psiKey); + assertTrue(null == psiKey); return; } else { - assertFalse(-1 == psiKey); + assertFalse(null == psiKey); } - - long asmKey = myBytecodeAnalysisConverter.mkAsmKey(new Key(method, direction, true)); - + HKey asmKey = BytecodeAnalysisConverter.asmKey(new Key(method, direction, true), myMessageDigest); Assert.assertEquals(asmKey, psiKey); } diff --git a/java/java-tests/testSrc/com/intellij/find/FindManagerTest.java b/java/java-tests/testSrc/com/intellij/find/FindManagerTest.java index e40e2c160822..cf876693e2f7 100644 --- a/java/java-tests/testSrc/com/intellij/find/FindManagerTest.java +++ b/java/java-tests/testSrc/com/intellij/find/FindManagerTest.java @@ -343,6 +343,28 @@ public class FindManagerTest extends DaemonAnalyzerTestCase { assertSize(2, findUsages(findModel)); } + public void testNonRecursiveDirectory() throws Exception { + VirtualFile root = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(createTempDirectory()); + addSourceContentToRoots(myModule, root); + + VirtualFile foo = createChildDirectory(root, "foo"); + VirtualFile bar = createChildDirectory(foo, "bar"); + createFile(myModule, root, "A.txt", "goo doo"); + createFile(myModule, foo, "A.txt", "goo doo"); + createFile(myModule, bar, "A.txt", "doo goo"); + + FindModel findModel = FindManagerTestUtils.configureFindModel("done"); + findModel.setProjectScope(false); + findModel.setDirectoryName(foo.getPath()); + findModel.setStringToFind("doo"); + + findModel.setWithSubdirectories(true); + assertSize(2, findUsages(findModel)); + + findModel.setWithSubdirectories(false); + assertSize(1, findUsages(findModel)); + } + public void testReplaceRegexp() { FindModel findModel = new FindModel(); findModel.setStringToFind("bug_(?=here)"); diff --git a/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameTest.groovy b/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameTest.groovy index 9a97a825964a..9c378a1e50cf 100644 --- a/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameTest.groovy +++ b/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameTest.groovy @@ -229,8 +229,14 @@ class Intf { edt { sdkRun = ourRun.containingClass.interfaces[0].methods[0] } - assert getPopupElements(new GotoSymbolModel2(project), 'run ', true) == [sdkRun] - assert getPopupElements(new GotoSymbolModel2(project), 'run ', false) == [ourRun] + + def withLibs = getPopupElements(new GotoSymbolModel2(project), 'run ', true) + assert withLibs[0] == sdkRun + assert !(ourRun in withLibs) + + def noLibs = getPopupElements(new GotoSymbolModel2(project), 'run ', false) + assert noLibs[0] == ourRun + assert !(sdkRun in noLibs) } private List<Object> getPopupElements(ChooseByNameModel model, String text, boolean checkboxState = false) { diff --git a/java/java-tests/testSrc/com/intellij/project/LoadProjectTest.java b/java/java-tests/testSrc/com/intellij/project/LoadProjectTest.java index b50e2d87c71f..69cc43416b5b 100644 --- a/java/java-tests/testSrc/com/intellij/project/LoadProjectTest.java +++ b/java/java-tests/testSrc/com/intellij/project/LoadProjectTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2012 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -28,6 +28,7 @@ import com.intellij.openapi.project.impl.ProjectImpl; import com.intellij.openapi.roots.ProjectRootManager; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiFile; import com.intellij.psi.impl.source.PsiFileImpl; import com.intellij.testFramework.LeakHunter; @@ -61,6 +62,8 @@ public class LoadProjectTest extends PlatformTestCase { assertNotNull(fileA); fileA.navigate(true); Editor editorA = FileEditorManager.getInstance(getProject()).openTextEditor(new OpenFileDescriptor(getProject(), a), true); + PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); + assertNotNull(editorA); CodeInsightTestFixtureImpl.instantiateAndRun(fileA, editorA, new int[0], false); @@ -70,6 +73,8 @@ public class LoadProjectTest extends PlatformTestCase { assertNotNull(fileB); fileB.navigate(true); Editor editorB = FileEditorManager.getInstance(getProject()).openTextEditor(new OpenFileDescriptor(getProject(), b), true); + PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); + assertNotNull(editorB); CodeInsightTestFixtureImpl.instantiateAndRun(fileB, editorB, new int[0], false); diff --git a/java/java-tests/testSrc/com/intellij/psi/SCR17094Test.java b/java/java-tests/testSrc/com/intellij/psi/FindClassInDeepPackagesTest.java index 501914bce501..5e5e010df2f7 100644 --- a/java/java-tests/testSrc/com/intellij/psi/SCR17094Test.java +++ b/java/java-tests/testSrc/com/intellij/psi/FindClassInDeepPackagesTest.java @@ -29,9 +29,13 @@ import java.io.File; /** * @author dsl */ -public class SCR17094Test extends PsiTestCase { - protected void setUpClasses(final String s) throws Exception { - final String testRoot = PathManagerEx.getTestDataPath() + "/psi/repositoryUse/scr17094"; +public class FindClassInDeepPackagesTest extends PsiTestCase { + @Override + protected void setUpJdk() { + } + + private void setUpLibrary(final String s) throws Exception { + final String testRoot = PathManagerEx.getTestDataPath() + "/psi/repositoryUse/deepPackages"; VirtualFile classesRoot = WriteCommandAction.runWriteCommandAction(null, new Computable<VirtualFile>() { @Override public VirtualFile compute() { @@ -44,20 +48,15 @@ public class SCR17094Test extends PsiTestCase { ModuleRootModificationUtil.addModuleLibrary(myModule, classesRoot.getUrl()); } - @Override - protected void setUpJdk() { - - } - public void testSRC() throws Exception { - setUpClasses("classes"); + setUpLibrary("classes"); final JavaPsiFacade psiManager = getJavaFacade(); final PsiClass classA = psiManager.findClass("a.a.a.a.e.f.i", GlobalSearchScope.moduleWithLibrariesScope(myModule)); assertNotNull(classA); } public void test3() throws Exception { - setUpClasses("classes2"); + setUpLibrary("classes2"); final JavaPsiFacade psiManager = getJavaFacade(); final PsiClass classA = psiManager.findClass("com.intellij.internal.f.a.b.a.i", GlobalSearchScope.moduleWithLibrariesScope(myModule)); assertNotNull(classA); diff --git a/java/java-tests/testSrc/com/intellij/psi/MiscPsiTest.java b/java/java-tests/testSrc/com/intellij/psi/MiscPsiTest.java index 61414ab0b416..2ed8233e99fe 100644 --- a/java/java-tests/testSrc/com/intellij/psi/MiscPsiTest.java +++ b/java/java-tests/testSrc/com/intellij/psi/MiscPsiTest.java @@ -24,6 +24,7 @@ import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.impl.source.tree.LazyParseableElement; +import com.intellij.testFramework.PlatformTestUtil; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; @@ -276,4 +277,24 @@ public class MiscPsiTest extends LightCodeInsightFixtureTestCase { assertEquals("class A{}", psiClass.getText()); assertEquals(" class A{}", document.getText()); } + + public void testASTBecomesInvalidOnExternalChange() { + final String text = "class A{}"; + final PsiJavaFile file = (PsiJavaFile)myFixture.addFileToProject("a.java", text); + PsiElement leaf = file.findElementAt(5); + + PlatformTestUtil.tryGcSoftlyReachableObjects(); + assertNull(PsiDocumentManager.getInstance(getProject()).getCachedDocument(file)); + + new WriteCommandAction.Simple(getProject()) { + @Override + protected void run() throws Throwable { + VfsUtil.saveText(file.getVirtualFile(), text + " "); + } + }.execute(); + + assertTrue(file.isValid()); + assertFalse(leaf.isValid()); + assertNotSame(leaf, file.findElementAt(5)); + } } diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR17650Test.java b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/ClassFileUnderSourceRootTest.java index 187d0c2ad80e..5311bd15dfec 100644 --- a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR17650Test.java +++ b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/ClassFileUnderSourceRootTest.java @@ -3,7 +3,6 @@ package com.intellij.psi.impl.cache.impl; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ex.PathManagerEx; import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VfsUtilCore; @@ -17,20 +16,15 @@ import java.io.IOException; /** * @author max */ -public class SCR17650Test extends PsiTestCase { +public class ClassFileUnderSourceRootTest extends PsiTestCase { private static final String TEST_ROOT = PathManagerEx.getTestDataPath() + "/psi/repositoryUse/cls"; - private VirtualFile myDir; @Override protected void setUp() throws Exception { super.setUp(); - final File root = FileUtil.createTempFile(getName(), ""); - root.delete(); - root.mkdir(); - myFilesToDelete.add(root); - + final File root = createTempDirectory(); ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { @@ -55,11 +49,10 @@ public class SCR17650Test extends PsiTestCase { private static VirtualFile getClassFile() { VirtualFile vDir = LocalFileSystem.getInstance().findFileByPath(TEST_ROOT.replace(File.separatorChar, '/')); - VirtualFile child = vDir.findChild("pack").findChild("MyClass.class"); - return child; + return vDir.findFileByRelativePath("pack/MyClass.class"); } - public void test17650() throws Exception { + public void testFindClass() throws Exception { assertEquals("p.A", myJavaFacade.findClass("p.A").getQualifiedName()); assertEquals("pack.MyClass", myJavaFacade.findClass("pack.MyClass").getQualifiedName()); } diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR14423Test.java b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/FindClassTest.java index 2870108623b1..e88027409dc0 100644 --- a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR14423Test.java +++ b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/FindClassTest.java @@ -18,11 +18,11 @@ package com.intellij.psi.impl.cache.impl; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.command.WriteCommandAction; import com.intellij.openapi.fileEditor.FileDocumentManager; +import com.intellij.openapi.fileTypes.FileTypeManager; import com.intellij.openapi.roots.ContentEntry; import com.intellij.openapi.roots.ModifiableRootModel; import com.intellij.openapi.roots.ModuleRootManager; import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; @@ -37,7 +37,7 @@ import java.io.IOException; /** * @author max */ -public class SCR14423Test extends PsiTestCase { +public class FindClassTest extends PsiTestCase { private VirtualFile myPrjDir1; private VirtualFile mySrcDir1; private VirtualFile myPackDir; @@ -46,11 +46,7 @@ public class SCR14423Test extends PsiTestCase { protected void setUp() throws Exception { super.setUp(); - final File root = FileUtil.createTempFile(getName(), ""); - root.delete(); - root.mkdir(); - myFilesToDelete.add(root); - + final File root = createTempDirectory(); WriteCommandAction.runWriteCommandAction(null, new Runnable() { @Override public void run() { @@ -75,14 +71,12 @@ public class SCR14423Test extends PsiTestCase { }); } - public void testBug2() throws Exception { + public void testSimple() throws Exception { PsiClass psiClass = myJavaFacade.findClass("p.A"); assertEquals("p.A", psiClass.getQualifiedName()); - - testBug1(); } - public void testBug1() { + public void testClassUnderExcludedFolder() { ApplicationManager.getApplication().runWriteAction(new Runnable() { public void run() { PsiTestUtil.addExcludedRoot(myModule, myPackDir); @@ -101,7 +95,7 @@ public class SCR14423Test extends PsiTestCase { }); } - public void testBug3() { + public void testClassUnderIgnoredFolder() { ApplicationManager.getApplication().runWriteAction(new Runnable() { public void run() { PsiClass psiClass = myJavaFacade.findClass("p.A", GlobalSearchScope.allScope(myProject)); @@ -109,14 +103,15 @@ public class SCR14423Test extends PsiTestCase { assertTrue(psiClass.isValid()); - PsiTestUtil.addExcludedRoot(myModule, myPackDir); - - assertFalse(psiClass.isValid()); - - ModifiableRootModel rootModel = ModuleRootManager.getInstance(myModule).getModifiableModel(); - final ContentEntry content = rootModel.getContentEntries()[0]; - content.removeExcludeFolder(content.getExcludeFolders()[0]); - rootModel.commit(); + FileTypeManager fileTypeManager = FileTypeManager.getInstance(); + String ignoredFilesList = fileTypeManager.getIgnoredFilesList(); + fileTypeManager.setIgnoredFilesList(ignoredFilesList + ";p"); + try { + assertFalse(psiClass.isValid()); + } + finally { + fileTypeManager.setIgnoredFilesList(ignoredFilesList); + } psiClass = myJavaFacade.findClass("p.A"); assertTrue(psiClass.isValid()); @@ -124,7 +119,7 @@ public class SCR14423Test extends PsiTestCase { }); } - public void testSyncrhonizationAfterChange() { + public void testSynchronizationAfterChange() { ApplicationManager.getApplication().runWriteAction(new Runnable() { public void run() { FileDocumentManager.getInstance().saveAllDocuments(); diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR20733Test.java b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SameSourceRootInTwoModulesTest.java index 5fef7daea7d9..1a5d5faeca7c 100644 --- a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR20733Test.java +++ b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SameSourceRootInTwoModulesTest.java @@ -3,7 +3,6 @@ package com.intellij.psi.impl.cache.impl; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtil; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; @@ -18,7 +17,7 @@ import java.io.IOException; /** * @author max */ -public class SCR20733Test extends PsiTestCase { +public class SameSourceRootInTwoModulesTest extends PsiTestCase { private VirtualFile myPrjDir1; private VirtualFile mySrcDir1; private VirtualFile myPackDir; @@ -27,11 +26,7 @@ public class SCR20733Test extends PsiTestCase { protected void setUp() throws Exception { super.setUp(); - final File root = FileUtil.createTempFile(getName(), ""); - root.delete(); - root.mkdir(); - myFilesToDelete.add(root); - + final File root = createTempDirectory(); ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR19174Test.java b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SourceRootAddedAsLibraryRootTest.java index c47bbf7184e8..36baf5de0d76 100644 --- a/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SCR19174Test.java +++ b/java/java-tests/testSrc/com/intellij/psi/impl/cache/impl/SourceRootAddedAsLibraryRootTest.java @@ -2,7 +2,6 @@ package com.intellij.psi.impl.cache.impl; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.roots.ModuleRootModificationUtil; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; @@ -16,7 +15,7 @@ import java.io.IOException; /** * @author max */ -public class SCR19174Test extends PsiTestCase { +public class SourceRootAddedAsLibraryRootTest extends PsiTestCase { private VirtualFile myDir; private VirtualFile myVFile; @@ -24,11 +23,7 @@ public class SCR19174Test extends PsiTestCase { protected void setUp() throws Exception { super.setUp(); - final File root = FileUtil.createTempFile(getName(), ""); - root.delete(); - root.mkdir(); - myFilesToDelete.add(root); - + final File root = createTempDirectory(); ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { @@ -37,12 +32,6 @@ public class SCR19174Test extends PsiTestCase { myDir = rootVFile.createChildDirectory(null, "contentAndLibrary"); - /* - myVFile = myDir.createChildData(null, "A.java"); - Writer writer1 = myVFile.getWriter(null); - writer1.write("package p; public class A{ public void foo(); }"); - writer1.close(); - */ PsiTestUtil.addSourceRoot(myModule, myDir); } catch (IOException e) { diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/PsiEventsTest.java b/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/PsiEventsTest.java index 2461a4601eba..a933d5bcacf6 100644 --- a/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/PsiEventsTest.java +++ b/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/PsiEventsTest.java @@ -43,13 +43,11 @@ public class PsiEventsTest extends PsiTestCase { private VirtualFile myPrjDir1; private VirtualFile myPrjDir2; - private VirtualFile myPrjDir3; private VirtualFile mySrcDir1; private VirtualFile mySrcDir2; private VirtualFile mySrcDir3; - private VirtualFile mySrcDir4; private VirtualFile myClsDir1; - private VirtualFile myExcludedDir1; + private VirtualFile myIgnoredDir; @Override protected void setUp() throws Exception { @@ -76,13 +74,12 @@ public class PsiEventsTest extends PsiTestCase { myClsDir1 = myPrjDir1.createChildDirectory(null, "cls1"); - myExcludedDir1 = mySrcDir1.createChildDirectory(null, "excluded"); + myIgnoredDir = mySrcDir1.createChildDirectory(null, "CVS"); PsiTestUtil.addContentRoot(myModule, myPrjDir1); PsiTestUtil.addSourceRoot(myModule, mySrcDir1); PsiTestUtil.addSourceRoot(myModule, mySrcDir2); PsiTestUtil.addContentRoot(myModule, myPrjDir2); - PsiTestUtil.addExcludedRoot(myModule, myExcludedDir1); ModuleRootModificationUtil.addModuleLibrary(myModule, myClsDir1.getUrl()); PsiTestUtil.addSourceRoot(myModule, mySrcDir3); } catch (IOException e) { @@ -106,7 +103,7 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildAddition\n" + "childAdded\n"; - assertEquals(expected, string); + assertEquals(psiDir.getName(), expected, string); } public void testCreateDirectory() throws Exception { @@ -121,7 +118,7 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildAddition\n" + "childAdded\n"; - assertEquals(expected, string); + assertEquals(psiDir.getName(), expected, string); } public void testDeleteFile() throws Exception { @@ -139,7 +136,7 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); } public void testDeleteDirectory() throws Exception { @@ -157,10 +154,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); } - public void testRenameFile1() throws Exception { + public void testRenameFile() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "a.txt"); PsiFile psiFile = fileManager.findFile(file); @@ -174,10 +171,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforePropertyChange\n" + "propertyChanged\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); } - public void testRenameFile2() throws Exception { + public void testRenameFileChangingExtension() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "a.txt"); PsiFile psiFile = fileManager.findFile(file); @@ -191,10 +188,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildReplacement\n" + "childReplaced\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); } - public void testRenameFile3() throws Exception { + public void testRenameFileToIgnored() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "a.txt"); PsiFile psiFile = fileManager.findFile(file); @@ -208,11 +205,11 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); assertNull(fileManager.findFile(file)); } - public void testRenameFile4() throws Exception { + public void testRenameFileFromIgnored() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "CVS"); PsiDirectory psiDirectory = fileManager.findDirectory(file.getParent()); @@ -226,10 +223,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildAddition\n" + "childAdded\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); } - public void testRenameDirectory1() throws Exception { + public void testRenameDirectory() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildDirectory(null, "dir1"); PsiDirectory psiDirectory = fileManager.findDirectory(file); @@ -243,10 +240,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforePropertyChange\n" + "propertyChanged\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); } - public void testRenameDirectory2() throws Exception { + public void testRenameDirectoryToIgnored() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildDirectory(null, "dir1"); PsiDirectory psiDirectory = fileManager.findDirectory(file); @@ -260,11 +257,11 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); assertNull(fileManager.findDirectory(file)); } - public void testRenameDirectory3() throws Exception { + public void testRenameDirectoryFromIgnored() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildDirectory(null, "CVS"); PsiDirectory psiDirectory = fileManager.findDirectory(file.getParent()); @@ -278,7 +275,7 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildAddition\n" + "childAdded\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); } public void testMakeFileReadOnly() throws Exception { @@ -291,7 +288,6 @@ public class PsiEventsTest extends PsiTestCase { ReadOnlyAttributeUtil.setReadOnlyAttribute(file, true); - String string = listener.getEventsString(); final String expected = "beforePropertyChange\n" + "propertyChanged\n"; @@ -306,7 +302,7 @@ public class PsiEventsTest extends PsiTestCase { ReadOnlyAttributeUtil.setReadOnlyAttribute(file, false); } - public void testMoveFile1() throws Exception { + public void testMoveFile() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "a.txt"); PsiFile psiFile = fileManager.findFile(file); @@ -320,10 +316,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildMovement\n" + "childMoved\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); } - public void testMoveFile2() throws Exception { + public void testMoveFileToIgnoredDir() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildData(null, "a.txt"); PsiFile psiFile = fileManager.findFile(file); @@ -331,19 +327,18 @@ public class PsiEventsTest extends PsiTestCase { EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); - file.move(null, myExcludedDir1); + file.move(null, myIgnoredDir); String string = listener.getEventsString(); String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiFile.getName(), expected, string); assertNull(fileManager.findFile(file)); } - public void testMoveFile3() throws Exception { - FileManager fileManager = myPsiManager.getFileManager(); - VirtualFile file = myExcludedDir1.createChildData(null, "a.txt"); + public void testMoveFileFromIgnoredDir() throws Exception { + VirtualFile file = myIgnoredDir.createChildData(null, "a.txt"); EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); @@ -357,10 +352,9 @@ public class PsiEventsTest extends PsiTestCase { assertEquals(expected, string); } - public void testMoveFile4() throws Exception { - FileManager fileManager = myPsiManager.getFileManager(); - VirtualFile file = myExcludedDir1.createChildData(null, "a.txt"); - VirtualFile subdir = myExcludedDir1.createChildDirectory(null, "subdir"); + public void testMoveFileInsideIgnoredDir() throws Exception { + VirtualFile file = myIgnoredDir.createChildData(null, "a.txt"); + VirtualFile subdir = myIgnoredDir.createChildDirectory(null, "subdir"); EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); @@ -372,7 +366,7 @@ public class PsiEventsTest extends PsiTestCase { assertEquals(expected, string); } - public void testMoveDirectory1() throws Exception { + public void testMoveDirectory() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildDirectory(null, "dir"); PsiDirectory psiDirectory = fileManager.findDirectory(file); @@ -386,10 +380,10 @@ public class PsiEventsTest extends PsiTestCase { String expected = "beforeChildMovement\n" + "childMoved\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); } - public void testMoveDirectory2() throws Exception { + public void testMoveDirectoryToIgnored() throws Exception { FileManager fileManager = myPsiManager.getFileManager(); VirtualFile file = myPrjDir1.createChildDirectory(null, "dir"); PsiDirectory psiDirectory = fileManager.findDirectory(file); @@ -397,19 +391,18 @@ public class PsiEventsTest extends PsiTestCase { EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); - file.move(null, myExcludedDir1); + file.move(null, myIgnoredDir); String string = listener.getEventsString(); String expected = "beforeChildRemoval\n" + "childRemoved\n"; - assertEquals(expected, string); + assertEquals(psiDirectory.getName(), expected, string); assertNull(fileManager.findDirectory(file)); } - public void testMoveDirectory3() throws Exception { - FileManager fileManager = myPsiManager.getFileManager(); - VirtualFile file = myExcludedDir1.createChildDirectory(null, "dir"); + public void testMoveDirectoryFromIgnored() throws Exception { + VirtualFile file = myIgnoredDir.createChildDirectory(null, "dir"); EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); @@ -423,10 +416,9 @@ public class PsiEventsTest extends PsiTestCase { assertEquals(expected, string); } - public void testMoveDirectory4() throws Exception { - FileManager fileManager = myPsiManager.getFileManager(); - VirtualFile file = myExcludedDir1.createChildDirectory(null, "dir"); - VirtualFile subdir = myExcludedDir1.createChildDirectory(null, "subdir"); + public void testMoveDirectoryInsideIgnored() throws Exception { + VirtualFile file = myIgnoredDir.createChildDirectory(null, "dir"); + VirtualFile subdir = myIgnoredDir.createChildDirectory(null, "subdir"); EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); @@ -497,7 +489,6 @@ public class PsiEventsTest extends PsiTestCase { } public void testModifyFileTypes() throws Exception { - FileManager fileManager = myPsiManager.getFileManager(); EventsTestListener listener = new EventsTestListener(); myPsiManager.addPsiTreeChangeListener(listener,getTestRootDisposable()); diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/TempFileSystemTest.java b/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/TempFileSystemTest.java new file mode 100644 index 000000000000..dbdd61bc340b --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/psi/impl/file/impl/TempFileSystemTest.java @@ -0,0 +1,43 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.psi.impl.file.impl; + +import com.intellij.openapi.roots.ProjectRootManager; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiDirectory; +import com.intellij.psi.PsiFile; +import com.intellij.psi.PsiManager; +import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase; + +import java.io.IOException; + +public class TempFileSystemTest extends LightPlatformCodeInsightFixtureTestCase { + public void testMove() { + ProjectRootManager rootManager = ProjectRootManager.getInstance(getProject()); + VirtualFile sourceRoot = rootManager.getContentSourceRoots()[0]; + PsiManager psiManager = PsiManager.getInstance(getProject()); + PsiDirectory psiSourceRoot = psiManager.findDirectory(sourceRoot); + PsiFile psiFile = psiSourceRoot.createFile("TestDocument.xml"); + try { + psiFile.getVirtualFile().move(this, psiSourceRoot.createSubdirectory("com").getVirtualFile()); + } catch (IOException e) { + e.printStackTrace(); + } + assertTrue(psiFile.isValid()); + psiFile.delete(); + assertFalse(psiFile.isValid()); + } +}
\ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineMethodMultifileTest.java b/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineMethodMultifileTest.java index 9d46f072f338..ded654d4a8d3 100644 --- a/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineMethodMultifileTest.java +++ b/java/java-tests/testSrc/com/intellij/refactoring/inline/InlineMethodMultifileTest.java @@ -42,6 +42,9 @@ public class InlineMethodMultifileTest extends RefactoringTestCase { public void testRemoveStaticImports() throws Exception { doTest("Foo", "foo"); } + public void testPreserveStaticImportsIfOverloaded() throws Exception { + doTest("Foo", "foo"); + } private void doTest(String className, String methodName) throws Exception { String rootBefore = getRoot() + "/before"; diff --git a/java/java-tests/testSrc/com/intellij/roots/libraries/LibraryTest.java b/java/java-tests/testSrc/com/intellij/roots/libraries/LibraryTest.java index e78308b4ae92..1ee498cd5d2c 100644 --- a/java/java-tests/testSrc/com/intellij/roots/libraries/LibraryTest.java +++ b/java/java-tests/testSrc/com/intellij/roots/libraries/LibraryTest.java @@ -1,16 +1,24 @@ package com.intellij.roots.libraries; import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.roots.OrderRootType; -import com.intellij.openapi.roots.RootProvider; +import com.intellij.openapi.application.Result; +import com.intellij.openapi.application.WriteAction; +import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.impl.libraries.LibraryEx; import com.intellij.openapi.roots.libraries.Library; import com.intellij.openapi.roots.libraries.LibraryTable; import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar; +import com.intellij.openapi.util.WriteExternalException; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.roots.ModuleRootManagerTestCase; +import com.intellij.testFramework.PlatformTestUtil; +import com.intellij.testFramework.PsiTestUtil; +import com.intellij.util.CommonProcessors; import org.jdom.Element; -import org.jdom.output.XMLOutputter; +import org.jetbrains.annotations.NotNull; + +import java.util.Collection; +import java.util.Collections; /** * @author dsl @@ -40,11 +48,6 @@ public class LibraryTest extends ModuleRootManagerTestCase { commit(model2); assertFalse(listenerNotifiedOnChange[0]); - final Element element = new Element("root"); - library.writeExternal(element); - assertEquals("<root><library name=\"library\"><CLASSES><root url=\"file://x.jar\" /></CLASSES><JAVADOC /><SOURCES><root url=\"file://x-src.jar\" /></SOURCES></library></root>", - new XMLOutputter().outputString(element)); - ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { @@ -53,6 +56,106 @@ public class LibraryTest extends ModuleRootManagerTestCase { }); } + public void testLibrarySerialization() { + Library library = PsiTestUtil.addProjectLibrary(myModule, "junit", Collections.singletonList(getJDomJar()), + Collections.singletonList(getJDomSources())); + Element element = serialize(library); + String classesUrl = getJDomJar().getUrl(); + String sourcesUrl = getJDomSources().getUrl(); + PlatformTestUtil.assertElementEquals( + "<root><library name=\"junit\"><CLASSES><root url=\"" + classesUrl + "\" /></CLASSES>" + + "<JAVADOC /><SOURCES><root url=\"" + sourcesUrl + "\" /></SOURCES></library></root>", + element); + } + + public void testResolveDependencyToAddedLibrary() { + final ModifiableRootModel model = ModuleRootManager.getInstance(myModule).getModifiableModel(); + model.addInvalidLibrary("jdom", LibraryTablesRegistrar.PROJECT_LEVEL); + commit(model); + assertEmpty(getLibraries()); + + Library library = createLibrary("jdom", getJDomJar(), null); + assertSameElements(getLibraries(), library); + } + + public void testResolveDependencyToRenamedLibrary() { + Library library = createLibrary("jdom2", getJDomJar(), null); + + final ModifiableRootModel model = ModuleRootManager.getInstance(myModule).getModifiableModel(); + model.addInvalidLibrary("jdom", LibraryTablesRegistrar.PROJECT_LEVEL); + commit(model); + assertEmpty(getLibraries()); + + Library.ModifiableModel libModel = library.getModifiableModel(); + libModel.setName("jdom"); + commit(libModel); + assertSameElements(getLibraries(), library); + } + + private Collection<Library> getLibraries() { + CommonProcessors.CollectProcessor<Library> processor = new CommonProcessors.CollectProcessor<Library>(); + ModuleRootManager.getInstance(myModule).orderEntries().forEachLibrary(processor); + return processor.getResults(); + } + + private static void commit(final ModifiableRootModel model) { + new WriteAction() { + protected void run(@NotNull final Result result) { + model.commit(); + } + }.execute(); + } + + public void testNativePathSerialization() { + LibraryTable table = LibraryTablesRegistrar.getInstance().getLibraryTable(myProject); + Library library = table.createLibrary("native"); + Library.ModifiableModel model = library.getModifiableModel(); + model.addRoot("file://native-lib-root", NativeLibraryOrderRootType.getInstance()); + commit(model); + + Element element = serialize(library); + PlatformTestUtil.assertElementEquals( + "<root><library name=\"native\"><CLASSES /><JAVADOC />" + + "<NATIVE><root url=\"file://native-lib-root\" /></NATIVE>" + + "<SOURCES /></library></root>", + element); + } + + public void testJarDirectoriesSerialization() { + LibraryTable table = LibraryTablesRegistrar.getInstance().getLibraryTable(myProject); + Library library = table.createLibrary("jarDirs"); + Library.ModifiableModel model = library.getModifiableModel(); + model.addJarDirectory("file://jar-dir", false, OrderRootType.CLASSES); + model.addJarDirectory("file://jar-dir-src", false, OrderRootType.SOURCES); + commit(model); + + Element element = serialize(library); + PlatformTestUtil.assertElementEquals("<root>\n" + + " <library name=\"jarDirs\">\n" + + " <CLASSES>\n" + + " <root url=\"file://jar-dir\" />\n" + + " </CLASSES>\n" + + " <JAVADOC />\n" + + " <SOURCES>\n" + + " <root url=\"file://jar-dir-src\" />\n" + + " </SOURCES>\n" + + " <jarDirectory url=\"file://jar-dir\" recursive=\"false\" />\n" + + " <jarDirectory url=\"file://jar-dir-src\" recursive=\"false\" type=\"SOURCES\" />\n" + + " </library>\n" + + "</root>" , element); + } + + private static Element serialize(Library library) { + try { + Element element = new Element("root"); + library.writeExternal(element); + return element; + } + catch (WriteExternalException e) { + throw new AssertionError(e); + } + } + public void testAddRemoveExcludedRoot() { VirtualFile jar = getJDomJar(); LibraryEx library = (LibraryEx)createLibrary("junit", jar, null); diff --git a/java/jdkAnnotations/org/jdom/annotations.xml b/java/jdkAnnotations/org/jdom/annotations.xml index 7cd091ac0512..d22b99b867ce 100644 --- a/java/jdkAnnotations/org/jdom/annotations.xml +++ b/java/jdkAnnotations/org/jdom/annotations.xml @@ -30,6 +30,9 @@ <item name='org.jdom.Attribute org.jdom.Attribute setValue(java.lang.String) 0'> <annotation name='org.jetbrains.annotations.NotNull'/> </item> + <item name='org.jdom.Document org.jdom.Element getRootElement()'> + <annotation name='org.jetbrains.annotations.NotNull'/> + </item> <item name="org.jdom.Element Element(java.lang.String) 0"> <annotation name="org.jetbrains.annotations.NonNls" /> </item> @@ -42,6 +45,9 @@ <item name="org.jdom.Element java.util.List getChildren(java.lang.String, org.jdom.Namespace)"> <annotation name="org.jetbrains.annotations.NotNull" /> </item> + <item name='org.jdom.Element java.util.List<org.jdom.Content> getContent()'> + <annotation name='org.jetbrains.annotations.NotNull'/> + </item> <item name='org.jdom.Element org.jdom.Element setAttribute(java.lang.String, java.lang.String) 0'> <annotation name='org.jetbrains.annotations.NotNull'/> </item> diff --git a/java/openapi/src/com/intellij/lang/refactoring/JavaNamesValidator.java b/java/openapi/src/com/intellij/lang/refactoring/JavaNamesValidator.java index f00fe56a0289..0d7dc480bb9e 100644 --- a/java/openapi/src/com/intellij/lang/refactoring/JavaNamesValidator.java +++ b/java/openapi/src/com/intellij/lang/refactoring/JavaNamesValidator.java @@ -17,6 +17,7 @@ package com.intellij.lang.refactoring; import com.intellij.openapi.project.Project; import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiNameHelper; import org.jetbrains.annotations.NotNull; /** @@ -25,11 +26,11 @@ import org.jetbrains.annotations.NotNull; public class JavaNamesValidator implements NamesValidator { @Override public boolean isKeyword(@NotNull String name, Project project) { - return JavaPsiFacade.getInstance(project).getNameHelper().isKeyword(name); + return PsiNameHelper.getInstance(project).isKeyword(name); } @Override public boolean isIdentifier(@NotNull String name, Project project) { - return JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(name); + return PsiNameHelper.getInstance(project).isIdentifier(name); } } diff --git a/java/openapi/src/com/intellij/openapi/roots/NativeLibraryOrderRootType.java b/java/openapi/src/com/intellij/openapi/roots/NativeLibraryOrderRootType.java new file mode 100644 index 000000000000..58dbf0441ab3 --- /dev/null +++ b/java/openapi/src/com/intellij/openapi/roots/NativeLibraryOrderRootType.java @@ -0,0 +1,34 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * 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.intellij.openapi.roots; + +/** + * @author nik + */ +public class NativeLibraryOrderRootType extends PersistentOrderRootType { + public static OrderRootType getInstance() { + return getOrderRootType(NativeLibraryOrderRootType.class); + } + + public NativeLibraryOrderRootType() { + super("NATIVE", null, null, null); + } + + @Override + public boolean skipWriteIfEmpty() { + return true; + } +} diff --git a/java/openapi/src/com/intellij/util/xml/converters/AbstractMemberResolveConverter.java b/java/openapi/src/com/intellij/util/xml/converters/AbstractMemberResolveConverter.java index 230fa140d0a3..80852bacf0aa 100644 --- a/java/openapi/src/com/intellij/util/xml/converters/AbstractMemberResolveConverter.java +++ b/java/openapi/src/com/intellij/util/xml/converters/AbstractMemberResolveConverter.java @@ -119,7 +119,7 @@ public abstract class AbstractMemberResolveConverter extends ResolvingConverter< public LocalQuickFix[] getQuickFixes(final ConvertContext context) { final String targetName = ((GenericValue)context.getInvocationElement()).getStringValue(); - if (!JavaPsiFacade.getInstance(context.getProject()).getNameHelper().isIdentifier(targetName)) return super.getQuickFixes(context); + if (!PsiNameHelper.getInstance(context.getProject()).isIdentifier(targetName)) return super.getQuickFixes(context); final PsiClass targetClass = getTargetClass(context); if (targetClass == null) return super.getQuickFixes(context); final PropertyMemberType memberType = getMemberTypes(context)[0]; diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java index 62e256c14c8e..dbd2734b4b5a 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java +++ b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java @@ -171,4 +171,9 @@ public class CloudModuleBuilder extends JavaModuleBuilder { } return myFrameworkSupportModel; } + + @Override + protected boolean isAvailable() { + return CloudModuleBuilderContributionFactory.EP_NAME.getExtensions().length > 0; + } } diff --git a/java/testFramework/src/com/intellij/codeInsight/CodeInsightTestCase.java b/java/testFramework/src/com/intellij/codeInsight/CodeInsightTestCase.java index 6ecec97f7fe7..631738835371 100644 --- a/java/testFramework/src/com/intellij/codeInsight/CodeInsightTestCase.java +++ b/java/testFramework/src/com/intellij/codeInsight/CodeInsightTestCase.java @@ -77,6 +77,8 @@ public abstract class CodeInsightTestCase extends PsiTestCase { Editor editor = instance.openTextEditor(new OpenFileDescriptor(myProject, file, 0), false); ((EditorImpl)editor).setCaretActive(); + PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); + return editor; } diff --git a/java/testFramework/src/com/intellij/codeInsight/daemon/DaemonAnalyzerTestCase.java b/java/testFramework/src/com/intellij/codeInsight/daemon/DaemonAnalyzerTestCase.java index b9e5ba977a5f..7160dc96787d 100644 --- a/java/testFramework/src/com/intellij/codeInsight/daemon/DaemonAnalyzerTestCase.java +++ b/java/testFramework/src/com/intellij/codeInsight/daemon/DaemonAnalyzerTestCase.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2013 JetBrains s.r.o. + * Copyright 2000-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -77,6 +77,7 @@ import com.intellij.testFramework.LightPlatformTestCase; import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.ContainerUtil; +import com.intellij.util.ui.UIUtil; import com.intellij.xml.XmlSchemaProvider; import gnu.trove.THashMap; import gnu.trove.TIntArrayList; @@ -424,6 +425,7 @@ public abstract class DaemonAnalyzerTestCase extends CodeInsightTestCase { assertNotNull(intentionActionName, intentionAction); assertTrue(ShowIntentionActionsHandler.chooseActionAndInvoke(file, editor, intentionAction, intentionActionName)); + UIUtil.dispatchAllInvocationEvents(); } protected static IntentionAction findIntentionAction(@NotNull Collection<HighlightInfo> infos, @NotNull String intentionActionName, @NotNull Editor editor, diff --git a/java/testFramework/src/com/intellij/codeInsight/daemon/quickFix/LightQuickFixTestCase.java b/java/testFramework/src/com/intellij/codeInsight/daemon/quickFix/LightQuickFixTestCase.java index 9bf434c3e0f5..26a52c661cf6 100644 --- a/java/testFramework/src/com/intellij/codeInsight/daemon/quickFix/LightQuickFixTestCase.java +++ b/java/testFramework/src/com/intellij/codeInsight/daemon/quickFix/LightQuickFixTestCase.java @@ -185,6 +185,7 @@ public abstract class LightQuickFixTestCase extends LightDaemonAnalyzerTestCase protected static void invoke(IntentionAction action) throws IncorrectOperationException { ShowIntentionActionsHandler.chooseActionAndInvoke(getFile(), getEditor(), action, action.getText()); + UIUtil.dispatchAllInvocationEvents(); } protected IntentionAction findActionWithText(final String text) { diff --git a/java/testFramework/src/com/intellij/debugger/DebuggerTestCase.java b/java/testFramework/src/com/intellij/debugger/DebuggerTestCase.java index 2409104c7116..2ec9ae61e17b 100644 --- a/java/testFramework/src/com/intellij/debugger/DebuggerTestCase.java +++ b/java/testFramework/src/com/intellij/debugger/DebuggerTestCase.java @@ -51,6 +51,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiFile; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.util.ui.UIUtil; import com.intellij.xdebugger.XDebugProcess; @@ -328,15 +329,15 @@ public abstract class DebuggerTestCase extends ExecutionWithDebuggerToolsTestCas } protected void createBreakpoints(final String className) { - final PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() { + final PsiFile psiFile = ApplicationManager.getApplication().runReadAction(new Computable<PsiFile>() { @Override - public PsiClass compute() { - return JavaPsiFacade.getInstance(myProject).findClass(className, GlobalSearchScope.allScope(myProject)); + public PsiFile compute() { + PsiClass psiClass = JavaPsiFacade.getInstance(myProject).findClass(className, GlobalSearchScope.allScope(myProject)); + return psiClass.getContainingFile(); } }); - createBreakpoints(psiClass.getContainingFile()); - + createBreakpoints(psiFile); } protected EvaluationContextImpl createEvaluationContext(final SuspendContextImpl suspendContext) { diff --git a/java/testFramework/src/com/intellij/testFramework/CompilerTester.java b/java/testFramework/src/com/intellij/testFramework/CompilerTester.java index 00780b9b76ce..a3c05c6ec3fd 100644 --- a/java/testFramework/src/com/intellij/testFramework/CompilerTester.java +++ b/java/testFramework/src/com/intellij/testFramework/CompilerTester.java @@ -232,7 +232,7 @@ public class CompilerTester { CompilerMessage[] messages = compileContext.getMessages(category); for (CompilerMessage message : messages) { final String text = message.getMessage(); - if (category != CompilerMessageCategory.INFORMATION || !(text.startsWith("Compilation completed successfully") || text.startsWith("Using javac"))) { + if (category != CompilerMessageCategory.INFORMATION || !(text.contains("Compilation completed successfully") || text.startsWith("Using javac"))) { myMessages.add(message); } } diff --git a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java index e983453a11c6..430f2182e516 100644 --- a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java +++ b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java @@ -19,6 +19,7 @@ import com.intellij.psi.util.TypeConversionUtil; import com.intellij.refactoring.typeMigration.TypeConversionDescriptor; import com.intellij.refactoring.typeMigration.TypeMigrationReplacementUtil; import com.intellij.refactoring.typeMigration.rules.AtomicConversionRule; +import com.intellij.refactoring.util.RefactoringUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.Query; import com.intellij.util.containers.ContainerUtil; @@ -180,9 +181,14 @@ public class ConvertFieldToAtomicIntention extends PsiElementBaseIntentionAction } } - final PsiExpression initializer = psiVariable.getInitializer(); + PsiExpression initializer = psiVariable.getInitializer(); if (initializer != null) { - final TypeConversionDescriptor directConversion = AtomicConversionRule.wrapWithNewExpression(toType, fromType, null, element); + if (initializer instanceof PsiArrayInitializerExpression) { + PsiExpression normalizedExpr = + RefactoringUtil.createNewExpressionFromArrayInitializer((PsiArrayInitializerExpression)initializer, psiVariable.getType()); + initializer = (PsiExpression)initializer.replace(normalizedExpr); + } + final TypeConversionDescriptor directConversion = AtomicConversionRule.wrapWithNewExpression(toType, fromType, initializer, element); if (directConversion != null) { TypeMigrationReplacementUtil.replaceExpression(initializer, project, directConversion); } diff --git a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToThreadLocalIntention.java b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToThreadLocalIntention.java index 38ff0ef466ae..8bdce8435be8 100644 --- a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToThreadLocalIntention.java +++ b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToThreadLocalIntention.java @@ -25,6 +25,7 @@ import com.intellij.refactoring.typeMigration.TypeMigrationLabeler; import com.intellij.refactoring.typeMigration.TypeMigrationReplacementUtil; import com.intellij.refactoring.typeMigration.TypeMigrationRules; import com.intellij.refactoring.typeMigration.rules.ThreadLocalConversionRule; +import com.intellij.refactoring.util.RefactoringUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.Query; import com.intellij.util.containers.ContainerUtil; @@ -116,8 +117,13 @@ public class ConvertFieldToThreadLocalIntention extends PsiElementBaseIntentionA } } - final PsiExpression initializer = psiField.getInitializer(); + PsiExpression initializer = psiField.getInitializer(); if (initializer != null) { + if (initializer instanceof PsiArrayInitializerExpression) { + PsiExpression normalizedExpr = + RefactoringUtil.createNewExpressionFromArrayInitializer((PsiArrayInitializerExpression)initializer, psiField.getType()); + initializer = (PsiExpression)initializer.replace(normalizedExpr); + } final TypeConversionDescriptor conversion = ThreadLocalConversionRule.wrapWithNewExpression(toType, fromType, initializer); TypeMigrationReplacementUtil.replaceExpression(initializer, project, conversion); CodeStyleManager.getInstance(project).reformat(psiField); diff --git a/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java b/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java index b3c36dca19f2..7cf1de7b16bc 100644 --- a/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java +++ b/java/typeMigration/test/com/intellij/refactoring/TypeMigrationTest.java @@ -28,6 +28,13 @@ public class TypeMigrationTest extends TypeMigrationTestBase { myFactory = myJavaFacade.getElementFactory(); } + @Override + public void tearDown() throws Exception { + myFactory = null; + + super.tearDown(); + } + public void testT07() { doTestFieldType("f", PsiType.INT.createArrayType(), diff --git a/java/typeMigration/testData/intentions/atomic/afterArrayInitializer.java b/java/typeMigration/testData/intentions/atomic/afterArrayInitializer.java new file mode 100644 index 000000000000..f2b51fa36440 --- /dev/null +++ b/java/typeMigration/testData/intentions/atomic/afterArrayInitializer.java @@ -0,0 +1,6 @@ +import java.util.concurrent.atomic.AtomicReferenceArray; + +// "Convert to atomic" "true" +class Test { + final AtomicReferenceArray<String> field= new AtomicReferenceArray<>(new String[]{}); +}
\ No newline at end of file diff --git a/java/typeMigration/testData/intentions/atomic/beforeArrayInitializer.java b/java/typeMigration/testData/intentions/atomic/beforeArrayInitializer.java new file mode 100644 index 000000000000..6ef272b130e7 --- /dev/null +++ b/java/typeMigration/testData/intentions/atomic/beforeArrayInitializer.java @@ -0,0 +1,4 @@ +// "Convert to atomic" "true" +class Test { + String[] <caret>field={}; +}
\ No newline at end of file diff --git a/java/typeMigration/testData/intentions/threadLocal/afterArrayInitializer.java b/java/typeMigration/testData/intentions/threadLocal/afterArrayInitializer.java new file mode 100644 index 000000000000..59323f18e0e5 --- /dev/null +++ b/java/typeMigration/testData/intentions/threadLocal/afterArrayInitializer.java @@ -0,0 +1,9 @@ +// "Convert to ThreadLocal" "true" +class Test { + final ThreadLocal<String[]> field = new ThreadLocal<String[]>() { + @Override + protected String[] initialValue() { + return new String[]{}; + } + }; +}
\ No newline at end of file diff --git a/java/typeMigration/testData/intentions/threadLocal/beforeArrayInitializer.java b/java/typeMigration/testData/intentions/threadLocal/beforeArrayInitializer.java new file mode 100644 index 000000000000..c2564a9cf266 --- /dev/null +++ b/java/typeMigration/testData/intentions/threadLocal/beforeArrayInitializer.java @@ -0,0 +1,4 @@ +// "Convert to ThreadLocal" "true" +class Test { + String[] <caret>field={}; +}
\ No newline at end of file |