--- /dev/null
+<component name="libraryTable">
+ <library name="commons-lang">
+ <CLASSES>
+ <root url="jar://$PROJECT_DIR$/lib/commons-lang-2.4.jar!/" />
+ </CLASSES>
+ <JAVADOC />
+ <SOURCES />
+ </library>
+</component>
\ No newline at end of file
# ---------------------------------------------------------------------
if [ -z "$IDEA_JDK" ]; then
IDEA_JDK=$JDK_HOME
+ if [ -z "$IDEA_JDK" -a -e "$JAVA_HOME/lib/tools.jar" ]; then
+ IDEA_JDK=$JAVA_HOME
+ fi
+ if [ -z "$IDEA_JDK" ]; then
+ # Try to get the jdk path from java binary path
+ JAVA_BIN_PATH=`which java`
+ if [ -n "$JAVA_BIN_PATH" ]; then
+ JAVA_LOCATION=`readlink -f $JAVA_BIN_PATH | xargs dirname | xargs dirname | xargs dirname`
+ if [ -x "$JAVA_LOCATION/bin/java" -a -e "$JAVA_LOCATION/lib/tools.jar" ]; then
+ IDEA_JDK=$JAVA_LOCATION
+ fi
+ fi
+ fi
if [ -z "$IDEA_JDK" ]; then
echo ERROR: cannot start IntelliJ IDEA.
echo No JDK found to run IDEA. Please validate either IDEA_JDK or JDK_HOME points to valid JDK installation
package com.intellij.compiler.actions;
import com.intellij.history.LocalHistory;
-import com.intellij.history.LocalHistoryConfiguration;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.actionSystem.PlatformDataKeys;
protected void doAction(DataContext dataContext, final Project project) {
CompilerManager.getInstance(project).rebuild(new CompileStatusNotification() {
public void finished(boolean aborted, int errors, int warnings, final CompileContext compileContext) {
- if (!aborted && LocalHistoryConfiguration.getInstance().ADD_LABEL_ON_PROJECT_COMPILATION) {
- String text = getTemplatePresentation().getText();
- if (!project.isDisposed()) {
- LocalHistory.putSystemLabel(project, errors == 0
- ? CompilerBundle.message("rebuild.lvcs.label.no.errors", text)
- : CompilerBundle.message("rebuild.lvcs.label.with.errors", text));
- }
- }
+ if (aborted) return;
+
+ String text = getTemplatePresentation().getText();
+ LocalHistory.getInstance().putSystemLabel(project, errors == 0
+ ? CompilerBundle.message("rebuild.lvcs.label.no.errors", text)
+ : CompilerBundle.message("rebuild.lvcs.label.with.errors", text));
}
});
}
if (file.getFileSystem() instanceof LocalFileSystem) {
if (file.isDirectory()) {
if (dbOnly) {
- for (VirtualFile child : ((NewVirtualFile)file).getInDbChildren()) {
- if (NullVirtualFile.INSTANCE != child) {
- processRecursively(child, true, processor);
- }
+ for (VirtualFile child : ((NewVirtualFile)file).iterInDbChildren()) {
+ processRecursively(child, true, processor);
}
}
else {
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.runners.JavaPatchableProgramRunner;
import com.intellij.execution.ui.RunContentDescriptor;
-import com.intellij.history.LocalHistory;
-import com.intellij.history.LocalHistoryConfiguration;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
protected RunContentDescriptor doExecute(final Project project, final Executor executor, final RunProfileState state, final RunContentDescriptor contentToReuse,
final ExecutionEnvironment env) throws ExecutionException {
FileDocumentManager.getInstance().saveAllDocuments();
+ return createContentDescriptor(project, executor, state, contentToReuse, env);
+ }
- if (LocalHistoryConfiguration.getInstance().ADD_LABEL_ON_RUNNING) {
- final String name = env.getRunProfile().getName();
- final String label = state instanceof RemoteState
- ? DebuggerBundle.message("debugger.runner.vcs.label.remote.debug", name)
- : DebuggerBundle.message("debugger.runner.vcs.label.debugging", name);
- LocalHistory.putSystemLabel(project, label);
- }
+ @Override
+ protected String getLocalHistoryLabel(RunProfile profile, RunProfileState state) {
+ final String name = profile.getName();
+ return state instanceof RemoteState
+ ? DebuggerBundle.message("debugger.runner.vcs.label.remote.debug", name)
+ : DebuggerBundle.message("debugger.runner.vcs.label.debugging", name);
- return createContentDescriptor(project, executor, state, contentToReuse, env);
}
@Nullable
final FrameworkSupportNode frameworkSupportNode = (FrameworkSupportNode)node;
frameworkSupportNode.setConfigurableComponentEnabled(node.isChecked());
updateOptionsPanel();
+ frameworkSupportNode.getConfigurable().onFrameworkSelectionChanged(node.isChecked());
myModel.onFrameworkSelectionChanged(frameworkSupportNode);
}
};
import com.intellij.openapi.ui.popup.PopupStep;
import com.intellij.openapi.ui.popup.util.BaseListPopupStep;
import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.text.StringUtil;
super(project, MESSAGE, ProjectBundle.message("external.annotation.prompt"), Messages.getQuestionIcon());
myProject = project;
init();
- Disposer.register(myProject, myDisposable);
}
protected String getOkActionName() {
public void handleInsert(InsertionContext context, LookupElementDecorator<LookupItem> item) {
@SuppressWarnings({"unchecked"}) final LookupItem<PsiClass> delegate = item.getDelegate();
- delegate.handleInsert(context);
insertParentheses(context, delegate, delegate.getObject());
+ DefaultInsertHandler.addImportForItem(context.getFile(), context.getStartOffset(), delegate);
+
final PsiElement position = SmartCompletionDecorator.getPosition(context, delegate);
final PsiExpression enclosing = PsiTreeUtil.getContextOfType(position, PsiExpression.class, true);
}
public static void insertParentheses(InsertionContext context, LookupItem delegate, final PsiClass psiClass) {
- PsiDocumentManager.getInstance(context.getProject()).doPostponedOperationsAndUnblockDocument(context.getEditor().getDocument());
-
final PsiElement place = context.getFile().findElementAt(context.getStartOffset());
final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(context.getProject()).getResolveHelper();
assert place != null;
final boolean needLeftParenth = isToInsertParenth();
final boolean hasParams = needLeftParenth && hasParams();
- if (CompletionUtil.isOverwrite(item, completionChar))
+ if (CompletionUtil.isOverwrite(item, completionChar)) {
removeEndOfIdentifier(needLeftParenth && hasParams);
- else if(myContext.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET) != myContext.getSelectionEndOffset())
+ }
+ else if(myContext.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET) != myContext.getSelectionEndOffset()) {
JavaCompletionUtil.resetParensInfo(context.getOffsetMap());
+ }
handleParenses(hasParams, needLeftParenth, tailType);
handleBrackets();
}
}
- private boolean isToInsertParenth(){
+ protected boolean isToInsertParenth(){
return insertingAnnotationWithParameters();
}
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.patterns.ElementPattern;
import com.intellij.patterns.PatternCondition;
-import static com.intellij.patterns.PsiJavaPatterns.*;
import com.intellij.patterns.PsiNameValuePairPattern;
import com.intellij.psi.*;
import com.intellij.psi.filters.*;
import java.util.LinkedHashSet;
import java.util.Set;
+import static com.intellij.patterns.PsiJavaPatterns.*;
+
/**
* @author peter
*/
@Nullable
private static ElementFilter getReferenceFilter(PsiElement position) {
// Completion after extends in interface, type parameter and implements in class
- final PsiClass containingClass = PsiTreeUtil.getParentOfType(position, PsiClass.class, false, PsiCodeBlock.class, PsiMethod.class, PsiExpressionList.class);
+ final PsiClass containingClass = PsiTreeUtil.getParentOfType(position, PsiClass.class, false, PsiCodeBlock.class, PsiMethod.class, PsiExpressionList.class, PsiVariable.class);
if (containingClass != null && psiElement().afterLeaf(PsiKeyword.EXTENDS, PsiKeyword.IMPLEMENTS, ",", "&").accepts(position)) {
return new AndFilter(ElementClassFilter.CLASS, new NotFilter(new AssignableFromContextFilter()));
}
new ParentElementFilter(new ClassFilter(PsiTryStatement.class)))
)));
public static final PsiJavaElementPattern.Capture<PsiElement> INSIDE_PARAMETER_LIST =
- PsiJavaPatterns.psiElement().withSuperParent(
- 2,
+ PsiJavaPatterns.psiElement().withParent(
psiElement(PsiJavaCodeReferenceElement.class).withParent(
psiElement(PsiTypeElement.class).withParent(PsiParameterList.class)));
public static final InsertHandler<JavaPsiClassReferenceElement> JAVA_CLASS_INSERT_HANDLER = new InsertHandler<JavaPsiClassReferenceElement>() {
public void handleInsert(final InsertionContext context, final JavaPsiClassReferenceElement item) {
if (completingRawConstructor(context, item)) {
- DefaultInsertHandler.NO_TAIL_HANDLER.handleInsert(context, item);
ConstructorInsertHandler.insertParentheses(context, item, item.getObject());
+ DefaultInsertHandler.addImportForItem(context.getFile(), context.getStartOffset(), item);
} else {
new DefaultInsertHandler().handleInsert(context, item);
}
JavaCompletionUtil.setShowFQN((LookupItem)item);
} else {
}
- ((LookupItem) item).setInsertHandler(DefaultInsertHandler.NO_TAIL_HANDLER);
result.addElement(decorate(LookupElementDecorator.withInsertHandler((LookupItem)item, ConstructorInsertHandler.INSTANCE), infos));
}
}
item.setAttribute(LookupItem.INDICATE_ANONYMOUS, "");
}
- item.setInsertHandler(DefaultInsertHandler.NO_TAIL_HANDLER);
result.addElement(decorate(type instanceof PsiClassType ? LookupElementDecorator.withInsertHandler(item, ConstructorInsertHandler.INSTANCE) : item, infos));
}
PsiElement element = file.findElementAt(context.getStartOffset());
if (element instanceof PsiIdentifier) {
element = element.getParent();
- while (element instanceof PsiJavaCodeReferenceElement || element instanceof PsiMethodCallExpression ||
+ while (element instanceof PsiJavaCodeReferenceElement || element instanceof PsiCall ||
element instanceof PsiThisExpression || element instanceof PsiSuperExpression ||
element instanceof PsiTypeElement ||
element instanceof PsiClassObjectAccessExpression) {
int newEnd = element.getTextRange().getEndOffset();
if (element instanceof PsiMethodCallExpression) {
- newEnd = ((PsiMethodCallExpression)element).getMethodExpression().getElement().getTextRange().getEndOffset();
+ newEnd = ((PsiMethodCallExpression)element).getMethodExpression().getTextRange().getEndOffset();
+ }
+ else if (element instanceof PsiNewExpression) {
+ final PsiJavaCodeReferenceElement classReference = ((PsiNewExpression)element).getClassReference();
+ if (classReference != null) {
+ newEnd = classReference.getTextRange().getEndOffset();
+ }
}
context.getOffsetMap().addOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET, newEnd);
element = element.getParent();
@Override public void visitReferenceExpression(PsiReferenceExpression expression) {
final PsiExpression qualifier = expression.getQualifierExpression();
- if (qualifier == null || qualifier instanceof PsiThisExpression && ((PsiThisExpression)qualifier).getQualifier() == null) {
+ if (qualifier == null || qualifier instanceof PsiThisExpression) {
final PsiElement resolved = expression.resolve();
if (resolved instanceof PsiField) {
final PsiField field = (PsiField)resolved;
"}";
private static final String INDENT_AND_BRACES_SAMPLE = "public class Foo {\n" +
+ " public Foo foo;\n" +
" public int[] X = new int[]{1, 3, 5 7, 9, 11};\n" +
"\n" +
" public void foo(boolean a, int x, int y, int z) {\n" +
" while (x < 10000);\n" +
" while (x < 50000) x++;\n" +
" for (int i = 0; i < 5; i++) System.out.println(i);\n" +
+ " foo.fooBar().fooBar()\n" +
+ " .fooBar().foo.fooBar().fooBar()\n" +
+ " .fooBar();\n" +
+ " }\n" +
+ "\n" +
+ " public Foo fooBar() {\n" +
+ " return this;\n" +
" }\n" +
"\n" +
" private class InnerClass implements I1, I2 {\n" +
myIsAfterClassKeyword = true;
}
if (childType == JavaElementType.METHOD_CALL_EXPRESSION) {
- result.add(createMethodCallExpressiobBlock(child,
+ result.add(createMethodCallExpressionBlock(child,
arrangeChildWrap(child, defaultWrap),
arrangeChildAlignment(child, defaultAlignment)));
}
return role == ChildRole.OPERATION_SIGN || role == ChildRole.COLON;
}
- private Block createMethodCallExpressiobBlock(final ASTNode node, final Wrap blockWrap, final Alignment alignment) {
+ private Block createMethodCallExpressionBlock(final ASTNode node, final Wrap blockWrap, final Alignment alignment) {
final ArrayList<ASTNode> nodes = new ArrayList<ASTNode>();
final ArrayList<Block> subBlocks = new ArrayList<Block>();
collectNodes(nodes, node);
final Wrap wrap = Wrap.createWrap(getWrapType(mySettings.METHOD_CALL_CHAIN_WRAP), false);
+ // We use this alignment object to align chained method calls to the first method invocation place if necessary (see IDEA-30369)
+ Alignment chainedCallsAlignment = createAlignment(mySettings.ALIGN_MULTILINE_CHAINED_METHODS, null);
+
+ // We want to align chained method calls only if method target is explicitly specified, i.e. we don't want to align methods
+ // chain like 'recursive().recursive().recursive()' but want to align calls like 'foo.recursive().recursive().recursive()'
+ boolean callPointDefined = false;
+
while (!nodes.isEmpty()) {
ArrayList<ASTNode> subNodes = readToNextDot(nodes);
- subBlocks.add(createSynthBlock(subNodes, wrap));
+ Alignment alignmentToUseForSubBlock = null;
+
+ // Just create a no-aligned sub-block if we don't need to bother with it's alignment (either due to end-user
+ // setup or sub-block state).
+ if (chainedCallsAlignment == null || subNodes.isEmpty()) {
+ subBlocks.add(createSynthBlock(subNodes, wrap, alignmentToUseForSubBlock));
+ continue;
+ }
+
+ IElementType lastNodeType = subNodes.get(subNodes.size() - 1).getElementType();
+ boolean currentSubBlockIsMethodCall = lastNodeType == JavaElementType.EXPRESSION_LIST;
+
+ // Update information about chained method alignment point if necessary. I.e. we want to align only continuous method calls
+ // like 'foo.bar().bar().bar()' but not 'foo.bar().foo.bar()'
+ if (callPointDefined && !currentSubBlockIsMethodCall) {
+ chainedCallsAlignment = createAlignment(mySettings.ALIGN_MULTILINE_CHAINED_METHODS, null);
+ }
+ callPointDefined |= !currentSubBlockIsMethodCall;
+
+ // We want to align method call only if call target is defined for the first chained method and current block is a method call.
+ if (callPointDefined && currentSubBlockIsMethodCall) {
+ alignmentToUseForSubBlock = chainedCallsAlignment;
+ }
+ subBlocks.add(createSynthBlock(subNodes, wrap, alignmentToUseForSubBlock));
}
return new SyntheticCodeBlock(subBlocks, alignment, mySettings, Indent.getContinuationWithoutFirstIndent(),
blockWrap);
}
- private Block createSynthBlock(final ArrayList<ASTNode> subNodes, final Wrap wrap) {
+ private Block createSynthBlock(final ArrayList<ASTNode> subNodes, final Wrap wrap, final Alignment alignment) {
final ArrayList<Block> subBlocks = new ArrayList<Block>();
final ASTNode firstNode = subNodes.get(0);
if (firstNode.getElementType() == JavaTokenType.DOT) {
null));
subNodes.remove(0);
if (!subNodes.isEmpty()) {
- subBlocks.add(createSynthBlock(subNodes, wrap));
+ subBlocks.add(createSynthBlock(subNodes, wrap, null));
}
- return new SyntheticCodeBlock(subBlocks, null, mySettings, Indent.getContinuationIndent(), wrap);
+ return new SyntheticCodeBlock(subBlocks, alignment, mySettings, Indent.getContinuationIndent(), wrap);
}
else {
- return new SyntheticCodeBlock(createJavaBlocks(subNodes), null, mySettings,
+ return new SyntheticCodeBlock(createJavaBlocks(subNodes), alignment, mySettings,
Indent.getContinuationWithoutFirstIndent(), null);
}
}
import com.intellij.psi.presentation.java.JavaPresentationUtil;
import com.intellij.psi.scope.PsiScopeProcessor;
import com.intellij.psi.search.SearchScope;
+import com.intellij.psi.stubs.IStubElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.ui.RowIcon;
import com.intellij.util.Icons;
private volatile Object myCachedInitializerValue = null; // PsiExpression on constant value for literal
public PsiFieldImpl(final PsiFieldStub stub) {
- super(stub, JavaStubElementTypes.FIELD);
+ this(stub, JavaStubElementTypes.FIELD);
+ }
+
+ protected PsiFieldImpl(final PsiFieldStub stub, final IStubElementType type) {
+ super(stub, type);
}
public PsiFieldImpl(final ASTNode node) {
import com.intellij.psi.presentation.java.JavaPresentationUtil;
import com.intellij.psi.scope.PsiScopeProcessor;
import com.intellij.psi.search.SearchScope;
+import com.intellij.psi.stubs.IStubElementType;
import com.intellij.psi.util.MethodSignature;
import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
import com.intellij.psi.util.PsiTreeUtil;
private PatchedSoftReference<PsiType> myCachedType = null;
public PsiMethodImpl(final PsiMethodStub stub) {
- super(stub, JavaStubElementTypes.METHOD);
+ this(stub, JavaStubElementTypes.METHOD);
+ }
+
+ protected PsiMethodImpl(final PsiMethodStub stub, final IStubElementType type) {
+ super(stub, type);
}
public PsiMethodImpl(final ASTNode node) {
public static void normalizeBrackets(PsiVariable variable) {
CompositeElement variableElement = (CompositeElement)SourceTreeToPsiMap.psiElementToTree(variable);
- ASTNode type = variableElement.findChildByRole(ChildRole.TYPE);
- LOG.assertTrue(type.getTreeParent() == variableElement);
- ASTNode name = variableElement.findChildByRole(ChildRole.NAME);
+
+ PsiTypeElement typeElement = variable.getTypeElement();
+ PsiIdentifier nameElement = variable.getNameIdentifier();
+ LOG.assertTrue(typeElement != null && nameElement != null);
+
+ ASTNode type = typeElement.getNode();
+ ASTNode name = nameElement.getNode();
ASTNode firstBracket = null;
ASTNode lastBracket = null;
final Language ql = findLanguageByID("JPAQL");
final Language js = findLanguageByID("JavaScript");
if (ql == null || js == null) return;
+ final Language ecma4 = findLanguageByID("ECMA Script Level 4");
final MultiHostInjector myMultiHostInjector = new MultiHostInjector() {
public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull PsiElement context) {
inject(host, placesToInject, js);
return;
}
+ if (ecma4 != null && "ecma4".equals(tag.getLocalName())) {
+ inject(host, placesToInject, ecma4);
+ return;
+ }
if ("jsprefix".equals(tag.getLocalName())) {
inject(host, placesToInject, js, "function foo(doc, window){", "}");
return;
import com.intellij.lang.ASTNode;
import com.intellij.psi.JavaTokenType;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiField;
import com.intellij.psi.impl.PsiImplUtil;
import com.intellij.psi.impl.source.Constants;
import com.intellij.psi.impl.source.tree.*;
import com.intellij.psi.tree.ChildRoleBase;
import com.intellij.psi.tree.IElementType;
+import com.intellij.util.CharTable;
import org.jetbrains.annotations.NotNull;
public class FieldElement extends CompositeElement{
super(Constants.FIELD);
}
+ protected FieldElement(@NotNull IElementType type) {
+ super(type);
+ }
+
public int getTextOffset() {
return findChildByRole(ChildRole.NAME).getStartOffset();
}
return ChildRoleBase.NONE;
}
}
+
+ @Override
+ public ASTNode copyElement() {
+ final CharTable table = SharedImplUtil.findCharTableByTree(this);
+ final PsiClass psiClass = ((PsiField)getPsi()).getContainingClass();
+ return psiClass != null ? ChangeUtil.copyElement(this, psiClass.getTypeParameterList(), table) : super.copyElement();
+ }
}
}
protected void performRefactoring(UsageInfo[] usages) {
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName());
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName());
try {
doRefactoring(usages);
}
protected void performRefactoring(UsageInfo[] usages) {
if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, myTargetClass)) return;
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName());
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName());
try {
doRefactoring(usages);
}
}
PsiClass source = findByName(sources, destination.getName());
if (source != null) {
- final PsiClass copy = copy(destination, copyClassName);
+ final PsiClass copy = copy(source, copyClassName);
newElement = destination.replace(copy);
oldToNewMap.put(source, newElement);
}
private static PsiClass[] getTopLevelClasses(PsiElement element) {
while (true) {
if (element == null || element instanceof PsiFile) break;
- if (element instanceof PsiClass && (((PsiClass)element).getContainingClass() == null)) break;
- element = element.getContext();
+ if (element instanceof PsiClass && element.getParent() != null && (((PsiClass)element).getContainingClass() == null)) break;
+ element = element.getParent();
}
if (element instanceof PsiClassOwner) {
PsiClass[] classes = ((PsiClassOwner)element).getClasses();
private void doRefactoring() throws IncorrectOperationException {
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName());
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName());
PsiClass anInterface = null;
try {
anInterface = extractInterface(myTargetDir, myClass, myInterfaceName, mySelectedMembers, myJavaDocPolicy);
final PsiDirectory targetDirectory = dialog.getTargetDirectory();
final MemberInfo[] selectedMemberInfos = dialog.getSelectedMemberInfos();
final DocCommentPolicy javaDocPolicy = new DocCommentPolicy(dialog.getJavaDocPolicy());
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName(subclass, superclassName));
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName(subclass, superclassName));
try {
PsiClass superclass = null;
if (!myIsInnerClassNeeded) return;
PsiClass innerClass = myFactory.createClass(myInnerClassName);
- final PsiJavaCodeReferenceElement baseClassReferenceElement = myFactory.createClassReferenceElement(myBaseClass);
+ final PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(myBaseClass, myClass, PsiSubstitutor.EMPTY);
+ final PsiClassType superClassType = myFactory.createType(myBaseClass, superClassSubstitutor);
+ final PsiJavaCodeReferenceElement baseClassReferenceElement = myFactory.createReferenceElementByType(superClassType);
if (!myBaseClass.isInterface()) {
innerClass.getExtendsList().add(baseClassReferenceElement);
} else {
myEditor.getCaretModel().moveToLogicalPosition(pos);
}
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName());
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName());
try {
doRefactoring(usages);
}
ElementToWorkOn.processElementToWorkOn(editor, file, REFACTORING_NAME, getHelpID(), project, getElementProcessor(project, editor));
}
- protected boolean invokeImpl(Project project, final PsiLocalVariable localVariable, Editor editor) {
- final LocalToFieldHandler localToFieldHandler = new LocalToFieldHandler(project, true);
+ protected boolean invokeImpl(final Project project, final PsiLocalVariable localVariable, final Editor editor) {
+ final LocalToFieldHandler localToFieldHandler = new LocalToFieldHandler(project, true){
+ @Override
+ protected Settings showRefactoringDialog(PsiClass aClass,
+ PsiLocalVariable local,
+ PsiExpression[] occurences,
+ boolean isStatic) {
+ return IntroduceConstantHandler.this.showRefactoringDialog(project, editor, aClass, local.getInitializer(), local.getType(), occurences, null, null);
+ }
+ };
return localToFieldHandler.convertLocalToField(localVariable, editor);
}
}
}
- IntroduceConstantDialog dialog =
+ final IntroduceConstantDialog dialog =
new IntroduceConstantDialog(project, parentClass, expr, localVariable, false, occurences, getParentClass(),
new TypeSelectorManagerImpl(project, type, expr, occurences));
dialog.show();
return new ExpressionOccurenceManager(selectedExpr, parentClass, occurenceFilter, true);
}
- protected boolean invokeImpl(Project project, PsiLocalVariable localVariable, Editor editor) {
- LocalToFieldHandler localToFieldHandler = new LocalToFieldHandler(project, false);
+ protected boolean invokeImpl(final Project project, PsiLocalVariable localVariable, final Editor editor) {
+ LocalToFieldHandler localToFieldHandler = new LocalToFieldHandler(project, false){
+ @Override
+ protected Settings showRefactoringDialog(PsiClass aClass,
+ PsiLocalVariable local,
+ PsiExpression[] occurences,
+ boolean isStatic) {
+ final PsiStatement statement = PsiTreeUtil.getParentOfType(local, PsiStatement.class);
+ return IntroduceFieldHandler.this.showRefactoringDialog(project, editor, aClass, local.getInitializer(), local.getType(), occurences, statement, statement);
+ }
+ };
return localToFieldHandler.convertLocalToField(localVariable, editor);
}
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.refactoring.HelpID;
import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.ui.TypeSelectorManagerImpl;
import com.intellij.refactoring.util.CommonRefactoringUtil;
import com.intellij.refactoring.util.EnumConstantsUtil;
import com.intellij.refactoring.util.RefactoringUtil;
import static com.intellij.refactoring.introduceField.BaseExpressionToFieldHandler.InitializationPlace.IN_CONSTRUCTOR;
import static com.intellij.refactoring.introduceField.BaseExpressionToFieldHandler.InitializationPlace.IN_FIELD_DECLARATION;
-public class LocalToFieldHandler {
+public abstract class LocalToFieldHandler {
private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.introduceField.LocalToFieldHandler");
private static final String REFACTORING_NAME = RefactoringBundle.message("convert.local.to.field.title");
myIsConstant = isConstant;
}
- protected BaseExpressionToFieldHandler.Settings showRefactoringDialog(PsiClass aClass, PsiLocalVariable local, PsiExpression[] occurences, boolean isStatic) {
- final String fieldName;
- final BaseExpressionToFieldHandler.InitializationPlace initializerPlace;
- final boolean declareFinal;
- @Modifier String fieldVisibility;
- final TypeSelectorManagerImpl typeSelectorManager = new TypeSelectorManagerImpl(myProject, local.getType(),
- occurences
- );
-
- final boolean annotateAsNonNls;
- final boolean introduceEnumConstant;
- if (myIsConstant) {
- IntroduceConstantDialog dialog = new IntroduceConstantDialog(myProject, aClass,
- local.getInitializer(), local, true, occurences, aClass, typeSelectorManager
- );
- dialog.show();
- if (!dialog.isOK()) return null;
- fieldName = dialog.getEnteredName();
- declareFinal = true;
- initializerPlace = IN_FIELD_DECLARATION;
- fieldVisibility = dialog.getFieldVisibility();
- annotateAsNonNls = dialog.isAnnotateAsNonNls();
- introduceEnumConstant = dialog.introduceEnumConstant();
- }
- else {
- PsiMethod method = PsiTreeUtil.getParentOfType(local, PsiMethod.class);
- IntroduceFieldDialog dialog = new IntroduceFieldDialog(myProject, aClass,
- local.getInitializer(), local,
- method != null && method.isConstructor(),
- true, isStatic,
- occurences.length, method != null, method != null,
- typeSelectorManager
- );
- dialog.show();
- if (!dialog.isOK()) return null;
- fieldName = dialog.getEnteredName();
- initializerPlace = dialog.getInitializerPlace();
- declareFinal = dialog.isDeclareFinal();
- fieldVisibility = dialog.getFieldVisibility();
- annotateAsNonNls = false;
- introduceEnumConstant = false;
- }
-
- return new BaseExpressionToFieldHandler.Settings(fieldName, true, isStatic, declareFinal, initializerPlace, fieldVisibility, local, null, true, new BaseExpressionToFieldHandler.TargetDestination(aClass), annotateAsNonNls,
- introduceEnumConstant);
- }
+ protected abstract BaseExpressionToFieldHandler.Settings showRefactoringDialog(PsiClass aClass, PsiLocalVariable local, PsiExpression[] occurences, boolean isStatic);
public boolean convertLocalToField(final PsiLocalVariable local, final Editor editor) {
PsiClass aClass;
import com.intellij.psi.search.LocalSearchScope;
import com.intellij.psi.search.searches.OverridingMethodsSearch;
import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.InheritanceUtil;
-import com.intellij.psi.util.MethodSignatureUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
+import com.intellij.psi.util.*;
import com.intellij.refactoring.BaseRefactoringProcessor;
import com.intellij.refactoring.RefactoringBundle;
import com.intellij.refactoring.listeners.JavaRefactoringListenerManager;
ChangeContextUtil.encodeContextInfo(info.getMember(), true);
}
+ final PsiSubstitutor substitutor = upDownSuperClassSubstitutor();
+ final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject);
+
// do actual move
for (MemberInfo info : myMembersToMove) {
if (info.getMember() instanceof PsiMethod) {
PsiMethod methodCopy = (PsiMethod)method.copy();
ChangeContextUtil.clearContextInfo(method);
RefactoringUtil.abstractizeMethod(myTargetSuperClass, methodCopy);
-
+ RefactoringUtil.replaceMovedMemberTypeParameters(methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
if (method.findDeepestSuperMethods().length == 0 || (myTargetSuperClass.isInterface() && !PsiUtil.isLanguageLevel6OrHigher(mySourceClass))) {
deleteOverrideAnnotationIfFound(methodCopy);
}
if (isOriginalMethodAbstract) {
PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true);
}
+ RefactoringUtil.replaceMovedMemberTypeParameters(method, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(method, movedMembers);
final PsiMethod superClassMethod = myTargetSuperClass.findMethodBySignature(method, false);
if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
else if (info.getMember() instanceof PsiField) {
PsiField field = (PsiField)info.getMember();
field.normalizeDeclaration();
+ RefactoringUtil.replaceMovedMemberTypeParameters(field, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(field, movedMembers);
if (myIsTargetInterface) {
PsiUtil.setModifierProperty(field, PsiModifier.PUBLIC, true);
RefactoringUtil.removeFromReferenceList(sourceReferenceList, aClass) :
RefactoringUtil.findReferenceToClass(sourceReferenceList, aClass);
if (ref != null) {
+ RefactoringUtil.replaceMovedMemberTypeParameters(ref, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
final PsiReferenceList referenceList =
myTargetSuperClass.isInterface() ? myTargetSuperClass.getExtendsList() : myTargetSuperClass.getImplementsList();
assert referenceList != null;
}
}
else {
+ RefactoringUtil.replaceMovedMemberTypeParameters(aClass, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory);
fixReferencesToStatic(aClass, movedMembers);
final PsiMember movedElement = (PsiMember)myTargetSuperClass.add(aClass);
myMembersAfterMove.add(movedElement);
}
}
+ private PsiSubstitutor upDownSuperClassSubstitutor() {
+ PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
+ for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(mySourceClass)) {
+ substitutor = substitutor.put(parameter, null);
+ }
+ final Map<PsiTypeParameter, PsiType> substitutionMap =
+ TypeConversionUtil.getSuperClassSubstitutor(myTargetSuperClass, mySourceClass, PsiSubstitutor.EMPTY).getSubstitutionMap();
+ for (PsiTypeParameter parameter : substitutionMap.keySet()) {
+ final PsiType type = substitutionMap.get(parameter);
+ final PsiClass resolvedClass = PsiUtil.resolveClassInType(type);
+ if (resolvedClass instanceof PsiTypeParameter) {
+ substitutor = substitutor.put((PsiTypeParameter)resolvedClass, JavaPsiFacade.getElementFactory(myProject).createType(parameter));
+ }
+ }
+ return substitutor;
+ }
+
private static void deleteOverrideAnnotationIfFound(PsiMethod oMethod) {
final PsiAnnotation annotation = AnnotationUtil.findAnnotation(oMethod, Override.class.getName());
if (annotation != null) {
private void pushDownToClass(PsiClass targetClass) throws IncorrectOperationException {
final PsiElementFactory factory = JavaPsiFacade.getInstance(myClass.getProject()).getElementFactory();
final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(myClass, targetClass, PsiSubstitutor.EMPTY);
- for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(myClass)) {
- for (PsiReference reference : ReferencesSearch.search(parameter)) {
- final PsiElement element = reference.getElement();
- final PsiMember member = PsiTreeUtil.getParentOfType(element, PsiMember.class);
- if (member != null) {
- for (MemberInfo memberInfo : myMemberInfos) {
- if (PsiTreeUtil.isAncestor(memberInfo.getMember(), member, false)) {
- PsiType substitutedType = substitutor.substitute(parameter);
- if (substitutedType == null) {
- substitutedType = TypeConversionUtil.erasure(factory.createType(parameter));
- }
- element.getParent().replace(factory.createTypeElement(substitutedType));
- break;
- }
- }
- }
- }
- }
for (MemberInfo memberInfo : myMemberInfos) {
- final PsiMember member = memberInfo.getMember();
+ PsiMember member = memberInfo.getMember();
final List<PsiReference> refsToRebind = new ArrayList<PsiReference>();
final PsiModifierList list = member.getModifierList();
LOG.assertTrue(list != null);
refsToRebind.add(reference);
}
}
-
+ member = (PsiMember)member.copy();
+ RefactoringUtil.replaceMovedMemberTypeParameters(member, PsiUtil.typeParametersIterable(myClass), substitutor, factory);
PsiMember newMember = null;
if (member instanceof PsiField) {
((PsiField)member).normalizeDeclaration();
protected void performRefactoring(UsageInfo[] usages) {
PsiManager psiManager = PsiManager.getInstance(myProject);
final PsiMigration psiMigration = JavaPsiFacade.getInstance(psiManager.getProject()).startMigration();
- LocalHistoryAction a = LocalHistory.startAction(myProject, getCommandName());
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(getCommandName());
try {
for (int i = 0; i < myMigrationMap.getEntryCount(); i++) {
public void run() {
ApplicationManager.getApplication().runWriteAction(new Runnable() {
public void run() {
- LocalHistoryAction a = LocalHistory.startAction(project, commandDescription);
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(commandDescription);
try {
rearrangeDirectoriesToTarget(directories, selectedTarget);
}
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 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.
LOG.assertTrue(newElement != null);
final PsiReference reference = moveRenameUsage.getReference();
if (reference != null) {
- reference.bindToElement(newElement);
+ try {
+ reference.bindToElement(newElement);
+ } catch (IncorrectOperationException e) {//
+ }
}
}
}
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
+import com.intellij.psi.util.TypeConversionUtil;
import com.intellij.refactoring.PackageWrapper;
import com.intellij.refactoring.introduceField.ElementToWorkOn;
import com.intellij.refactoring.introduceVariable.IntroduceVariableBase;
return null;
}
+ public static void replaceMovedMemberTypeParameters(final PsiElement member,
+ final Iterable<PsiTypeParameter> parametersIterable,
+ final PsiSubstitutor substitutor,
+ final PsiElementFactory factory) {
+ for (PsiTypeParameter parameter : parametersIterable) {
+ for (PsiReference reference : ReferencesSearch.search(parameter, new LocalSearchScope(member))) {
+ final PsiElement element = reference.getElement();
+ PsiType substitutedType = substitutor.substitute(parameter);
+ if (substitutedType == null) {
+ substitutedType = TypeConversionUtil.erasure(factory.createType(parameter));
+ }
+ element.getParent().replace(factory.createTypeElement(substitutedType));
+ }
+ }
+ }
+
public static interface ImplicitConstructorUsageVisitor {
void visitConstructor(PsiMethod constructor, PsiMethod baseConstructor);
}
private static void replaceDuplicate(final Project project, final List<Match> duplicates, final PsiMethod method) {
- LocalHistoryAction a = LocalHistory.startAction(project, REFACTORING_NAME);
+ LocalHistoryAction a = LocalHistory.getInstance().startAction(REFACTORING_NAME);
try {
final ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator();
if (progressIndicator != null && progressIndicator.isCanceled()) return;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
import java.net.ServerSocket;
import java.net.Socket;
parms[j - 1] = args[j];
}
Method m = Class.forName(mainClass).getMethod("main", new Class[]{parms.getClass()});
+ if (!Modifier.isStatic(m.getModifiers())) {
+ System.err.println("main method should be static");
+ return;
+ }
try {
ensureAccess(m);
m.invoke(null, new Object[]{parms});
--- /dev/null
+public enum ButtonKey {
+ CANCEL_ALL,
+ CANCEL_SELL;
+
+ public static final ButtonKey[] ARR = {CANCEL_ALL, CANCEL_S<caret>};
+}
\ No newline at end of file
--- /dev/null
+public enum ButtonKey {
+ CANCEL_ALL,
+ CANCEL_SELL;
+
+ public static final ButtonKey[] ARR = {CANCEL_ALL, CANCEL_SELL<caret>};
+}
\ No newline at end of file
--- /dev/null
+public class Foo {
+ Object foo(bo<caret>){ }
+}
--- /dev/null
+public class Foo {
+ Object foo(boolean <caret>){ }
+}
--- /dev/null
+public class Main {
+
+ public void main(String[] args) {
+ Aaaa a = new Bbbb(<caret>2);
+ }
+
+ class Aaaa {
+ int aaa;
+
+ Aaaa(int aaa) {
+ this.aaa = aaa;
+ }
+ }
+
+ class Bbbb extends Aaaa{
+ Bbbb(int aaa) {
+ super(aaa);
+ }
+ }
+
+}
--- /dev/null
+public class Main {
+
+ public void main(String[] args) {
+ Aaaa a = new B<caret>Aaaa(2);
+ }
+
+ class Aaaa {
+ int aaa;
+
+ Aaaa(int aaa) {
+ this.aaa = aaa;
+ }
+ }
+
+ class Bbbb extends Aaaa{
+ Bbbb(int aaa) {
+ super(aaa);
+ }
+ }
+
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<problems/>
\ No newline at end of file
--- /dev/null
+public class Outer {
+ private int value = 0;
+
+ public class Inner {
+ private final int myValue = Outer.this.value;
+ }
+}
\ No newline at end of file
* at least as large as the list size. As elements are added to an ArrayList,
* its capacity grows automatically. The details of the growth policy are not
* specified beyond the fact that adding an element has constant amortized
- * time cost.<p>
+ * time cost.<p>
*
* An application can increase the capacity of an <tt>ArrayList</tt> instance
* before adding a large number of elements using the <tt>ensureCapacity</tt>
* Note that the fail-fast behavior of an iterator cannot be guaranteed
* as it is, generally speaking, impossible to make any hard guarantees in the
* presence of unsynchronized concurrent modification. Fail-fast iterators
- * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
+ * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i>the fail-fast behavior of iterators
* should be used only to detect bugs.</i><p>
*
- * This class is a member of the
+ * This class is a member of the
* <a href="{@docRoot}/../guide/collections/index.html">
* Java Collections Framework</a>.
*
size = c.size();
// Allow 10% room for growth
elementData = (E[])new Object[
- (int)Math.min((size*110L)/100,Integer.MAX_VALUE)];
+ (int)Math.min((size*110L)/100,Integer.MAX_VALUE)];
c.toArray(elementData);
}
/**
* Increases the capacity of this <tt>ArrayList</tt> instance, if
* necessary, to ensure that it can hold at least the number of elements
- * specified by the minimum capacity argument.
+ * specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity.
*/
}
/**
- * Searches for the first occurence of the given argument, testing
- * for equality using the <tt>equals</tt> method.
+ * Searches for the first occurence of the given argument, testing
+ * for equality using the <tt>equals</tt> method.
*
* @param elem an object.
* @return the index of the first occurrence of the argument in this
* @return a clone of this <tt>ArrayList</tt> instance.
*/
public Object clone() {
- try {
+ try {
Bar<E> v = (Bar<E>) super.clone();
v.elementData = (E[])new Object[size];
System.arraycopy(elementData, 0, v.elementData, 0, size);
v.modCount = 0;
return v;
- } catch (CloneNotSupportedException e) {
+ } catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
- System.arraycopy(elementData, index+1, elementData, index,
+ System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}
for (int i=0; i<size; i++)
a[i] = s.readObject();
}
-}
\ No newline at end of file
+}
--- /dev/null
+public class A {
+ public final MyIntf myDelegate = new MyIntf();
+
+ private class MyIntf implements Intf<Integer> {
+ public void method1(Integer t) {
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+public interface Intf<T> {
+ void method1(T t);
+}
\ No newline at end of file
--- /dev/null
+public class A implements Intf<Integer> {
+ public void method1(Integer t) {
+ }
+}
\ No newline at end of file
--- /dev/null
+public interface Intf<T> {
+ void method1(T t);
+}
\ No newline at end of file
--- /dev/null
+class Test {
+ Integer t;
+}
\ No newline at end of file
--- /dev/null
+class Test1 {
+ String t;
+}
\ No newline at end of file
--- /dev/null
+class Super<T> {
+ T t;
+}
\ No newline at end of file
--- /dev/null
+class Test extends Super<Integer>{
+}
\ No newline at end of file
--- /dev/null
+class Test1 extends Super<String>{
+}
\ No newline at end of file
--- /dev/null
+public abstract class Parent<S> {}
+
+class Child<T> extends Parent<T> {
+ void <caret>method(T t){}
+}
--- /dev/null
+public abstract class Parent<S> {
+ abstract void method(S t);
+}
+
+class Child<T> extends Parent<T> {
+ @Override
+ void method(T t){}
+}
--- /dev/null
+public class Parent<S> {}
+
+interface I<IT> {
+ void method(IT t);
+}
+
+class Child<T> extends Parent<T> implements I<T>{
+ <caret>
+ public void method(T t){}
+}
--- /dev/null
+public class Parent<S> implements I<S> {}
+
+interface I<IT> {
+ void method(IT t);
+}
+
+class Child<T> extends Parent<T> {
+
+ public void method(T t){}
+}
--- /dev/null
+public class Parent<S> {}
+
+class Child extends Parent<String> {
+ String <caret>f;
+}
--- /dev/null
+public class Parent<S> {
+ String f;
+}
+
+class Child extends Parent<String> {
+}
--- /dev/null
+public class Parent {}
+
+class Child<T> extends Parent {
+ T <caret>f;
+}
--- /dev/null
+public class Parent {
+ Object f;
+}
+
+class Child<T> extends Parent {
+}
--- /dev/null
+public class Parent<S> {}
+
+class Child<T> extends Parent<T> {
+ T <caret>f;
+}
--- /dev/null
+public class Parent<S> {
+ S f;
+}
+
+class Child<T> extends Parent<T> {
+}
public void testMethodParameterAnnotationClass() throws Throwable { doTest(); }
+ public void testEnumConstantFromEnumMember() throws Throwable { doTest(); }
+
+ public void testPrimitiveMethodParameter() throws Throwable { doTest(); }
+
}
checkResultByTestName();
}
+ public void testTabAfterNew() throws Exception {
+ configureByTestName();
+ select('\t');
+ checkResultByTestName();
+ }
+
private void doTest(boolean performAction, boolean selectItem) throws Exception {
configureByTestName();
if (performAction) {
public void testStateField() throws Exception { doTest(); }
public void testLocalStateVar2InnerClass() throws Exception { doTest(); }
public void testNotConstantInitializer() throws Exception {doTest();}
+ public void testInnerClassFieldInitializer() throws Exception {doTest();}
}
new String[]{"getDate"}, ArrayUtil.EMPTY_STRING_ARRAY, false, false));
}
+ public void testTypeParametersSubstitution() throws Exception {
+ doTest(createPerformAction("A", "myDelegate", "MyIntf", "Intf", new int[]{}, ArrayUtil.EMPTY_STRING_ARRAY, true, false));
+ }
private PerformAction createPerformAction(
final String className, final String fieldName, final String innerClassName,
}
public void testMultipleSubclasses() throws Exception {
+ doTestMultipleSubclasses();
+ }
+
+ public void testMultipleSubstitutions() throws Exception {
+ doTestMultipleSubclasses();
+ }
+
+ private void doTestMultipleSubclasses() throws Exception {
doTest(new PerformAction() {
public void performAction(final VirtualFile rootDir, final VirtualFile rootAfter) throws Exception {
PsiClass superClass = myJavaFacade.findClass("Super", GlobalSearchScope.allScope(myProject));
doTest(new MemberDescriptor ("get", PsiMethod.class));
}
+ public void testTypeParamErasure() throws Exception {
+ doTest(new MemberDescriptor("f", PsiField.class));
+ }
+
+ public void testTypeParamSubst() throws Exception {
+ doTest(new MemberDescriptor("f", PsiField.class));
+ }
+
+ public void testTypeArgument() throws Exception {
+ doTest(new MemberDescriptor("f", PsiField.class));
+ }
+
+ public void testGenericsInAbstractMethod() throws Exception {
+ doTest(new MemberDescriptor("method", PsiMethod.class, true));
+ }
+
+ public void testGenericsInImplements() throws Exception {
+ doTest(false, new MemberDescriptor("I", PsiClass.class));
+ }
+
private void doTest(MemberDescriptor... membersToFind) throws Exception {
+ doTest(true, membersToFind);
+ }
+
+ private void doTest(final boolean checkMemebersMovedCount, MemberDescriptor... membersToFind) throws Exception {
configureByFile(BASE_PATH + getTestName(false) + ".java");
PsiElement elementAt = getFile().findElementAt(getEditor().getCaretModel().getOffset());
final PsiClass sourceClass = PsiTreeUtil.getParentOfType(elementAt, PsiClass.class);
final PullUpHelper helper = new PullUpHelper(sourceClass, targetClass, infos, new DocCommentPolicy(DocCommentPolicy.ASIS));
helper.run();
JavaRefactoringListenerManager.getInstance(getProject()).removeMoveMembersListener(listener);
- assertEquals(countMoved[0], membersToFind.length);
+ if (checkMemebersMovedCount) {
+ assertEquals(countMoved[0], membersToFind.length);
+ }
checkResultByFile(BASE_PATH + getTestName(false) + "_after.java");
}
package com.intellij.execution.runners;
-import com.intellij.execution.ExecutionException;
-import com.intellij.execution.ExecutionManager;
-import com.intellij.execution.ExecutionResult;
-import com.intellij.execution.Executor;
+import com.intellij.execution.*;
import com.intellij.execution.configurations.*;
import com.intellij.execution.process.ProcessHandler;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.history.LocalHistory;
-import com.intellij.history.LocalHistoryConfiguration;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.DataKey;
import com.intellij.openapi.application.ApplicationManager;
if (callback != null) callback.processStarted(descriptor);
if (descriptor != null) {
- if (LocalHistoryConfiguration.getInstance().ADD_LABEL_ON_RUNNING) {
- LocalHistory.putSystemLabel(project, executor.getId() + " " + profile.getName());
- }
+ LocalHistory.getInstance().putSystemLabel(project, getLocalHistoryLabel(profile, state));
ExecutionManager.getInstance(project).getContentManager().showRunContent(executor, descriptor);
final ProcessHandler processHandler = descriptor.getProcessHandler();
protected abstract RunContentDescriptor doExecute(final Project project, final Executor executor, final RunProfileState state,
final RunContentDescriptor contentToReuse,
final ExecutionEnvironment env) throws ExecutionException;
+
+ protected String getLocalHistoryLabel(RunProfile profile, RunProfileState state) {
+ return ExecutionBundle.message("default.runner.start.action.label", profile.getName());
+ }
}
+++ /dev/null
-/*
- * 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.execution.ui;
-
-import com.intellij.execution.filters.Filter;
-import com.intellij.execution.filters.HyperlinkInfo;
-import com.intellij.execution.process.ProcessHandler;
-import com.intellij.openapi.actionSystem.AnAction;
-import org.jetbrains.annotations.NotNull;
-
-import javax.swing.*;
-
-/**
- * @author Gregory.Shrago
- */
-public class ConsoleViewWrapper implements ConsoleView, ExecutionConsoleEx {
- private final ConsoleView myDelegate;
-
- public ConsoleViewWrapper(final ConsoleView delegate) {
- myDelegate = delegate;
- }
-
- public ConsoleView getDelegate() {
- return myDelegate;
- }
-
- public void dispose() {
- myDelegate.dispose();
- }
-
- public JComponent getComponent() {
- return myDelegate.getComponent();
- }
-
- public JComponent getPreferredFocusableComponent() {
- return myDelegate.getPreferredFocusableComponent();
- }
-
- public void print(String s, ConsoleViewContentType contentType) {
- myDelegate.print(s, contentType);
- }
-
- public void clear() {
- myDelegate.clear();
- }
-
- public void scrollTo(int offset) {
- myDelegate.scrollTo(offset);
- }
-
- public void attachToProcess(ProcessHandler processHandler) {
- myDelegate.attachToProcess(processHandler);
- }
-
- public void setOutputPaused(boolean value) {
- myDelegate.setOutputPaused(value);
- }
-
- public boolean isOutputPaused() {
- return myDelegate.isOutputPaused();
- }
-
- public boolean hasDeferredOutput() {
- return myDelegate.hasDeferredOutput();
- }
-
- public void performWhenNoDeferredOutput(Runnable runnable) {
- myDelegate.performWhenNoDeferredOutput(runnable);
- }
-
- public void setHelpId(String helpId) {
- myDelegate.setHelpId(helpId);
- }
-
- public void addMessageFilter(Filter filter) {
- myDelegate.addMessageFilter(filter);
- }
-
- public void printHyperlink(String hyperlinkText, HyperlinkInfo info) {
- myDelegate.printHyperlink(hyperlinkText, info);
- }
-
- public int getContentSize() {
- return myDelegate.getContentSize();
- }
-
- public boolean canPause() {
- return myDelegate.canPause();
- }
-
- public void buildUi(RunnerLayoutUi layoutUi) {
- if (myDelegate instanceof ExecutionConsoleEx) {
- ((ExecutionConsoleEx)myDelegate).buildUi(layoutUi);
- }
- }
-
-
- public String getExecutionConsoleId() {
- if (myDelegate instanceof ExecutionConsoleEx) {
- return ((ExecutionConsoleEx)myDelegate).getExecutionConsoleId();
- }
- return null;
- }
-
- @NotNull
- public AnAction[] createConsoleActions() {
- return myDelegate.createConsoleActions();
- }
-
-}
protected void run(Result result) throws Throwable {
LocalHistoryAction action = LocalHistoryAction.NULL;
try {
- action = LocalHistory.startAction(myProject, commandName);
+ action = LocalHistory.getInstance().startAction(commandName);
PsiElement[] psiElements = create(inputString);
myCreatedElements[0] = new SmartPsiElementPointer[psiElements.length];
return null;
}
+ public void onFrameworkSelectionChanged(boolean selected) {
+ }
+
public void addListener(@NotNull FrameworkSupportConfigurableListener listener) {
myDispatcher.addListener(listener);
}
public boolean isCollapsedByDefault(@NotNull ASTNode node) {
final FoldingBuilder builder = node.getUserData(FOLDING_BUILDER);
- return builder == null ? false : builder.isCollapsedByDefault(node);
+ return builder != null && builder.isCollapsedByDefault(node);
}
}
import com.intellij.lang.ASTNode;
import com.intellij.lang.Language;
-import com.intellij.lang.injection.InjectedLanguageManager;
import com.intellij.openapi.editor.FoldingGroup;
import com.intellij.openapi.util.ProperTextRange;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
import com.intellij.util.ObjectUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
* Returns the folded text range.
* @return the folded text range.
*/
+ @NotNull
public TextRange getRange() {
- return getRange(myElement, myRange);
- }
-
- public static TextRange getRange(ASTNode node, TextRange range) {
- PsiElement element = node.getPsi();
- PsiFile containingFile = element.getContainingFile();
- InjectedLanguageManager injectedManager = InjectedLanguageManager.getInstance(containingFile.getProject());
- boolean isInjected = injectedManager.isInjectedFragment(containingFile);
- if (isInjected) {
- range = injectedManager.injectedToHost(element, range);
- }
- return range;
+ return myRange;
}
@Nullable
}
@Nullable
- public static LibraryOrderEntry findLibraryEntry(VirtualFile file, final Project project) {
+ public static OrderEntry findLibraryEntry(VirtualFile file, final Project project) {
List<OrderEntry> entries = ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(file);
for (OrderEntry entry : entries) {
- if (entry instanceof LibraryOrderEntry) {
- return (LibraryOrderEntry)entry;
+ if (entry instanceof LibraryOrderEntry || entry instanceof JdkOrderEntry) {
+ return entry;
}
}
return null;
public boolean SPECIAL_ELSE_IF_TREATMENT = true;
+ /**
+ * Indicates if long sequence of chained method calls should be aligned.
+ * <p/>
+ * E.g. if statement like <code>'foo.bar().bar().bar();'</code> should be reformatted to the one below if,
+ * say, last <code>'bar()'</code> call exceeds right margin. The code looks as follows after reformatting
+ * if this property is <code>true</code>:
+ * <p/>
+ * <pre>
+ * foo.bar().bar()
+ * .bar();
+ * </pre>
+ */
+ public boolean ALIGN_MULTILINE_CHAINED_METHODS = false;
public boolean ALIGN_MULTILINE_PARAMETERS = true;
public boolean ALIGN_MULTILINE_PARAMETERS_IN_CALLS = false;
public boolean ALIGN_MULTILINE_FOR = true;
}
ApplicationManager.getApplication().runWriteAction(new Runnable() {
public void run() {
+ ApplicationManager.getApplication().getMessageBus().syncPublisher(VirtualFileManager.VFS_CHANGES)
+ .before(new ArrayList<VFileEvent>(list));
ApplicationManager.getApplication().getMessageBus().syncPublisher(VirtualFileManager.VFS_CHANGES)
.after(new ArrayList<VFileEvent>(list));
}
import com.intellij.openapi.application.ApplicationBundle;
import com.intellij.psi.PsiFile;
import com.intellij.psi.codeStyle.CodeStyleSettings;
-import com.intellij.ui.IdeBorderFactory;
import com.intellij.ui.OptionGroup;
import javax.swing.*;
private JComboBox myWhileForceCombo;
private JComboBox myDoWhileForceCombo;
+ private JCheckBox myAlignChainedMethods;
private JCheckBox myAlignDeclarationParameters;
private JCheckBox myAlignCallParameters;
private JCheckBox myAlignExtendsList;
public CodeStyleIndentAndBracesPanel(CodeStyleSettings settings) {
super(settings);
- myPanel.add(createKeepWhenReformatingPanel(),
+ myPanel.add(createKeepWhenReformattingPanel(),
new GridBagConstraints(0, 0, 1, 1, 0, 0, GridBagConstraints.NORTH, GridBagConstraints.HORIZONTAL,
new Insets(0, 4, 0, 4), 0, 0));
return LanguageCodeStyleSettingsProvider.SettingsType.INDENT_AND_BRACES_SETTINGS;
}
- private Component createKeepWhenReformatingPanel() {
+ private Component createKeepWhenReformattingPanel() {
OptionGroup optionGroup = new OptionGroup(ApplicationBundle.message("title.keep.when.reformatting"));
myKeepLineBreaks = createCheckBox(ApplicationBundle.message("checkbox.keep.when.reformatting.line.breaks"));
private JPanel createAlignmentsPanel() {
OptionGroup optionGroup = new OptionGroup(ApplicationBundle.message("title.align.when.multiline"));
+ myAlignChainedMethods = createCheckBox(ApplicationBundle.message("checkbox.align.multiline.chained.methods"));
+ optionGroup.add(myAlignChainedMethods);
+
myAlignDeclarationParameters = createCheckBox(ApplicationBundle.message("checkbox.align.multiline.method.parameters"));
optionGroup.add(myAlignDeclarationParameters);
isModified |= settings.CLASS_BRACE_STYLE != getBraceComboValue(myClassDeclarationCombo);
isModified |= settings.METHOD_BRACE_STYLE != getBraceComboValue(myMethodDeclarationCombo);
+ isModified |= isModified(myAlignChainedMethods, settings.ALIGN_MULTILINE_CHAINED_METHODS);
isModified |= isModified(myAlignAssignment, settings.ALIGN_MULTILINE_ASSIGNMENT);
isModified |= isModified(myAlignBinaryExpression, settings.ALIGN_MULTILINE_BINARY_OPERATION);
isModified |= isModified(myAlignCallParameters, settings.ALIGN_MULTILINE_PARAMETERS_IN_CALLS);
myAlignAssignment.setSelected(settings.ALIGN_MULTILINE_ASSIGNMENT);
myAlignBinaryExpression.setSelected(settings.ALIGN_MULTILINE_BINARY_OPERATION);
myAlignCallParameters.setSelected(settings.ALIGN_MULTILINE_PARAMETERS_IN_CALLS);
+ myAlignChainedMethods.setSelected(settings.ALIGN_MULTILINE_CHAINED_METHODS);
myAlignDeclarationParameters.setSelected(settings.ALIGN_MULTILINE_PARAMETERS);
myAlignExtendsList.setSelected(settings.ALIGN_MULTILINE_EXTENDS_LIST);
myAlignForStatement.setSelected(settings.ALIGN_MULTILINE_FOR);
settings.ALIGN_MULTILINE_ASSIGNMENT = myAlignAssignment.isSelected();
settings.ALIGN_MULTILINE_BINARY_OPERATION = myAlignBinaryExpression.isSelected();
settings.ALIGN_MULTILINE_PARAMETERS_IN_CALLS = myAlignCallParameters.isSelected();
+ settings.ALIGN_MULTILINE_CHAINED_METHODS = myAlignChainedMethods.isSelected();
settings.ALIGN_MULTILINE_PARAMETERS = myAlignDeclarationParameters.isSelected();
settings.ALIGN_MULTILINE_EXTENDS_LIST = myAlignExtendsList.isSelected();
settings.ALIGN_MULTILINE_FOR = myAlignForStatement.isSelected();
}
public void doCollectInformation(ProgressIndicator progress) {
- final boolean firstTime = myFile.getUserData(THE_FIRST_TIME) == null || myEditor.getUserData(THE_FIRST_TIME) == null;
+ final boolean firstTime = isFirstTime(myFile, myEditor, THE_FIRST_TIME);
Runnable runnable = CodeFoldingManager.getInstance(myProject).updateFoldRegionsAsync(myEditor, firstTime);
synchronized (this) {
myRunnable = runnable;
}
}
+ static boolean isFirstTime(PsiFile file, Editor editor, Key<Boolean> key) {
+ return file.getUserData(key) == null || editor.getUserData(key) == null;
+ }
+
+ static void clearFirstTimeFlag(PsiFile file, Editor editor, Key<Boolean> key) {
+ file.putUserData(key, Boolean.FALSE);
+ editor.putUserData(key, Boolean.FALSE);
+ }
+
public void doApplyInformationToEditor() {
Runnable runnable;
synchronized (this) {
try {
runnable.run();
}
- catch (IndexNotReadyException e) {
+ catch (IndexNotReadyException ignored) {
}
}
if (InjectedLanguageUtil.getTopLevelFile(myFile) == myFile) {
- myFile.putUserData(THE_FIRST_TIME, Boolean.FALSE);
- myEditor.putUserData(THE_FIRST_TIME, Boolean.FALSE);
+ clearFirstTimeFlag(myFile, myEditor, THE_FIRST_TIME);
}
}
}
import com.intellij.openapi.project.DumbAware;
import com.intellij.openapi.project.IndexNotReadyException;
import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Key;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
class InjectedCodeFoldingPass extends TextEditorHighlightingPass implements DumbAware {
+ private static final Key<Boolean> THE_FIRST_TIME_KEY = Key.create("FirstInjectedFoldingPass");
private Runnable myRunnable;
private final Editor myEditor;
private final PsiFile myFile;
}
public void doCollectInformation(ProgressIndicator progress) {
- Runnable runnable = FoldingUpdate.updateInjectedFoldRegions(myEditor, myFile);
+ boolean firstTime = CodeFoldingPass.isFirstTime(myFile, myEditor, THE_FIRST_TIME_KEY);
+ Runnable runnable = FoldingUpdate.updateInjectedFoldRegions(myEditor, myFile, firstTime);
synchronized (this) {
myRunnable = runnable;
}
try {
runnable.run();
}
- catch (IndexNotReadyException e) {
+ catch (IndexNotReadyException ignored) {
}
+ CodeFoldingPass.clearFirstTimeFlag(myFile, myEditor, THE_FIRST_TIME_KEY);
}
}
}
\ No newline at end of file
import com.intellij.openapi.actionSystem.ex.AnActionListener;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.IndexNotReadyException;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.LibraryOrderEntry;
+import com.intellij.openapi.roots.OrderEntry;
import com.intellij.openapi.roots.libraries.LibraryUtil;
import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
import com.intellij.openapi.ui.popup.JBPopup;
import java.util.Set;
public class DocumentationManager {
+ private static final Logger LOG = Logger.getInstance("#" + DocumentationManager.class.getName());
private static final String SHOW_DOCUMENTATION_IN_TOOL_WINDOW = "ShowDocumentationInToolWindow";
private static final String DOCUMENTATION_AUTO_UPDATE_ENABLED = "DocumentationAutoUpdateEnabled";
@NonNls public static final String JAVADOC_LOCATION_AND_SIZE = "javadoc.popup";
text = provider.getDocumentation();
}
catch (Throwable e) {
+ LOG.info(e);
ex[0] = e;
}
final PsiFile containingFile = psiElement.getContainingFile();
if (containingFile != null) {
final VirtualFile virtualFile = containingFile.getVirtualFile();
- final LibraryOrderEntry libraryEntry = LibraryUtil.findLibraryEntry(virtualFile, myProject);
+ final OrderEntry libraryEntry = LibraryUtil.findLibraryEntry(virtualFile, myProject);
if (libraryEntry != null) {
ProjectSettingsService.getInstance(myProject).openProjectLibrarySettings(new NamedLibraryElement(libraryEntry.getOwnerModule(), libraryEntry));
}
final FoldRegion[] regions = editor.getFoldingModel().getAllFoldRegions();
editor.getFoldingModel().runBatchFoldingOperation(new Runnable() {
public void run() {
+ EditorFoldingInfo foldingInfo = EditorFoldingInfo.get(editor);
for (FoldRegion region : regions) {
- PsiElement element = EditorFoldingInfo.get(editor).getPsiElement(region);
+ PsiElement element = foldingInfo.getPsiElement(region);
if (element != null) {
region.setExpanded(!FoldingPolicy.isCollapseByDefault(element));
}
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.FoldRegion;
import com.intellij.openapi.editor.RangeMarker;
-import com.intellij.openapi.editor.impl.FoldRegionImpl;
+import com.intellij.openapi.editor.ex.FoldingModelEx;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.impl.text.CodeFoldingState;
import com.intellij.openapi.project.Project;
FoldRegion region = FoldingUtil.findFoldRegion(editor, marker.getStartOffset(), marker.getEndOffset());
if (region == null) {
String placeHolderText = myPlaceholderTexts.get(marker);
- region = new FoldRegionImpl(editor, marker.getStartOffset(), marker.getEndOffset(), placeHolderText, null); //may fail to add in case intersecting region exists
+ region = ((FoldingModelEx)editor.getFoldingModel()).createFoldRegion(marker.getStartOffset(), marker.getEndOffset(), placeHolderText, null);
+ //may fail to add in case intersecting region exists
if (!editor.getFoldingModel().addFoldRegion(region)) return;
}
package com.intellij.codeInsight.folding.impl;
import com.intellij.injected.editor.DocumentWindow;
+import com.intellij.injected.editor.EditorWindow;
import com.intellij.lang.Language;
import com.intellij.lang.folding.FoldingBuilder;
import com.intellij.lang.folding.FoldingDescriptor;
final TreeMap<PsiElement, FoldingDescriptor> elementsToFoldMap = new TreeMap<PsiElement, FoldingDescriptor>(COMPARE_BY_OFFSET);
getFoldingsFor(file instanceof PsiCompiledElement ? (PsiFile)((PsiCompiledElement)file).getMirror() : file, document, elementsToFoldMap, quick);
- final UpdateFoldRegionsOperation operation =
- new UpdateFoldRegionsOperation(project, editor, elementsToFoldMap, applyDefaultState, false);
+ final UpdateFoldRegionsOperation operation = new UpdateFoldRegionsOperation(project, editor, elementsToFoldMap, applyDefaultState, false);
Runnable runnable = new Runnable() {
public void run() {
editor.getFoldingModel().runBatchFoldingOperationDoNotCollapseCaret(operation);
private static final Key<Object> LAST_UPDATE_INJECTED_STAMP_KEY = Key.create("LAST_UPDATE_INJECTED_STAMP_KEY");
@Nullable
- public static Runnable updateInjectedFoldRegions(@NotNull final Editor editor, @NotNull PsiFile file) {
+ public static Runnable updateInjectedFoldRegions(@NotNull final Editor editor, @NotNull PsiFile file, final boolean applyDefaultState) {
if (file instanceof PsiCompiledElement) return null;
ApplicationManager.getApplication().assertReadAccessAllowed();
Object lastTimeStamp = editor.getUserData(LAST_UPDATE_INJECTED_STAMP_KEY);
if (lastTimeStamp instanceof Long && ((Long)lastTimeStamp).longValue() == timeStamp) return null;
- final TreeMap<PsiElement, FoldingDescriptor> elementsToFoldMap = new TreeMap<PsiElement, FoldingDescriptor>(COMPARE_BY_OFFSET);
-
List<DocumentWindow> injectedDocuments = InjectedLanguageUtil.getCachedInjectedDocuments(file);
if (injectedDocuments.isEmpty()) return null;
+ final List<EditorWindow> injectedEditors = new ArrayList<EditorWindow>();
+ final List<Map<PsiElement, FoldingDescriptor>> maps = new ArrayList<Map<PsiElement, FoldingDescriptor>>();
for (DocumentWindow injectedDocument : injectedDocuments) {
- PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(injectedDocument);
- if (psiFile == null || !psiFile.isValid() || !injectedDocument.isValid()) continue;
- getFoldingsFor(psiFile, injectedDocument, elementsToFoldMap, false);
+ PsiFile injectedFile = PsiDocumentManager.getInstance(project).getPsiFile(injectedDocument);
+ if (injectedFile == null || !injectedFile.isValid() || !injectedDocument.isValid()) continue;
+ Editor injectedEditor = InjectedLanguageUtil.getInjectedEditorForInjectedFile(editor, injectedFile);
+ if (!(injectedEditor instanceof EditorWindow)) continue;
+
+ injectedEditors.add((EditorWindow)injectedEditor);
+ Map<PsiElement, FoldingDescriptor> map = new TreeMap<PsiElement, FoldingDescriptor>(COMPARE_BY_OFFSET);
+ maps.add(map);
+ getFoldingsFor(injectedFile, injectedDocument, map, false);
}
- final Runnable operation = new UpdateFoldRegionsOperation(project, editor, elementsToFoldMap, false, true);
+
+ final Runnable operation = new Runnable() {
+ public void run() {
+ for (int i = 0; i < injectedEditors.size(); i++) {
+ EditorWindow injectedEditor = injectedEditors.get(i);
+ Map<PsiElement, FoldingDescriptor> map = maps.get(i);
+ new UpdateFoldRegionsOperation(project, injectedEditor, map, applyDefaultState, true).run();
+ }
+ }
+ };
return new Runnable() {
public void run() {
editor.getFoldingModel().runBatchFoldingOperationDoNotCollapseCaret(operation);
};
}
- private static void getFoldingsFor(PsiFile file, Document document,
TreeMap<PsiElement, FoldingDescriptor> elementsToFoldMap, boolean quick) {
+ private static void getFoldingsFor(PsiFile file, Document document, Map<PsiElement, FoldingDescriptor> elementsToFoldMap, boolean quick) {
final FileViewProvider viewProvider = file.getViewProvider();
for (final Language language : viewProvider.getLanguages()) {
final PsiFile psi = viewProvider.getPsi(language);
projects / idea / community.git / commitdiff