-120.SNAPSHOT\r
+122.SNAPSHOT\r
fileset(dir: "$home/plugins/maven/maven2-server-impl/lib")
}
- layoutPlugin("gradle") {
- jar("gradle.jar") {
- module("gradle")
- }
- }
-
layoutPlugin("rearranger") {
jar("rearranger.jar") {
module("rearranger")
libraryLicense(name: "Netty", libraryName: "Netty", version: "3.3.1", license: "Apache 2.0", url: "http://netty.io", licenseUrl: "http://www.apache.org/licenses/LICENSE-2.0")
libraryLicense(name: "Kryo", libraryName: "Kryo", version: "1.04", license: "New BSD License", url: "http://code.google.com/p/kryo/", licenseUrl: "http://www.opensource.org/licenses/bsd-license.php")
libraryLicense(name: "Snappy-Java", libraryName: "Snappy-Java", version: "1.0.4.1", license: "Apache 2.0", url: "http://code.google.com/p/snappy-java/", licenseUrl: "http://www.apache.org/licenses/LICENSE-2.0")
+libraryLicense(name: "Cucumber-JVM", libraryName: "cucumber-jvm", version: "1.0.11", license: "MIT License", url: "https://github.com/cucumber/cucumber-jvm/", licenseUrl: "http://www.opensource.org/licenses/mit-license.html")
jetbrainsLibrary("JPS")
jetbrainsLibrary("Maven Embedder")
jetbrainsLibrary("tcServiceMessages")
previous = myModuleBytecodeTarget.put(module.getName(), level);
}
if (!Comparing.equal(previous, level)) {
- final Project project = module.getProject();
+ //final Project project = module.getProject(); // todo[jeka] so what?
}
}
public String getBytecodeTargetLevel(Module module) {
final String level = myModuleBytecodeTarget.get(module.getName());
if (level != null) {
- return "".equals(level)? null : level;
+ return level.isEmpty() ? null : level;
}
return myBytecodeTargetLevel;
}
myModuleProcessorProfiles.addAll(moduleProfiles);
}
+ @Nullable
+ public ProcessorConfigProfile findModuleProcessorProfile(@NotNull String name) {
+ for (ProcessorConfigProfile profile : myModuleProcessorProfiles) {
+ if (name.equals(profile.getName())) {
+ return profile;
+ }
+ }
+
+ return null;
+ }
+
+ public void removeModuleProcessorProfile(ProcessorConfigProfile profile) {
+ myModuleProcessorProfiles.remove(profile);
+ myProcessorsProfilesMap = null; // clear cache
+ }
+
+ public void addModuleProcessorProfile(@NotNull ProcessorConfigProfile profile) {
+ myModuleProcessorProfiles.add(profile);
+ myProcessorsProfilesMap = null; // clear cache
+ }
+
@Override
@NotNull
public ProcessorConfigProfile getAnnotationProcessingConfiguration(Module module) {
final CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings.Builder cmdBuilder =
CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings.newBuilder();
+ cmdBuilder.setGlobalOptionsPath(PathManager.getOptionsPath());
+
if (!data.isEmpty()) {
for (Map.Entry<String, String> entry : data.entrySet()) {
final String var = entry.getKey();
@Nullable Set<String> writtenPaths,
@Nullable FileFilter fileFilter) throws IOException {
if (fileFilter != null && !fileFilter.accept(fromFile)) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Skipping " + fromFile.getAbsolutePath() + ": it wasn't accepted by filter " + fileFilter);
+ }
return;
}
checkPathDoNotNavigatesUpFromFile(fromFile);
}
if (fromFile.equals(toFile)
|| writtenPaths != null && !writtenPaths.add(toFile.getPath())) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Skipping " + fromFile.getAbsolutePath() + ": " + toFile.getAbsolutePath() + " is already written");
+ }
return;
}
- if (!FileUtil.isFilePathAcceptable(toFile, fileFilter)) return;
- if (context.getProgressIndicator() != null) {
- context.getProgressIndicator().setText("Copying files");
- context.getProgressIndicator().setText2(fromFile.getPath());
+ if (!FileUtil.isFilePathAcceptable(toFile, fileFilter)) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Skipping " + fromFile.getAbsolutePath() + ": " + toFile.getAbsolutePath() + " wasn't accepted by filter " + fileFilter);
+ }
+ return;
}
+ context.getProgressIndicator().setText("Copying files");
+ context.getProgressIndicator().setText2(fromFile.getPath());
try {
if (LOG.isDebugEnabled()) {
LOG.debug("Copy file '" + fromFile + "' to '"+toFile+"'");
@Override
public void addListener(final BreakpointsListener listener, Project project) {
- final MyBreakpointManagerListener listener1 = new MyBreakpointManagerListener(listener);
- DebuggerManagerEx.getInstanceEx(getCurrentProject()).getBreakpointManager().addBreakpointManagerListener(listener1);
+ BreakpointManager breakpointManager = DebuggerManagerEx.getInstanceEx(getCurrentProject()).getBreakpointManager();
+ final MyBreakpointManagerListener listener1 = new MyBreakpointManagerListener(listener, breakpointManager);
+ breakpointManager.addBreakpointManagerListener(listener1);
myListeners.add(listener1);
}
public void removeListener(BreakpointsListener listener) {
for (MyBreakpointManagerListener managerListener : myListeners) {
if (managerListener.myListener == listener) {
+ BreakpointManager manager = managerListener.myBreakpointManager;
+ manager.removeBreakpointManagerListener(managerListener);
myListeners.remove(managerListener);
break;
}
private static class MyBreakpointManagerListener implements BreakpointManagerListener {
private final BreakpointsListener myListener;
+ public BreakpointManager myBreakpointManager;
- public MyBreakpointManagerListener(BreakpointsListener listener) {
+
+ public MyBreakpointManagerListener(BreakpointsListener listener, BreakpointManager breakpointManager) {
myListener = listener;
+ myBreakpointManager = breakpointManager;
}
@Override
*/
package com.intellij.debugger.ui.breakpoints;
-import com.intellij.debugger.DebuggerBundle;
-import com.intellij.openapi.actionSystem.*;
-import com.intellij.openapi.actionSystem.ex.ComboBoxAction;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.popup.JBPopup;
-import com.intellij.openapi.ui.popup.JBPopupListener;
-import com.intellij.openapi.ui.popup.LightweightWindowEvent;
+import com.intellij.openapi.ui.ComboBox;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.UserDataHolderBase;
-import com.intellij.ui.popup.util.DetailView;
-import com.intellij.ui.popup.util.ItemWrapper;
+import com.intellij.ui.CollectionComboBoxModel;
+import com.intellij.ui.components.JBList;
+import com.intellij.ui.popup.util.*;
import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
-import com.intellij.xdebugger.impl.breakpoints.ui.tree.BreakpointMasterDetailPopupBuilder;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
-import java.awt.*;
-import java.util.Collection;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.util.List;
public class BreakpointChooser {
- private Project myProject;
private DetailView myDetailView;
- private ActionToolbar myActionToolbar;
- private BreakpointItem myBreakpointItem;
-
private Delegate myDelegate;
- private final ComboBoxAction myComboBoxAction;
- private BreakpointMasterDetailPopupBuilder myPopupBuilder;
- private Object mySelectedBreakpoint;
+ private final ComboBox myComboBox;
+
+ private DetailController myDetailController;
+ private JBList myList;
public void setDetailView(DetailView detailView) {
myDetailView = detailView;
+ myDetailController.setDetailView(new MyDetailView(myDetailView.getEditorState()));
}
public Object getSelectedBreakpoint() {
- return mySelectedBreakpoint;
- }
-
- public BreakpointItem getBreakpointItem() {
- return myBreakpointItem;
- }
-
- public void setSelectedBreakpoint(Object selectedBreakpoint) {
- mySelectedBreakpoint = selectedBreakpoint;
- myBreakpointItem = selectedBreakpoint != null ? new JavaBreakpointItem(null, (Breakpoint)selectedBreakpoint) : null;
- updatePresentation(myComboBoxAction.getTemplatePresentation(), myBreakpointItem);
+ return ((BreakpointItem)myComboBox.getSelectedItem()).getBreakpoint();
}
private void pop(DetailView.PreviewEditorState pushed) {
}
}
public interface Delegate {
- void breakpointChosen(Project project, BreakpointItem breakpointItem, JBPopup popup);
+ void breakpointChosen(Project project, BreakpointItem breakpointItem);
}
- public BreakpointChooser(Project project, Delegate delegate, Breakpoint baseBreakpoint) {
- myProject = project;
+ public BreakpointChooser(final Project project, Delegate delegate, Breakpoint baseBreakpoint, List<BreakpointItem> breakpointItems) {
myDelegate = delegate;
- myPopupBuilder = new BreakpointMasterDetailPopupBuilder(myProject);
- myPopupBuilder.setPlainView(true);
-
- myComboBoxAction = new ComboBoxAction() {
-
+ BreakpointItem breakpointItem = null;
+ for (BreakpointItem item : breakpointItems) {
+ if (item.getBreakpoint() == baseBreakpoint) {
+ breakpointItem = item;
+ break;
+ }
+ }
+ myDetailController = new DetailController(new MasterController() {
+ JLabel fake = new JLabel();
@Override
- public void update(AnActionEvent e) {
- final Presentation presentation = e.getPresentation();
- updatePresentation(presentation, BreakpointChooser.this.myBreakpointItem);
+ public ItemWrapper[] getSelectedItems() {
+ return new ItemWrapper[]{((BreakpointItem)myList.getSelectedValue())};
}
@Override
- protected ComboBoxButton createComboBoxButton(final Presentation presentation) {
- return new ComboBoxButton(presentation) {
- @Override
- protected JBPopup createPopup(final Runnable onDispose) {
- final DetailView.PreviewEditorState pushed = myDetailView.getEditorState();
- myPopupBuilder.setIsViewer(true);
- myPopupBuilder.setAddDetailViewToEast(false);
- myPopupBuilder.setDetailView(new MyDetailView(pushed));
- myPopupBuilder.setCallback(new BreakpointMasterDetailPopupBuilder.BreakpointChosenCallback() {
- @Override
- public void breakpointChosen(Project project, BreakpointItem breakpointItem, JBPopup popup, boolean withEnterOrDoubleClick) {
- popup.cancel();
- myBreakpointItem = breakpointItem;
- mySelectedBreakpoint = breakpointItem.getBreakpoint();
- updatePresentation(myComboBoxAction.getTemplatePresentation(), myBreakpointItem);
- updatePresentation(presentation, myBreakpointItem);
-
- if (myDelegate != null) {
- myDelegate.breakpointChosen(project, breakpointItem, popup);
- }
- }
- });
- myPopupBuilder.setIsViewer(true);
- JBPopup popup = myPopupBuilder.createPopup();
- popup.addListener(new JBPopupListener() {
- @Override
- public void beforeShown(LightweightWindowEvent event) {
- //To change body of implemented methods use File | Settings | File Templates.
- }
-
- @Override
- public void onClosed(LightweightWindowEvent event) {
- onDispose.run();
- pop(pushed);
- }
- });
- return popup;
- }
-
-
- };
+ public JLabel getPathLabel() {
+ return fake;
}
+ });
- @NotNull
+ final ItemWrapperListRenderer listRenderer = new ItemWrapperListRenderer(project, null);
+
+ ComboBoxModel model = new CollectionComboBoxModel(breakpointItems, breakpointItem);
+ myComboBox = new ComboBox(model) {
@Override
- protected DefaultActionGroup createPopupActionGroup(JComponent button) {
- assert false : "should not be here";
- return null;
+ protected JBList createJBList(ComboBoxModel model) {
+ myList = super.createJBList(model);
+ myDetailController.setList(myList);
+ myList.setCellRenderer(listRenderer);
+ return myList;
}
};
- setSelectedBreakpoint(baseBreakpoint);
- myActionToolbar = ActionManager.getInstance().createActionToolbar("asdad", new DefaultActionGroup(myComboBoxAction), true);
- myActionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);
- }
-
- public void setBreakpointItems(Collection<BreakpointItem> items) {
- myPopupBuilder.setBreakpointItems(items);
- }
-
- private void updatePresentation(Presentation presentation, BreakpointItem breakpointItem) {
- if (breakpointItem != null && breakpointItem.getBreakpoint() != null) {
- presentation.setIcon(breakpointItem.getIcon());
- presentation.setText(breakpointItem.getDisplayText());
- }
- else {
- presentation.setText(DebuggerBundle.message("value.none"));
- }
+ myComboBox.setRenderer(listRenderer);
+ myComboBox.setSwingPopup(false);
+ myComboBox.addItemListener(new ItemListener() {
+ @Override
+ public void itemStateChanged(ItemEvent event) {
+ myDelegate.breakpointChosen(project, ((BreakpointItem)myComboBox.getSelectedItem()));
+ }
+ });
}
public JComponent getComponent() {
- return myActionToolbar.getComponent();
+ return myComboBox;
}
private class MyDetailView implements DetailView {
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.ui.FixedSizeButton;
-import com.intellij.openapi.ui.popup.JBPopup;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.ui.components.JBCheckBox;
import com.intellij.ui.popup.util.DetailView;
import com.intellij.util.IJSwingUtilities;
-import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
import com.intellij.xdebugger.impl.DebuggerSupport;
+import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointItem;
import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
myMasterBreakpointChooser = new BreakpointChooser(myProject, new BreakpointChooser.Delegate() {
@Override
- public void breakpointChosen(Project project, BreakpointItem item, JBPopup popup) {
+ public void breakpointChosen(Project project, BreakpointItem item) {
final boolean enabled = item != null && item.getBreakpoint() != null;
myLeaveEnabledRadioButton.setEnabled(enabled);
myDisableAgainRadio.setEnabled(enabled);
updateMasterBreakpointPanel(findMasterBreakpointRule());
}
- }, baseBreakpoint);
+ }, baseBreakpoint, getBreakpointItemsExceptMy());
insert(myDependentBreakpointComboPanel, myMasterBreakpointChooser.getComponent());
-
- myMasterBreakpointChooser.setBreakpointItems(getBreakpointItemsExceptMy());
-
}
private @Nullable EnableBreakpointRule findMasterBreakpointRule() {
import com.intellij.debugger.impl.DebuggerContextListener;
import com.intellij.debugger.impl.DebuggerStateManager;
import com.intellij.debugger.ui.DebuggerView;
+import com.intellij.openapi.CompositeDisposable;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.ActionManager;
import com.intellij.openapi.actionSystem.AnAction;
import javax.swing.*;
import java.awt.*;
-import java.util.ArrayList;
public abstract class UpdatableDebuggerView extends JPanel implements DebuggerView {
private final Project myProject;
private final DebuggerStateManager myStateManager;
private volatile boolean myRefreshNeeded = true;
- private final java.util.List<Disposable> myDisposables = new ArrayList<Disposable>();
+ private final CompositeDisposable myDisposables = new CompositeDisposable();
private volatile boolean myUpdateEnabled;
protected UpdatableDebuggerView(final Project project, final DebuggerStateManager stateManager) {
}
public void dispose() {
- for (Disposable disposable : myDisposables) {
- Disposer.dispose(disposable);
- }
- myDisposables.clear();
+ Disposer.dispose(myDisposables);
}
protected void overrideShortcut(final JComponent forComponent, final String actionId, final ShortcutSet shortcutSet) {
import com.intellij.execution.runners.ProgramRunner;
import com.intellij.execution.testframework.*;
import com.intellij.idea.ActionsBundle;
+import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Getter;
-import com.intellij.openapi.util.InvalidDataException;
-import com.intellij.openapi.util.JDOMExternalizable;
-import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.openapi.ui.ComponentContainer;
+import com.intellij.openapi.util.*;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
-public class AbstractRerunFailedTestsAction extends AnAction implements AnAction.TransparentUpdate {
- private static List<AbstractRerunFailedTestsAction> registry = new ArrayList<AbstractRerunFailedTestsAction>();
+public class AbstractRerunFailedTestsAction extends AnAction implements AnAction.TransparentUpdate, Disposable {
+ private static List<AbstractRerunFailedTestsAction> registry = new CopyOnWriteArrayList<AbstractRerunFailedTestsAction>();
private static final Logger LOG = Logger.getInstance("#com.intellij.execution.junit2.ui.actions.RerunFailedTestsAction");
private TestFrameworkRunningModel myModel;
private Getter<TestFrameworkRunningModel> myModelProvider;
myParent = null;
}
- protected AbstractRerunFailedTestsAction(JComponent parent) {
- myParent = parent;
+ protected AbstractRerunFailedTestsAction(@NotNull ComponentContainer componentContainer) {
+ myParent = componentContainer.getComponent();
registry.add(this);
+ Disposer.register(componentContainer, this);
copyFrom(ActionManager.getInstance().getAction("RerunFailedTests"));
- registerCustomShortcutSet(getShortcutSet(), parent);
+ registerCustomShortcutSet(getShortcutSet(), myParent);
+ }
+
+ public void dispose() {
+ registry.remove(this);
}
public void init(final TestConsoleProperties consoleProperties,
--- /dev/null
+/*
+ * Copyright 2000-2012 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.application.options.codeStyle.arrangement.ArrangementSettingsPanel;
+import com.intellij.ide.highlighter.JavaFileType;
+import com.intellij.lang.java.JavaLanguage;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.codeStyle.arrangement.Rearranger;
+import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Denis Zhdanov
+ * @since 8/8/12 8:57 AM
+ */
+public class JavaArrangementPanel extends ArrangementSettingsPanel {
+
+ public JavaArrangementPanel(@NotNull CodeStyleSettings settings) {
+ super(settings, (ArrangementStandardSettingsAware)Rearranger.EXTENSION.forLanguage(JavaLanguage.INSTANCE));
+ }
+
+ @Override
+ protected int getRightMargin() {
+ return 80;
+ }
+
+ @NotNull
+ @Override
+ protected FileType getFileType() {
+ return JavaFileType.INSTANCE;
+ }
+
+ @Override
+ protected String getPreviewText() {
+ return null;
+ }
+}
/*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2012 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.
super.initTabs(settings);
addTab(new JavaDocFormattingPanel(settings));
addTab(new CodeStyleImportsPanelWrapper(settings));
+ if (Boolean.getBoolean("show.arrangement.options")) {
+ addTab(new JavaArrangementPanel(settings));
+ }
for (CodeStyleSettingsProvider provider : Extensions.getExtensions(CodeStyleSettingsProvider.EXTENSION_POINT_NAME)) {
if (provider.getLanguage() == JavaLanguage.INSTANCE && !provider.hasSettingsPage()) {
createTab(provider);
myResult = types;
}
else {
- LOG.assertTrue(myExpr.equals(expr.getElseExpression()));
+ if (!myExpr.equals(expr.getElseExpression())) {
+ LOG.error(Arrays.asList(expr.getChildren()) + "; " + myExpr);
+ }
myResult = getExpectedTypes(expr, myForCompletion);
for (ExpectedTypeInfo info : myResult) {
((ExpectedTypeInfoImpl)info).setInsertExplicitTypeParams(true);
import com.intellij.codeInsight.completion.simple.ParenthesesTailType;
import com.intellij.codeInsight.completion.simple.RParenthTailType;
import com.intellij.openapi.editor.Editor;
-import com.intellij.psi.codeStyle.CodeStyleSettings;
import com.intellij.psi.codeStyle.CommonCodeStyleSettings;
public class TailTypes {
}
};
public static final TailType FINALLY_LBRACE = new BracesTailType() {
- protected boolean isSpaceBeforeLBrace(final CodeStyleSettings styleSettings, final Editor editor, final int tailOffset) {
+ protected boolean isSpaceBeforeLBrace(final CommonCodeStyleSettings styleSettings, final Editor editor, final int tailOffset) {
return styleSettings.SPACE_BEFORE_FINALLY_LBRACE;
}
};
+ public static final TailType TRY_LBRACE = new BracesTailType() {
+ @Override
+ protected boolean isSpaceBeforeLBrace(CommonCodeStyleSettings styleSettings, Editor editor, int tailOffset) {
+ return styleSettings.SPACE_BEFORE_TRY_LBRACE;
+ }
+ };
+ public static final TailType DO_LBRACE = new BracesTailType() {
+ @Override
+ protected boolean isSpaceBeforeLBrace(CommonCodeStyleSettings styleSettings, Editor editor, int tailOffset) {
+ return styleSettings.SPACE_BEFORE_DO_LBRACE;
+ }
+ };
+
+
private TailTypes() {}
}
}
if (!AFTER_DOT.accepts(element)) {
- new CollectionsUtilityMethodsProvider(parameters.getPosition(),
- parameters.getExpectedType(),
- parameters.getDefaultType(), result)
- .addCompletions(parameters.getParameters().getInvocationCount() > 1 || StringUtil.isNotEmpty(matcher.getPrefix()));
+ if (parameters.getParameters().getInvocationCount() <= 1) {
+ new CollectionsUtilityMethodsProvider(parameters.getPosition(),
+ parameters.getExpectedType(),
+ parameters.getDefaultType(), result)
+ .addCompletions(StringUtil.isNotEmpty(matcher.getPrefix()));
+ }
ClassLiteralGetter.addCompletions(parameters, result, matcher);
final PsiElement position = parameters.getPosition();
registerVariant(variant);
}
-
- {
- final CompletionVariant variant = new CompletionVariant(PsiJavaFile.class, CLASS_START);
- variant.includeScopeClass(PsiClass.class);
-
- variant.addCompletion(PsiKeyword.ENUM, TailType.HUMBLE_SPACE_BEFORE_WORD);
- registerVariant(variant);
- }
-
}
protected void initVariantsInClassScope() {
if (JavaCompletionData.AFTER_TRY_BLOCK.isAcceptable(position, position) ||
JavaCompletionData.START_SWITCH.accepts(position) ||
- JavaCompletionData.INSTANCEOF_PLACE.isAcceptable(position, position) ||
+ JavaCompletionData.isInstanceofPlace(position) ||
JavaCompletionData.isAfterPrimitiveOrArrayType(position)) {
return null;
}
private static final PsiElementPattern<PsiElement,?> AFTER_DOT = psiElement().afterLeaf(".");
- public static final LeftNeighbour INSTANCEOF_PLACE = new LeftNeighbour(new OrFilter(
+ private static final LeftNeighbour INSTANCEOF_PLACE = new LeftNeighbour(new OrFilter(
new ReferenceOnFilter(new ClassFilter(PsiVariable.class)),
new TextFilter(PsiKeyword.THIS),
new AndFilter(new TextFilter(")"), new ParentElementFilter(new AndFilter(
not(psiElement().inside(PsiAnnotation.class)),
not(START_SWITCH));
- public static final AndFilter CLASS_START = new AndFilter(
- new OrFilter(
- END_OF_BLOCK,
- new PatternFilter(psiElement().afterLeaf(
- or(
- psiElement().withoutText(".").inside(psiElement(PsiModifierList.class).withParent(not(psiElement(PsiParameter.class)))).andNot(
- psiElement().inside(PsiAnnotationParameterList.class)),
- psiElement().isNull())))
- ),
- new PatternFilter(not(psiElement().afterLeaf("@"))));
-
private static final String[] PRIMITIVE_TYPES = new String[]{
PsiKeyword.SHORT, PsiKeyword.BOOLEAN,
PsiKeyword.DOUBLE, PsiKeyword.LONG,
}
protected void initVariantsInFileScope(){
- {
- final CompletionVariant variant = new CompletionVariant(PsiJavaFile.class, CLASS_START);
- variant.includeScopeClass(PsiClass.class);
-
- variant.addCompletion(PsiKeyword.CLASS);
- variant.addCompletion(PsiKeyword.INTERFACE);
-
- registerVariant(variant);
- }
-
}
/**
registerVariant(variant);
}
- {
-// instanceof keyword
- final ElementFilter position = INSTANCEOF_PLACE;
- final CompletionVariant variant = new CompletionVariant(position);
- variant.includeScopeClass(PsiExpression.class, true);
- variant.includeScopeClass(PsiMethod.class);
- variant.addCompletion(PsiKeyword.INSTANCEOF);
-
- registerVariant(variant);
- }
-
{
// Keyword completion in returns !!!!
final CompletionVariant variant = new CompletionVariant(PsiMethod.class, new LeftNeighbour(new TextFilter(PsiKeyword.RETURN)));
private static void addStatementKeywords(CompletionResultSet variant, PsiElement position) {
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.SWITCH), TailTypes.SWITCH_LPARENTH));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.WHILE), TailTypes.WHILE_LPARENTH));
- variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.DO), TailType.createSimpleTailType('{')));
+ variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.DO), TailTypes.DO_LBRACE));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.FOR), TailTypes.FOR_LPARENTH));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.IF), TailTypes.IF_LPARENTH));
- variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.TRY), TailType.createSimpleTailType('{')));
+ variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.TRY), TailTypes.TRY_LBRACE));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.THROW), TailType.INSERT_SPACE));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.NEW), TailType.INSERT_SPACE));
variant.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.SYNCHRONIZED), TailTypes.SYNCHRONIZED_LPARENTH));
result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
- if (CLASS_START.isAcceptable(position, position) &&
- PsiTreeUtil.getNonStrictParentOfType(position, PsiLiteralExpression.class, PsiComment.class) == null) {
+ if (isInstanceofPlace(position)) {
+ result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.INSTANCEOF), TailType.HUMBLE_SPACE_BEFORE_WORD));
+ }
+
+ if (isSuitableForClass(position)) {
for (String s : ModifierChooser.getKeywords(position)) {
result.addElement(new OverrideableSpace(createKeyword(position, s), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
+ result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.CLASS), TailType.HUMBLE_SPACE_BEFORE_WORD));
+ if (PsiTreeUtil.getParentOfType(position, PsiCodeBlock.class, true, PsiMember.class) == null) {
+ result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.INTERFACE), TailType.HUMBLE_SPACE_BEFORE_WORD));
+ if (PsiUtil.getLanguageLevel(position).isAtLeast(LanguageLevel.JDK_1_5)) {
+ result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.ENUM), TailType.INSERT_SPACE));
+ }
+ }
}
addPrimitiveTypes(result, position);
}
}
+ public static boolean isInstanceofPlace(PsiElement position) {
+ return INSTANCEOF_PLACE.isAcceptable(position, position);
+ }
+
+ public static boolean isSuitableForClass(PsiElement position) {
+ if (psiElement().afterLeaf("@").accepts(position) ||
+ PsiTreeUtil.getNonStrictParentOfType(position, PsiLiteralExpression.class, PsiComment.class) != null) {
+ return false;
+ }
+
+ if (psiElement().afterLeaf(
+ or(
+ psiElement().withoutText(".").inside(psiElement(PsiModifierList.class).withParent(not(psiElement(PsiParameter.class)))).andNot(
+ psiElement().inside(PsiAnnotationParameterList.class)),
+ psiElement().isNull())).accepts(position)) {
+ return true;
+ }
+
+ return END_OF_BLOCK.isAcceptable(position, position);
+ }
+
static void addExpectedTypeMembers(CompletionParameters parameters, final CompletionResultSet result, PsiElement position) {
for (final ExpectedTypeInfo info : JavaSmartCompletionContributor.getExpectedTypes(parameters)) {
- new JavaMembersGetter(info.getDefaultType(), position).addMembers(parameters, parameters.getInvocationCount() > 1, new Consumer<LookupElement>() {
+ new JavaMembersGetter(info.getDefaultType(), parameters).addMembers(parameters.getInvocationCount() > 1, new Consumer<LookupElement>() {
@Override
public void consume(LookupElement element) {
result.addElement(element);
final Object object = element.getObject();
if (object instanceof PsiDocCommentOwner) {
final PsiDocCommentOwner member = (PsiDocCommentOwner)object;
- if (!member.isValid()) {
- return MyEnum.NORMAL;
- }
-
if (!JavaPsiFacade.getInstance(member.getProject()).getResolveHelper().isAccessible(member, myPosition, null)) return MyEnum.INACCESSIBLE;
if (member.isDeprecated()) return MyEnum.DEPRECATED;
}
import com.intellij.codeInsight.lookup.DefaultLookupItemRenderer;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.codeInsight.lookup.LookupElementPresentation;
+import com.intellij.featureStatistics.FeatureUsageTracker;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMember;
import com.intellij.psi.PsiMethod;
@Override
public void handleInsert(InsertionContext context) {
+ FeatureUsageTracker.getInstance().triggerFeatureUsed(JavaCompletionFeatures.GLOBAL_MEMBER_NAME);
+
(willBeImported() ? myImportInsertion : myQualifiedInsertion).handleInsert(context, this);
}
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.Set;
public class JavaPsiClassReferenceElement extends LookupItem<Object> {
public static final ClassConditionKey<JavaPsiClassReferenceElement> CLASS_CONDITION_KEY = ClassConditionKey.create(JavaPsiClassReferenceElement.class);
private final Object myClass;
+ private volatile Reference<PsiClass> myCache;
private final String myQualifiedName;
private String myForcedPresentableName;
@Override
public PsiClass getObject() {
if (myClass instanceof PsiAnchor) {
+ Reference<PsiClass> cache = myCache;
+ if (cache != null) {
+ PsiClass psiClass = cache.get();
+ if (psiClass != null) {
+ return psiClass;
+ }
+ }
+
final PsiClass retrieve = (PsiClass)((PsiAnchor)myClass).retrieve();
assert retrieve != null : myQualifiedName;
+ myCache = new WeakReference<PsiClass>(retrieve);
return retrieve;
}
return (PsiClass)myClass;
PsiElement position = params.getPosition();
if (!BasicExpressionCompletionContributor.AFTER_DOT.accepts(position)) {
for (ExpectedTypeInfo info : mergedInfos) {
- new JavaMembersGetter(info.getType(), position).addMembers(params, !quick, consumer);
+ new JavaMembersGetter(info.getType(), params).addMembers(!quick, consumer);
if (!info.getDefaultType().equals(info.getType())) {
- new JavaMembersGetter(info.getDefaultType(), position).addMembers(params, !quick, consumer);
+ new JavaMembersGetter(info.getDefaultType(), params).addMembers(!quick, consumer);
}
}
}
import com.intellij.codeInsight.lookup.AutoCompletionPolicy;\r
import com.intellij.codeInsight.lookup.LookupElement;\r
import com.intellij.codeInsight.lookup.VariableLookupItem;\r
+import com.intel