From e0e888283dd057d99b9d04959bbd2e5c2d9692f3 Mon Sep 17 00:00:00 2001 From: Mihail Buryakov Date: Wed, 3 Feb 2016 18:37:00 +0300 Subject: [PATCH 1/5] MPS-23292: find all usages at once --- .../models/jetbrains/mps/ide/migration.mps | 424 +++-- .../jetbrains/mps/ide/migration/dependencies | 3 + .../jetbrains/mps/ide/migration/generated | 2 +- .../mps/ide/migration/MigrationComponent.java | 73 +- .../jetbrains/mps/ide/migration/trace.info | 667 ++++---- .../lang/migration/pluginSolution/plugin.mps | 1259 +++++++++----- .../pluginSolution/plugin/dependencies | 7 +- .../migration/pluginSolution/plugin/generated | 2 +- .../plugin/UpdateReferencesParticipant.java | 139 +- .../pluginSolution/plugin/trace.info | 377 +++-- .../lang/structure/pluginSolution/plugin.mps | 356 ++-- .../pluginSolution/plugin/dependencies | 1 - .../structure/pluginSolution/plugin/generated | 2 +- .../plugin/MoveAspectsParticipant.java | 55 +- .../pluginSolution/plugin/trace.info | 272 +-- .../mps/ide/platform/actions/core.mps | 1501 ++++++++++------- .../ide/platform/actions/core/dependencies | 7 +- .../mps/ide/platform/actions/core/generated | 2 +- .../actions/core/MoveNodesDefault.java | 70 +- .../actions/core/RecursiveParticipant.java | 16 +- .../actions/core/RefactoringParticipant.java | 56 +- .../core/RefactoringParticipantBase.java | 47 +- .../mps/ide/platform/actions/core/trace.info | 1198 ++++++------- 23 files changed, 3966 insertions(+), 2570 deletions(-) diff --git a/plugins/migrationAssistant/solutions/component/models/jetbrains/mps/ide/migration.mps b/plugins/migrationAssistant/solutions/component/models/jetbrains/mps/ide/migration.mps index 17e5c4f8db20..c71a19d8623e 100644 --- a/plugins/migrationAssistant/solutions/component/models/jetbrains/mps/ide/migration.mps +++ b/plugins/migrationAssistant/solutions/component/models/jetbrains/mps/ide/migration.mps @@ -65,7 +65,7 @@ - + @@ -195,6 +195,7 @@ + @@ -461,12 +462,25 @@ + + + + + + + + + + + + + @@ -6088,45 +6102,89 @@ - + - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6145,7 +6203,7 @@ - + @@ -6241,57 +6299,42 @@ - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - + + - + - - + + - + - + - + - - + + @@ -6299,6 +6342,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6315,12 +6414,16 @@ - - + + + + - - + + + + @@ -6655,118 +6758,163 @@ - - - - - - - - + + + - - - - - - - + + + + + + + - - + + - + - + - - - - - + + + + + - + - - + + - - - - - - - + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + - - - - - - + + + + + + + + + - - - + + + + + + + + - - + + + + + + + + + + + - - + + - + - - + + - + - - + + - - + + - - + + - - - - + + + + - + @@ -6778,10 +6926,10 @@ - - + + - + diff --git a/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/dependencies b/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/dependencies index 7a282e380660..0771a4945f0c 100644 --- a/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/dependencies +++ b/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/dependencies @@ -57,11 +57,13 @@ + + @@ -73,6 +75,7 @@ + diff --git a/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/generated b/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/generated index 2760033776e8..d719b31b51dd 100644 --- a/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/generated +++ b/plugins/migrationAssistant/solutions/component/source_gen.caches/jetbrains/mps/ide/migration/generated @@ -1,3 +1,3 @@ - + diff --git a/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/MigrationComponent.java b/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/MigrationComponent.java index 2993bf5481e0..8f129278f8a7 100644 --- a/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/MigrationComponent.java +++ b/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/MigrationComponent.java @@ -29,15 +29,16 @@ import jetbrains.mps.lang.migration.runtime.base.MigrationScript; import org.jetbrains.mps.openapi.language.SLanguage; import jetbrains.mps.ide.platform.actions.core.RefactoringParticipant; +import java.util.List; import org.jetbrains.mps.openapi.module.SRepository; import org.jetbrains.mps.openapi.module.SearchScope; import jetbrains.mps.ide.platform.actions.core.RefactoringSession; -import java.util.List; import jetbrains.mps.internal.collections.runtime.ListSequence; -import jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations; import jetbrains.mps.internal.collections.runtime.ISelector; +import jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations; import jetbrains.mps.lang.smodel.generator.smodelAdapter.SPropertyOperations; import jetbrains.mps.progress.EmptyProgressMonitor; +import java.util.Iterator; import jetbrains.mps.lang.migration.runtime.base.RefactoringLog; import jetbrains.mps.lang.migration.runtime.base.RefactoringLogReference; import org.jetbrains.mps.openapi.model.SModel; @@ -47,6 +48,7 @@ import jetbrains.mps.smodel.structure.ExtensionPoint; import jetbrains.mps.internal.collections.runtime.ITranslator2; import jetbrains.mps.lang.migration.runtime.base.RefactoringStepImpl; +import jetbrains.mps.internal.collections.runtime.IMapping; import jetbrains.mps.lang.migration.runtime.base.RefactoringPart; import jetbrains.mps.ide.platform.actions.core.RefactoringSessionImpl; import jetbrains.mps.ide.findusages.model.scopes.ModulesScope; @@ -157,10 +159,18 @@ public MigrationScript fetchMigrationScript(MigrationScriptReference scriptRefer return script; } - public static void executeRefactoringLog(RefactoringParticipant.PersistentRefactoringParticipant participant, SNode initialStateSerialized, SNode finalStateSerialized, SNode selectedOptionsSerialized, final SRepository repository, SearchScope searchScope, final RefactoringSession session) { - I initialState = participant.deserializeInitialState(initialStateSerialized); - final F finalState = participant.deserializeFinalState(finalStateSerialized); - List availableOptions = participant.getAvailableOptions(initialState, repository); + public static void doRefactor(final RefactoringParticipant.PersistentRefactoringParticipant participant, List initialStatesSerialized, List finalStatesSerialized, SNode selectedOptionsSerialized, final SRepository repository, SearchScope searchScope, final RefactoringSession session) { + List initialStates = ListSequence.fromList(initialStatesSerialized).select(new ISelector() { + public I select(SNode it) { + return participant.deserializeInitialState(it); + } + }).toListSequence(); + List finalStates = ListSequence.fromList(finalStatesSerialized).select(new ISelector() { + public F select(SNode it) { + return participant.deserializeFinalState(it); + } + }).toListSequence(); + List availableOptions = participant.getAvailableOptions(initialStates, repository); List selectedOptions; if (selectedOptionsSerialized == null) { selectedOptions = availableOptions; @@ -171,11 +181,22 @@ public RefactoringParticipant.Option select(SNode it) { } }).toListSequence(); } - ListSequence.fromList(participant.getChanges(initialState, repository, selectedOptions, searchScope, new EmptyProgressMonitor())).visitAll(new IVisitor>() { - public void visit(RefactoringParticipant.Change it) { - it.confirm(finalState, repository, session); + List>> nodesChanges = participant.getChanges(initialStates, repository, selectedOptions, searchScope, new EmptyProgressMonitor()); + { + Iterator>> changes_it = ListSequence.fromList(nodesChanges).iterator(); + Iterator finalState_it = ListSequence.fromList(finalStates).iterator(); + List> changes_var; + final Wrappers._T finalState_var = new Wrappers._T(); + while (changes_it.hasNext() && finalState_it.hasNext()) { + changes_var = changes_it.next(); + finalState_var.value = finalState_it.next(); + ListSequence.fromList(changes_var).visitAll(new IVisitor>() { + public void visit(RefactoringParticipant.Change it) { + it.confirm(finalState_var.value, repository, session); + } + }); } - }); + } } public RefactoringLog fetchRefactoringLog(RefactoringLogReference scriptReference, boolean silently) { @@ -193,7 +214,7 @@ public boolean accept(SNode it) { } return null; } - final Map> participants = MapSequence.fromMap(new HashMap>()); + Map> participants = MapSequence.fromMap(new HashMap>()); for (RefactoringParticipant.PersistentRefactoringParticipant participant : Sequence.fromIterable(new ExtensionPoint>>("jetbrains.mps.ide.platform.PersistentRefactoringParticipantsEP").getObjects()).translate(new ITranslator2>, RefactoringParticipant.PersistentRefactoringParticipant>() { public Iterable> translate(Iterable> it) { return it; @@ -213,12 +234,33 @@ public SNode select(SNode it) { public RefactoringLogReference select(SNode it) { return ((RefactoringLogReference) (RefactoringLogReference) BHReflection.invoke(it, SMethodTrimmedId.create("getDescriptor", MetaAdapterFactory.getConcept(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x1bf9eb43276b6d8fL, "jetbrains.mps.lang.migration.structure.RefactoringLog"), "4uVwhQyPQ_Z"))); } - }), ListSequence.fromList(SLinkOperations.getChildren(log, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x1bf9eb43276b6d8fL, 0x1bf9eb43276b6d92L, "part"))).select(new ISelector() { - public RefactoringPart select(final SNode refactoringPartNode) { + }), MapSequence.fromMap(participants).select(new ISelector>, RefactoringPart>() { + public RefactoringPart select(final IMapping> participant) { return new RefactoringPart() { public void execute(SModule module) { RefactoringSessionImpl session = new RefactoringSessionImpl(); - executeRefactoringLog(MapSequence.fromMap(participants).get(SPropertyOperations.getString(refactoringPartNode, MetaAdapterFactory.getProperty(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3aaL, "participant"))), SLinkOperations.getTarget(refactoringPartNode, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3acL, "initialState")), SLinkOperations.getTarget(refactoringPartNode, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3aeL, "finalState")), SLinkOperations.getTarget(log, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x1bf9eb43276b6d8fL, 0x31ee543051f2333cL, "options")), myMpsProject.getRepository(), new ModulesScope(module), session); + List participantParts = ListSequence.fromList(SLinkOperations.getChildren(log, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x1bf9eb43276b6d8fL, 0x1bf9eb43276b6d92L, "part"))).where(new IWhereFilter() { + public boolean accept(SNode it) { + return eq_gd1mrb_a0a0a0a0a0a0b0a0a0a0a0a0a3a0a7a22(SPropertyOperations.getString(it, MetaAdapterFactory.getProperty(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3aaL, "participant")), participant.key()); + } + }).toListSequence(); + doRefactor(participant.value(), ListSequence.fromList(participantParts).where(new IWhereFilter() { + public boolean accept(SNode it) { + return (SLinkOperations.getTarget(it, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3acL, "initialState")) != null); + } + }).select(new ISelector() { + public SNode select(SNode it) { + return SLinkOperations.getTarget(it, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3acL, "initialState")); + } + }).toListSequence(), ListSequence.fromList(participantParts).where(new IWhereFilter() { + public boolean accept(SNode it) { + return (SLinkOperations.getTarget(it, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3aeL, "finalState")) != null); + } + }).select(new ISelector() { + public SNode select(SNode it) { + return SLinkOperations.getTarget(it, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x2b3f57492c163158L, 0x325b97b223b9e3aeL, "finalState")); + } + }).toListSequence(), SLinkOperations.getTarget(log, MetaAdapterFactory.getContainmentLink(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x1bf9eb43276b6d8fL, 0x31ee543051f2333cL, "options")), myMpsProject.getRepository(), new ModulesScope(module), session); session.commit(); } }; @@ -299,4 +341,7 @@ private static MigrationScript check_gd1mrb_a0e0s(MigrationDescriptor checkedDot } return null; } + private static boolean eq_gd1mrb_a0a0a0a0a0a0b0a0a0a0a0a0a3a0a7a22(Object a, Object b) { + return (a != null ? a.equals(b) : a == b); + } } diff --git a/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/trace.info b/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/trace.info index 0efc5b4e73e0..e23f2b87b242 100644 --- a/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/trace.info +++ b/plugins/migrationAssistant/solutions/component/source_gen/jetbrains/mps/ide/migration/trace.info @@ -467,361 +467,429 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - - - + + + + + + + + + + - - + + - + - - + + - + - + - + - - + + + + + + + + - - - + + + + + + + + + + + + + - + - + - - - - - + + + + + - - + + - - - - - - - - + + + + + - + - - + + - + - - + + + - - - - - - - + + + - - - + + + - - - + + + + + + + + + - + - + - + - - - - - - - + - - - - - - - - - - + - + - + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + - + @@ -829,27 +897,34 @@ - + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/models/jetbrains/mps/lang/migration/pluginSolution/plugin.mps b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/models/jetbrains/mps/lang/migration/pluginSolution/plugin.mps index fe3f42ab82a7..e17e369f1691 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/models/jetbrains/mps/lang/migration/pluginSolution/plugin.mps +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/models/jetbrains/mps/lang/migration/pluginSolution/plugin.mps @@ -43,6 +43,7 @@ + @@ -252,6 +253,7 @@ + @@ -442,9 +444,6 @@ - - - @@ -466,6 +465,9 @@ + + + @@ -6117,9 +6119,11 @@ - - - + + + + + @@ -6143,14 +6147,22 @@ + + + + + + - - - - - - - + + + + + + + + + @@ -6159,18 +6171,51 @@ - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6187,539 +6232,837 @@ - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + - - - - - - - - + + + + - - - - - + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - + + + + - - - + + + + + + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + - - + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + - - - - - - - - - - - - - - - - + + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/dependencies b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/dependencies index 4d271125f0a3..3eecfcf4e2b2 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/dependencies +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/dependencies @@ -282,13 +282,16 @@ - + + + + @@ -319,8 +322,10 @@ + + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/generated b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/generated index a3b3f6aa464b..0427d09dfd2f 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/generated +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen.caches/jetbrains/mps/lang/migration/pluginSolution/plugin/generated @@ -1,3 +1,3 @@ - + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/UpdateReferencesParticipant.java b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/UpdateReferencesParticipant.java index 6879cbf00251..27ad8bce0107 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/UpdateReferencesParticipant.java +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/UpdateReferencesParticipant.java @@ -16,23 +16,29 @@ import jetbrains.mps.internal.collections.runtime.ListSequence; import java.util.ArrayList; import org.jetbrains.mps.openapi.module.SearchScope; -import jetbrains.mps.lang.smodel.query.runtime.CommandUtil; -import jetbrains.mps.lang.smodel.query.runtime.QueryExecutionContext; +import org.jetbrains.mps.openapi.util.ProgressMonitor; +import jetbrains.mps.internal.collections.runtime.ISelector; +import java.util.Collections; import java.util.Collection; import org.jetbrains.mps.openapi.model.SReference; -import jetbrains.mps.internal.collections.runtime.Sequence; +import jetbrains.mps.lang.smodel.query.runtime.CommandUtil; +import jetbrains.mps.lang.smodel.query.runtime.QueryExecutionContext; import jetbrains.mps.internal.collections.runtime.IWhereFilter; +import java.util.Set; +import org.jetbrains.mps.openapi.module.FindUsagesFacade; +import jetbrains.mps.internal.collections.runtime.SetSequence; +import java.util.HashSet; +import jetbrains.mps.internal.collections.runtime.Sequence; import jetbrains.mps.internal.collections.runtime.CollectionSequence; -import jetbrains.mps.internal.collections.runtime.ISelector; +import java.util.Map; +import jetbrains.mps.internal.collections.runtime.MapSequence; +import java.util.HashMap; import org.jetbrains.mps.openapi.language.SReferenceLink; import jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations; import jetbrains.mps.ide.findusages.model.SearchResults; -import jetbrains.mps.internal.collections.runtime.SetSequence; -import java.util.HashSet; import jetbrains.mps.ide.findusages.model.SearchResult; import jetbrains.mps.ide.platform.actions.core.RefactoringSession; import jetbrains.mps.ide.platform.actions.core.MoveNodesDefault; -import jetbrains.mps.internal.collections.runtime.MapSequence; import jetbrains.mps.lang.migration.behavior.AbstractNodeReference__BehaviorDescriptor; import jetbrains.mps.lang.smodel.generator.smodelAdapter.SPropertyOperations; import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory; @@ -89,10 +95,20 @@ public List getAvailableOptions(NamedNodeReferenc return ListSequence.fromListAndArray(new ArrayList(), OPTION); } - public List> getChanges(final NamedNodeReference initialState, SRepository repository, final List selectedOptions, SearchScope searchScope) { + public List>> getChanges(List initialStates, final SRepository repository, final List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { if (!(ListSequence.fromList(selectedOptions).contains(OPTION))) { - return ListSequence.fromList(new ArrayList>()); + return ListSequence.fromList(initialStates).select(new ISelector>>() { + public List> select(NamedNodeReference it) { + return (List>) Collections.>emptyList(); + } + }).toListSequence(); } + Collection usages; + List movedNodes = ListSequence.fromList(initialStates).select(new ISelector() { + public SNode select(NamedNodeReference it) { + return it.reference().resolve(repository); + } + }).toListSequence(); { final SearchScope scope = CommandUtil.createScope(searchScope); QueryExecutionContext context = new QueryExecutionContext() { @@ -100,53 +116,73 @@ public SearchScope getDefaultSearchScope() { return scope; } }; - final SNode movedNode = initialState.reference().resolve(repository); - Collection usages; - if (movedNode != null) { - usages = CommandUtil.usages(CommandUtil.createConsoleScope(null, false, context), movedNode); + if (ListSequence.fromList(movedNodes).all(new IWhereFilter() { + public boolean accept(SNode it) { + return it != null; + } + })) { + progressMonitor.start("References in current project", 1); + usages = (Set) FindUsagesFacade.getInstance().findUsages(searchScope, SetSequence.fromSetWithValues(new HashSet(), movedNodes), progressMonitor.subTask(1)); } else { - usages = Sequence.fromIterable(CommandUtil.references(CommandUtil.createConsoleScope(null, false, context))).where(new IWhereFilter() { - public boolean accept(SReference it) { - return eq_k8iioh_a0a0a0a0a0a0a0a4a1a21(it.getTargetNodeReference(), initialState.reference()); + progressMonitor.start("References in current project", Sequence.fromIterable(CommandUtil.references(CommandUtil.createConsoleScope(null, false, context))).count()); + usages = CollectionSequence.fromCollection(new ArrayList()); + for (SReference ref : Sequence.fromIterable(CommandUtil.references(CommandUtil.createConsoleScope(null, false, context)))) { + if (ListSequence.fromList(initialStates).select(new ISelector() { + public SNodeReference select(NamedNodeReference it) { + return it.reference(); + } + }).contains(ref.getTargetNodeReference())) { + CollectionSequence.fromCollection(usages).addElement(ref); } - }).toListSequence(); + progressMonitor.advance(1); + if (progressMonitor.isCanceled()) { + return null; + } + } } - return CollectionSequence.fromCollection(usages).select(new ISelector>() { - public RefactoringParticipant.Change select(SReference ref) { - final SNodeReference containingNode = ref.getSourceNode().getReference(); - final SReferenceLink role = ref.getLink(); - final String resolveInfo = SLinkOperations.getResolveInfo(ref); - final SearchResults searchResults = new SearchResults(SetSequence.fromSetAndArray(new HashSet(), movedNode), ListSequence.fromListAndArray(new ArrayList>(), new SearchResult(ref.getSourceNode(), "reference"))); - RefactoringParticipant.Change change = new RefactoringParticipant.Change() { - public MoveNodeRefactoringParticipant getParticipant() { - return UpdateReferencesParticipant.this; - } - public SearchResults getSearchResults() { - return searchResults; - } - public boolean needsToPreserveOldNode() { - return false; - } - public void confirm(final NamedNodeReference finalState, final SRepository repository, final RefactoringSession refactoringSession) { - refactoringSession.registerChange(new Runnable() { - public void run() { - SNode node = containingNode.resolve(repository); - MoveNodesDefault.CopyMapObject copyMap = MoveNodesDefault.CopyMapObject.getCopyMap(refactoringSession); - if (node == null || (MapSequence.fromMap(copyMap.getCopyMap()).containsKey(node) && copyMap.whetherKeepNode(node))) { - return; - } - node.setReference(role, jetbrains.mps.smodel.SReference.create(role, node, finalState.reference().getModelReference(), finalState.reference().getNodeId(), resolveInfo)); - if (ListSequence.fromList(selectedOptions).contains(UpdateModelImports.OPTION)) { - UpdateModelImports.addModelImport(node.getModel(), finalState.reference().getModelReference().resolve(repository)); - } - } - }); + } + final Map>> result = MapSequence.fromMap(new HashMap>>()); + for (SReference ref : CollectionSequence.fromCollection(usages)) { + final SNodeReference containingNode = ref.getSourceNode().getReference(); + final SReferenceLink role = ref.getLink(); + final String resolveInfo = SLinkOperations.getResolveInfo(ref); + final SearchResults searchResults = new SearchResults(SetSequence.fromSetAndArray(new HashSet(), ref.getTargetNode()), ListSequence.fromListAndArray(new ArrayList>(), new SearchResult(ref.getSourceNode(), "reference"))); + RefactoringParticipant.Change change = new RefactoringParticipant.Change() { + public MoveNodeRefactoringParticipant getParticipant() { + return UpdateReferencesParticipant.this; + } + public SearchResults getSearchResults() { + return searchResults; + } + public boolean needsToPreserveOldNode() { + return false; + } + public void confirm(final NamedNodeReference finalState, final SRepository repository, final RefactoringSession refactoringSession) { + refactoringSession.registerChange(new Runnable() { + public void run() { + SNode node = containingNode.resolve(repository); + MoveNodesDefault.CopyMapObject copyMap = MoveNodesDefault.CopyMapObject.getCopyMap(refactoringSession); + if (node == null || (MapSequence.fromMap(copyMap.getCopyMap()).containsKey(node) && copyMap.whetherKeepNode(node))) { + return; + } + node.setReference(role, jetbrains.mps.smodel.SReference.create(role, node, finalState.reference().getModelReference(), finalState.reference().getNodeId(), resolveInfo)); + if (ListSequence.fromList(selectedOptions).contains(UpdateModelImports.OPTION)) { + UpdateModelImports.addModelImport(node.getModel(), finalState.reference().getModelReference().resolve(repository)); + } } - }; - return change; + }); } - }).toListSequence(); + }; + if (MapSequence.fromMap(result).get(ref.getTargetNodeReference()) == null) { + MapSequence.fromMap(result).put(ref.getTargetNodeReference(), ListSequence.fromList(new ArrayList>())); + } + ListSequence.fromList(MapSequence.fromMap(result).get(ref.getTargetNodeReference())).addElement(change); } + return ListSequence.fromList(initialStates).select(new ISelector>>() { + public List> select(NamedNodeReference initialState) { + return MapSequence.fromMap(result).get(initialState.reference()); + } + }).toListSequence(); } public SNode serializeInitialState(NamedNodeReference initialState) { return NodeReferenceUtil.makeReflection(initialState.reference(), initialState.name()); @@ -160,7 +196,4 @@ public SNode serializeFinalState(NamedNodeReference finalState) { public NamedNodeReference deserializeFinalState(SNode serialized) { return new NamedNodeReference(AbstractNodeReference__BehaviorDescriptor.getNodeReference_id4uVwhQyQbdz.invoke(serialized), SPropertyOperations.getString(serialized, MetaAdapterFactory.getProperty(0x9074634404fd4286L, 0x97d5b46ae6a81709L, 0x27bf3263be23f0dfL, 0x27bf3263be23f299L, "nodeName"))); } - private static boolean eq_k8iioh_a0a0a0a0a0a0a0a4a1a21(Object a, Object b) { - return (a != null ? a.equals(b) : a == b); - } } diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/trace.info b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/trace.info index 06b3a813f398..4b61c6c4870c 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/trace.info +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.migration/source_gen/jetbrains/mps/lang/migration/pluginSolution/plugin/trace.info @@ -667,205 +667,246 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - + + + + - + - - + + - - - + + + + + + + + + + + + + + + + + + - - - - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + - - - + + + - - - - - - - - - + + + + + + + + + + + + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/models/jetbrains/mps/lang/structure/pluginSolution/plugin.mps b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/models/jetbrains/mps/lang/structure/pluginSolution/plugin.mps index cccafde63d8c..d6407e49087a 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/models/jetbrains/mps/lang/structure/pluginSolution/plugin.mps +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/models/jetbrains/mps/lang/structure/pluginSolution/plugin.mps @@ -322,6 +322,9 @@ + + + @@ -5000,6 +5003,116 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -5401,8 +5514,13 @@ - - + + + + + + + @@ -5530,86 +5648,110 @@ - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - + + + + + - - - + - - - - - - - - - - - - - - - - - - - + + + + + + + + - + - + - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + - + - + @@ -5664,40 +5806,47 @@ - + - - - - - - - - - + + + + + + + + + - - + + - - + + + - - + + + + + + + + - + - + @@ -5710,8 +5859,25 @@ - - + + + + + + + + + + + + + + + + + + + @@ -5936,16 +6102,21 @@ - - - - - - - - - - + + + + + + + + + + + + + + + @@ -6018,9 +6189,6 @@ - - - diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/dependencies b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/dependencies index 96c04beea2ba..7e3e2bf4da97 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/dependencies +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/dependencies @@ -116,7 +116,6 @@ - diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/generated b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/generated index 52b22f889565..fbfea5953c93 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/generated +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen.caches/jetbrains/mps/lang/structure/pluginSolution/plugin/generated @@ -1,3 +1,3 @@ - + diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/MoveAspectsParticipant.java b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/MoveAspectsParticipant.java index 668c5b55339b..fe276ff6a298 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/MoveAspectsParticipant.java +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/MoveAspectsParticipant.java @@ -20,6 +20,7 @@ import org.jetbrains.mps.openapi.util.ProgressMonitor; import jetbrains.mps.internal.collections.runtime.Sequence; import java.util.Collections; +import jetbrains.mps.internal.collections.runtime.ISelector; import java.util.Map; import jetbrains.mps.smodel.LanguageAspect; import jetbrains.mps.smodel.structure.ExtensionPoint; @@ -28,7 +29,6 @@ import jetbrains.mps.internal.collections.runtime.ILeftCombinator; import org.jetbrains.mps.openapi.language.SAbstractConcept; import jetbrains.mps.internal.collections.runtime.IMapping; -import jetbrains.mps.internal.collections.runtime.ISelector; import jetbrains.mps.baseLanguage.tuples.runtime.Tuples; import jetbrains.mps.baseLanguage.tuples.runtime.MultiTuple; import jetbrains.mps.ide.findusages.model.SearchResults; @@ -81,7 +81,16 @@ public List> getCh return getChanges(initialState, repository, selectedOptions, searchScope, progressMonitor, Sequence.fromIterable(Collections.emptyList())); } + @Override + public List>> getChanges(List initialStates, final SRepository repository, final List selectedOptions, final SearchScope searchScope, final ProgressMonitor progressMonitor, final Iterable parents) { + return ListSequence.fromList(initialStates).select(new ISelector>>() { + public List> select(SNodeReference initialState) { + return getChanges(initialState, repository, selectedOptions, searchScope, progressMonitor, parents); + } + }).toListSequence(); + } + public List> getChanges(final SNodeReference initialState, final SRepository repository, final List selectedOptions, final SearchScope searchScope, final ProgressMonitor progressMonitor, final Iterable parents) { if (!((isApplicable(initialState, repository))) || !(ListSequence.fromList(selectedOptions).contains(OPTION))) { return ListSequence.fromList(new ArrayList>()); @@ -114,7 +123,7 @@ public RefactoringParticipant.Change select(fina public Iterable>> translate(final SNode node) { return Sequence.fromIterable(new ExtensionPoint>("jetbrains.mps.ide.platform.MoveNodeParticipantEP").getObjects()).select(new ISelector, Tuples._2>>() { public Tuples._2> select(MoveNodeRefactoringParticipant participant) { - RecursiveParticipant.RecursiveParticipantState participantState = RecursiveParticipant.RecursiveParticipantState.create(participant, node, parents); + RecursiveParticipant.RecursiveParticipantState participantState = RecursiveParticipant.RecursiveParticipantState.create(participant, ListSequence.fromListAndArray(new ArrayList(), node), parents); participantState.findChanges(repository, selectedOptions, searchScope, progressMonitor.subTask(1)); return MultiTuple.>from(node, participantState); } @@ -124,17 +133,21 @@ public RefactoringParticipant.Change select(fina final SearchResults results = new SearchResults(); results.addAll(new SearchResults(SetSequence.fromSetAndArray(new HashSet(), sourceConcept), ListSequence.fromListAndArray(new ArrayList>(), new SearchResult(aspect, "concept aspect")))); - ListSequence.fromList(childparticipantStates).translate(new ITranslator2>, RefactoringParticipant.Change>() { - public Iterable> translate(Tuples._2> it) { - return ((RefactoringParticipant.ParticipantState) it._1()).getChanges(); + ListSequence.fromList(childparticipantStates).select(new ISelector>, List>>() { + public List> select(Tuples._2> it) { + return (List>) ListSequence.fromList(it._1().getChanges()).first(); } - }).select(new ISelector, SearchResults>() { - public SearchResults select(RefactoringParticipant.Change it) { - return it.getSearchResults(); - } - }).visitAll(new IVisitor() { - public void visit(SearchResults it) { - results.addAll(it); + }).visitAll(new IVisitor>>() { + public void visit(List> it) { + ListSequence.fromList(it).select(new ISelector, SearchResults>() { + public SearchResults select(RefactoringParticipant.Change it1) { + return it1.getSearchResults(); + } + }).visitAll(new IVisitor() { + public void visit(SearchResults it1) { + results.addAll(it1); + } + }); } }); @@ -146,13 +159,17 @@ public SearchResults getSearchResults() { return results; } public boolean needsToPreserveOldNode() { - return ListSequence.fromList(childparticipantStates).translate(new ITranslator2>, RefactoringParticipant.Change>() { - public Iterable> translate(Tuples._2> it) { - return ((RefactoringParticipant.ParticipantState) it._1()).getChanges(); + return ListSequence.fromList(childparticipantStates).select(new ISelector>, List>>() { + public List> select(Tuples._2> it) { + return (List>) ListSequence.fromList(it._1().getChanges()).first(); } - }).any(new IWhereFilter>() { - public boolean accept(RefactoringParticipant.Change it) { - return it.needsToPreserveOldNode(); + }).any(new IWhereFilter>>() { + public boolean accept(List> it) { + return ListSequence.fromList(it).any(new IWhereFilter>() { + public boolean accept(RefactoringParticipant.Change it1) { + return it1.needsToPreserveOldNode(); + } + }); } }); } @@ -166,7 +183,7 @@ public void confirm(SNodeReference finalState, final SRepository repository, fin newLocation.insertNode(repository, ListSequence.fromList(copied).first()); ListSequence.fromList(childparticipantStates).visitAll(new IVisitor>>() { public void visit(Tuples._2> pis) { - pis._1().confirm(MapSequence.fromMap(copyMap).get(pis._0()), repository, refactoringSession); + pis._1().doRefactor(ListSequence.fromListAndArray(new ArrayList(), MapSequence.fromMap(copyMap).get(pis._0())), repository, refactoringSession); } }); } diff --git a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/trace.info b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/trace.info index 13f91827a069..38be21ee03a5 100644 --- a/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/trace.info +++ b/plugins/mpsdevkit/languages/pluginSolutions/lang.structure/source_gen/jetbrains/mps/lang/structure/pluginSolution/plugin/trace.info @@ -33,45 +33,46 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -79,38 +80,45 @@ - - - - - - - - - + + + + + + + + + + - - - - + + + + + + - + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + @@ -120,16 +128,17 @@ - - - - - - - - - - + + + + + + + + + + + @@ -143,33 +152,36 @@ - + + + + - + - + - - + + - - + + - - + + - - - + + + - - + + - + @@ -180,53 +192,70 @@ - + + + - - + + + + + + + + + + + + + - - - + + + + + - + + - + + - + - - + + - + - - + + @@ -234,22 +263,25 @@ - - - - - - - - - + + + + + + + + + + - - - - - + + + + + + + diff --git a/workbench/mps-platform/models/jetbrains/mps/ide/platform/actions/core.mps b/workbench/mps-platform/models/jetbrains/mps/ide/platform/actions/core.mps index 6e36683f37d3..beb903a9498b 100644 --- a/workbench/mps-platform/models/jetbrains/mps/ide/platform/actions/core.mps +++ b/workbench/mps-platform/models/jetbrains/mps/ide/platform/actions/core.mps @@ -50,7 +50,7 @@ - + @@ -154,7 +154,6 @@ - @@ -304,6 +303,9 @@ + + + @@ -319,9 +321,7 @@ - - - + @@ -350,10 +350,6 @@ - - - - @@ -492,8 +488,10 @@ + + @@ -2888,35 +2886,25 @@ - - - - - - - - - - - + + + + + + - - - + + + - - - - - - - - - - - + + + + + + @@ -2945,6 +2933,16 @@ + + + + + + + + + + @@ -3031,6 +3029,22 @@ + + + + + + + + + + + + + + + + @@ -3038,90 +3052,63 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + - - - - - - - + + + + - + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - @@ -3147,41 +3134,21 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + - - - + + @@ -3437,60 +3404,11 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + @@ -3512,103 +3430,83 @@ - + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - + + - - - + + + + + + - - + + - - - - - - - - + + + - - - - - - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - + + + + + + + + + + + + + + + + + + + + + - - - - @@ -3727,19 +3625,45 @@ - + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + + + - + @@ -3750,17 +3674,19 @@ - - - + + + + + + - - - + + @@ -3777,7 +3703,7 @@ - + @@ -3787,24 +3713,38 @@ - - - - - - + + + - - + + - - - + + + + + + + + + + + + + + + + + + + + + - @@ -4127,61 +4067,65 @@ - + - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - + + + + - - - - - - - - - - - + + + + + + + + + + + + - - - - - - @@ -5575,9 +5519,11 @@ - - - + + + + + @@ -5599,9 +5545,11 @@ - - - + + + + + @@ -5632,14 +5580,16 @@ - - - - - - - - + + + + + + + + + + @@ -5814,40 +5764,33 @@ - + - - + + + + - - - - - - - - + + + + + + + + + + - - - - - - - - - - - @@ -5856,6 +5799,19 @@ + + + + + + + + + + + + + @@ -5884,15 +5840,17 @@ - - - + + + + + - + @@ -5922,8 +5880,10 @@ - - + + + + @@ -6002,9 +5962,11 @@ - - - + + + + + @@ -6026,26 +5988,46 @@ - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + @@ -6072,7 +6054,7 @@ - + @@ -6141,14 +6123,16 @@ - - - - - - - - + + + + + + + + + + @@ -6191,7 +6175,7 @@ - + @@ -6209,24 +6193,28 @@ - - - - - - - - + + + + + + + + + + - + - - - + + + + + @@ -6244,71 +6232,91 @@ - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + @@ -6636,9 +6644,11 @@ - - - + + + + + @@ -6677,14 +6687,16 @@ - - - - - - - - + + + + + + + + + + @@ -6726,9 +6738,11 @@ - - - + + + + + @@ -6760,7 +6774,7 @@ - + @@ -6818,9 +6832,11 @@ - - - + + + + + @@ -6840,7 +6856,7 @@ - + @@ -6885,17 +6901,6 @@ - - - - - - - - - - - @@ -6930,7 +6935,7 @@ - + @@ -6938,7 +6943,7 @@ - + @@ -6997,7 +7002,7 @@ - + @@ -7067,6 +7072,19 @@ + + + + + + + + + + + + + @@ -7145,9 +7163,11 @@ - - - + + + + + @@ -7177,17 +7197,6 @@ - - - - - - - - - - - @@ -7197,9 +7206,9 @@ - + - + @@ -7235,8 +7244,11 @@ - - + + + + + @@ -7244,33 +7256,103 @@ - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + - - - - + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + - - + + + + + + + + + + @@ -7288,73 +7370,362 @@ + + + + + + + + + + + + + - + - + - + - + - + - + - - + + - + - + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/dependencies b/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/dependencies index 3f6d37e0b0ea..d96e3b587d18 100644 --- a/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/dependencies +++ b/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/dependencies @@ -57,7 +57,6 @@ - @@ -144,9 +143,11 @@ + + @@ -155,7 +156,11 @@ + + + + diff --git a/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/generated b/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/generated index 996e48f422c2..4640cb2bbc24 100644 --- a/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/generated +++ b/workbench/mps-platform/source_gen.caches/jetbrains/mps/ide/platform/actions/core/generated @@ -1,3 +1,3 @@ - + diff --git a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/MoveNodesDefault.java b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/MoveNodesDefault.java index 46aa47f91b8e..ddcf4f1a5552 100644 --- a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/MoveNodesDefault.java +++ b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/MoveNodesDefault.java @@ -39,7 +39,6 @@ import com.intellij.openapi.progress.Task; import com.intellij.openapi.progress.ProgressIndicator; import jetbrains.mps.progress.ProgressMonitorAdapter; -import jetbrains.mps.internal.collections.runtime.ILeftCombinator; import org.jetbrains.mps.openapi.util.SubProgressKind; import jetbrains.mps.ide.findusages.model.SearchResults; import jetbrains.mps.ide.platform.refactoring.RefactoringAccessEx; @@ -238,8 +237,9 @@ public void run() { } }); - final Map>> changes = MapSequence.fromMap(new HashMap>>()); + final Map> changes = MapSequence.fromMap(new HashMap>()); final Map nodeRoots = MapSequence.fromMap(new HashMap()); + final Wrappers._T> allNodes = new Wrappers._T>(); final Wrappers._T> options = new Wrappers._T>(); project.getRepository().getModelAccess().runReadAction(new Runnable() { public void run() { @@ -252,20 +252,18 @@ public SNodeReference select(SNode it) { MapSequence.fromMap(nodeRoots).put(descendant, nodeToMove); } } + allNodes.value = SetSequence.fromSet(MapSequence.fromMap(nodeRoots).keySet()).toListSequence(); for (MoveNodeRefactoringParticipant participant : Sequence.fromIterable(new ExtensionPoint>("jetbrains.mps.ide.platform.MoveNodeParticipantEP").getObjects()).toListSequence()) { - Map> participantStates = MapSequence.fromMap(new HashMap>()); - MapSequence.fromMap(changes).put(participant, participantStates); - for (SNodeReference nodeRef : SetSequence.fromSet(MapSequence.fromMap(nodeRoots).keySet())) { - MapSequence.fromMap(participantStates).put(nodeRef, RefactoringParticipant.ParticipantState.create(participant, resolveNode(nodeRef, project))); - } + RefactoringParticipant.ParticipantState participantState; + MapSequence.fromMap(changes).put(participant, RefactoringParticipant.ParticipantState.create(participant, ListSequence.fromList(allNodes.value).select(new ISelector() { + public SNode select(SNodeReference it) { + return resolveNode(it, project); + } + }).toListSequence())); } - options.value = MapSequence.fromMap(changes).translate(new ITranslator2>>, RefactoringParticipant.Option>() { - public Iterable translate(IMapping>> it) { - return MapSequence.fromMap(it.value()).translate(new ITranslator2>, RefactoringParticipant.Option>() { - public Iterable translate(IMapping> it) { - return it.value().getAvaliableOptions(project.getRepository()); - } - }); + options.value = MapSequence.fromMap(changes).translate(new ITranslator2>, RefactoringParticipant.Option>() { + public Iterable translate(IMapping> it) { + return it.value().getAvaliableOptions(project.getRepository()); } }).distinct().sort(new ISelector() { public String select(RefactoringParticipant.Option it) { @@ -300,24 +298,13 @@ public void run(@NotNull ProgressIndicator progressIndicator) { final ProgressMonitorAdapter progressMonitor = new ProgressMonitorAdapter(progressIndicator); project.getRepository().getModelAccess().runReadAction(new Runnable() { public void run() { - int steps = MapSequence.fromMap(changes).select(new ISelector>>, Integer>() { - public Integer select(IMapping>> pss) { - return MapSequence.fromMap(pss.value()).count(); - } - }).foldLeft(0, new ILeftCombinator() { - public Integer combine(Integer s, Integer it) { - return it + s; - } - }); + int steps = MapSequence.fromMap(changes).count(); progressMonitor.start("Searching for usages", steps); -outer: - for (IMapping>> participantStates : MapSequence.fromMap(changes)) { - for (IMapping> participantState : MapSequence.fromMap(participantStates.value())) { - if (progressMonitor.isCanceled()) { - cancelled.value = true; - break outer; - } - participantState.value().findChanges(project.getRepository(), selectedOptions, project.getScope(), progressMonitor.subTask(1, SubProgressKind.AS_COMMENT)); + for (IMapping> participantState : MapSequence.fromMap(changes)) { + participantState.value().findChanges(project.getRepository(), selectedOptions, project.getScope(), progressMonitor.subTask(1, SubProgressKind.AS_COMMENT)); + if (progressMonitor.isCanceled()) { + cancelled.value = true; + break; } } progressMonitor.done(); @@ -336,10 +323,11 @@ public Integer combine(Integer s, Integer it) { for (SNodeReference node : SetSequence.fromSet(MapSequence.fromMap(moveMap).keySet())) { MapSequence.fromMap(shouldKeep).put(node, false); } - for (IMapping>> participantChanges : MapSequence.fromMap(changes)) { - for (IMapping> nodeChanges : MapSequence.fromMap(participantChanges.value())) { - for (RefactoringParticipant.Change change : ListSequence.fromList(nodeChanges.value().getChanges())) { - MapSequence.fromMap(shouldKeep).putValue(MapSequence.fromMap(nodeRoots).get(nodeChanges.key()), MapSequence.fromMap(shouldKeep).get(MapSequence.fromMap(nodeRoots).get(nodeChanges.key())) || (change.needsToPreserveOldNode())); + for (IMapping> participantState : MapSequence.fromMap(changes)) { + List>> nodesChanges = participantState.value().getChanges(); + for (int i = 0; i < ListSequence.fromList(allNodes.value).count(); i++) { + for (RefactoringParticipant.Change change : ListSequence.fromList(ListSequence.fromList(nodesChanges).getElement(i))) { + MapSequence.fromMap(shouldKeep).putValue(MapSequence.fromMap(nodeRoots).get(ListSequence.fromList(allNodes.value).getElement(i)), MapSequence.fromMap(shouldKeep).get(MapSequence.fromMap(nodeRoots).get(ListSequence.fromList(allNodes.value).getElement(i))) || (change.needsToPreserveOldNode())); searchResults.addAll(change.getSearchResults()); } } @@ -355,7 +343,7 @@ public void run() { } - Map copyMap = MoveNodesDefault.CopyMapObject.getCopyMap(refactoringSession).getCopyMap(); + final Map copyMap = MoveNodesDefault.CopyMapObject.getCopyMap(refactoringSession).getCopyMap(); final Map resolveMap = MapSequence.fromMap(new HashMap()); List nodesToMove = ListSequence.fromList(new ArrayList()); for (SNodeReference nodeRef : SetSequence.fromSet(MapSequence.fromMap(nodeRoots).keySet())) { @@ -384,10 +372,12 @@ public Boolean select(SNodeReference it) { } } - for (IMapping>> participantChanges : MapSequence.fromMap(changes)) { - for (IMapping> nodeChanges : MapSequence.fromMap(participantChanges.value())) { - nodeChanges.value().confirm(MapSequence.fromMap(copyMap).get(MapSequence.fromMap(resolveMap).get(nodeChanges.key())), project.getRepository(), refactoringSession); - } + for (IMapping> participantState : MapSequence.fromMap(changes)) { + participantState.value().doRefactor(ListSequence.fromList(allNodes.value).select(new ISelector() { + public SNode select(SNodeReference it) { + return MapSequence.fromMap(copyMap).get(MapSequence.fromMap(resolveMap).get(it)); + } + }).toListSequence(), project.getRepository(), refactoringSession); } try { refactoringSession.commit(); diff --git a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RecursiveParticipant.java b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RecursiveParticipant.java index 39e9cda3931e..7bed0f8813c4 100644 --- a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RecursiveParticipant.java +++ b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RecursiveParticipant.java @@ -11,29 +11,29 @@ public interface RecursiveParticipant extends RefactoringParticipant { - public List> getChanges(InitialDataObject initialState, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor, Iterable parents); + public List>> getChanges(List initialStates, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor, Iterable parents); public static class RecursiveParticipantState extends RefactoringParticipant.ParticipantState { private Iterable myParents; - public static RecursiveParticipant.RecursiveParticipantState create(RefactoringParticipant participant, IP oldNode, Iterable parents) { - return new RecursiveParticipant.RecursiveParticipantState(participant, oldNode, parents); + public static RecursiveParticipant.RecursiveParticipantState create(RefactoringParticipant participant, List oldNodes, Iterable parents) { + return new RecursiveParticipant.RecursiveParticipantState(participant, oldNodes, parents); } - private RecursiveParticipantState(RefactoringParticipant participant, IP oldNode, Iterable parents) { - super(participant, oldNode); + private RecursiveParticipantState(RefactoringParticipant participant, List oldNodes, Iterable parents) { + super(participant, oldNodes); myParents = parents; } @Override - protected List> initChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { + protected List>> initChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { if (getParticipant() instanceof RecursiveParticipant) { if (Sequence.fromIterable(myParents).any(new IWhereFilter() { public boolean accept(RefactoringParticipant.ParticipantState parent) { - return eq_7nv468_a0a0a0a0a0a0a0a3d_0(parent.getParticipant(), RecursiveParticipantState.this.getParticipant()) && eq_7nv468_a0a0a0a0a0a0a0a3d(parent.getInitialState(), RecursiveParticipantState.this.getInitialState()); + return eq_7nv468_a0a0a0a0a0a0a0a3d_0(parent.getParticipant(), RecursiveParticipantState.this.getParticipant()) && eq_7nv468_a0a0a0a0a0a0a0a3d(parent.getInitialStates(), RecursiveParticipantState.this.getInitialStates()); } })) { // todo: checked exception throw new IllegalStateException("infinite recursion detected"); } else { - return ((RecursiveParticipant) getParticipant()).getChanges(getInitialState(), repository, selectedOptions, searchScope, progressMonitor, Sequence.fromIterable(myParents).concat(Sequence.fromIterable(Sequence.singleton(this)))); + return ((RecursiveParticipant) getParticipant()).getChanges(getInitialStates(), repository, selectedOptions, searchScope, progressMonitor, Sequence.fromIterable(myParents).concat(Sequence.fromIterable(Sequence.singleton(this)))); } } else { return super.initChanges(repository, selectedOptions, searchScope, progressMonitor); diff --git a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipant.java b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipant.java index bd3dff35920e..5dda4b4f70a8 100644 --- a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipant.java +++ b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipant.java @@ -9,6 +9,8 @@ import jetbrains.mps.ide.findusages.model.SearchResults; import org.jetbrains.mps.openapi.model.SNode; import jetbrains.mps.internal.collections.runtime.ListSequence; +import jetbrains.mps.internal.collections.runtime.ISelector; +import java.util.Iterator; import jetbrains.mps.internal.collections.runtime.IVisitor; public interface RefactoringParticipant { @@ -44,9 +46,9 @@ private static boolean eq_g5nieh_a0a0a6f(Object a, Object b) { } } - public List getAvailableOptions(InitialDataObject initialState, SRepository repository); + public List getAvailableOptions(List initialStates, SRepository repository); - public List> getChanges(InitialDataObject initialState, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor); + public List>> getChanges(List initialStates, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor); public static interface Change { public SearchResults getSearchResults(); @@ -64,40 +66,54 @@ public static interface PersistentRefactoringParticipant { private RefactoringParticipant myParticipant; - private I myInitialState; - private List> changes; - public List> getChanges() { + private List myInitialStates; + private List>> changes; + public List>> getChanges() { return changes; } public RefactoringParticipant getParticipant() { return myParticipant; } - public I getInitialState() { - return myInitialState; + public List getInitialStates() { + return myInitialStates; } - public static RefactoringParticipant.ParticipantState create(RefactoringParticipant participant, IP oldNode) { + public static RefactoringParticipant.ParticipantState create(RefactoringParticipant participant, List oldNode) { return new RefactoringParticipant.ParticipantState(participant, oldNode); } - public ParticipantState(RefactoringParticipant participant, IP oldNode) { + public ParticipantState(RefactoringParticipant participant, List oldNodes) { this.myParticipant = participant; - myInitialState = this.myParticipant.getDataCollector().beforeMove(oldNode); + myInitialStates = ListSequence.fromList(oldNodes).select(new ISelector() { + public I select(IP oldNode) { + return ParticipantState.this.myParticipant.getDataCollector().beforeMove(oldNode); + } + }).toListSequence(); } public List getAvaliableOptions(SRepository repository) { - return myParticipant.getAvailableOptions(myInitialState, repository); + return myParticipant.getAvailableOptions(myInitialStates, repository); } - public List> findChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { + public List>> findChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { return changes = initChanges(repository, selectedOptions, searchScope, progressMonitor); } - protected List> initChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { - return myParticipant.getChanges(myInitialState, repository, selectedOptions, searchScope, progressMonitor); + protected List>> initChanges(SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { + return myParticipant.getChanges(myInitialStates, repository, selectedOptions, searchScope, progressMonitor); } - public void confirm(FP newNode, final SRepository repository, final RefactoringSession session) { - final F finalState = this.myParticipant.getDataCollector().afterMove(newNode); - ListSequence.fromList(this.changes).visitAll(new IVisitor>() { - public void visit(RefactoringParticipant.Change it) { - it.confirm(finalState, repository, session); + public void doRefactor(List newNodes, final SRepository repository, final RefactoringSession session) { + { + Iterator>> nodeChanges_it = ListSequence.fromList(this.changes).iterator(); + Iterator newNode_it = ListSequence.fromList(newNodes).iterator(); + List> nodeChanges_var; + FP newNode_var; + while (nodeChanges_it.hasNext() && newNode_it.hasNext()) { + nodeChanges_var = nodeChanges_it.next(); + newNode_var = newNode_it.next(); + final F finalState = this.myParticipant.getDataCollector().afterMove(newNode_var); + ListSequence.fromList(nodeChanges_var).visitAll(new IVisitor>() { + public void visit(RefactoringParticipant.Change it) { + it.confirm(finalState, repository, session); + } + }); } - }); + } } } diff --git a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipantBase.java b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipantBase.java index 85e29eeba885..8fde1cc0d60b 100644 --- a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipantBase.java +++ b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/RefactoringParticipantBase.java @@ -7,17 +7,56 @@ import org.jetbrains.mps.openapi.module.SearchScope; import org.jetbrains.mps.openapi.util.ProgressMonitor; import jetbrains.mps.internal.collections.runtime.ListSequence; +import java.util.ArrayList; import jetbrains.mps.progress.EmptyProgressMonitor; +import jetbrains.mps.internal.collections.runtime.ITranslator2; +import jetbrains.mps.internal.collections.runtime.IWhereFilter; public abstract class RefactoringParticipantBase implements RefactoringParticipant { - public List> getChanges(InitialDataObject initialState, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { - RefactoringParticipant.Option firstOption = ListSequence.fromList(getAvailableOptions(initialState, repository)).first(); - progressMonitor.start((firstOption == null ? "" : firstOption.getDescription()), 1); - List> result = getChanges(initialState, repository, selectedOptions, searchScope); + public List>> getChanges(List initialStates, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { + RefactoringParticipant.Option firstOption = ListSequence.fromList(getAvailableOptions(initialStates, repository)).first(); + progressMonitor.start((firstOption == null ? "" : firstOption.getDescription()), ListSequence.fromList(initialStates).count()); + List>> result = ListSequence.fromList(new ArrayList>>(ListSequence.fromList(initialStates).count())); + for (InitialDataObject initialState : ListSequence.fromList(initialStates)) { + progressMonitor.advance(1); + ListSequence.fromList(result).addElement(getChanges(initialState, repository, selectedOptions, searchScope)); + if (progressMonitor.isCanceled()) { + return null; + } + } progressMonitor.done(); return result; } public List> getChanges(InitialDataObject initialState, SRepository repository, List selectedOptions, SearchScope searchScope) { return getChanges(initialState, repository, selectedOptions, searchScope, new EmptyProgressMonitor()); } + public List> getChanges(InitialDataObject initialState, SRepository repository, List selectedOptions, SearchScope searchScope, ProgressMonitor progressMonitor) { + return ListSequence.fromList(getChanges(ListSequence.fromListAndArray(new ArrayList(), initialState), repository, selectedOptions, searchScope, progressMonitor)).first(); + } + + + + + + + public List getAvailableOptions(List initialStates, final SRepository repository) { + return ListSequence.fromList(initialStates).translate(new ITranslator2() { + public Iterable translate(InitialDataObject initialState) { + return getAvailableOptions(initialState, repository); + } + }).distinct().toListSequence(); + } + public List getAvailableOptions(InitialDataObject initialState, SRepository repository) { + return getAvailableOptions(ListSequence.fromListAndArray(new ArrayList(), initialState), repository); + } + public boolean isApplicable(List initialStates, final SRepository repository) { + return ListSequence.fromList(initialStates).any(new IWhereFilter() { + public boolean accept(InitialDataObject initialState) { + return isApplicable(initialState, repository); + } + }); + } + public boolean isApplicable(InitialDataObject initialState, SRepository repository) { + return isApplicable(ListSequence.fromListAndArray(new ArrayList(), initialState), repository); + } } diff --git a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/trace.info b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/trace.info index 7a2822c77403..74692c319b80 100644 --- a/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/trace.info +++ b/workbench/mps-platform/source_gen/jetbrains/mps/ide/platform/actions/core/trace.info @@ -26,46 +26,46 @@ - + - - - - + + + + - + - + - + - + - + - - - + + + - + - + @@ -81,12 +81,12 @@ - + - + @@ -117,467 +117,449 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - + - - + + - + - - + + - - + + - + - + - - - - + + + + - - + + - - + + - + - + - + - - - - - - - - + - + - + - + - + - - - + + - + - - - + + + - + - - - + + + - - - + + - + + - + - - - - - - - - - - + + + + - + - + - - + + - - - + + + + + - + - + - - + + - - + + - - - + + - + - - + + - - - + + + - + - + @@ -585,74 +567,75 @@ - + + + + - - + + - - + + + - - + + + + + + + + - + - + - - - - - + - - - - + + - - - - - - + + - + - + - - - + + + - + + @@ -662,203 +645,224 @@ - + - - + + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - + + + + + + + + - - + + - - - + + + - - + + - + - + - + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - - + + + + - + + + + - + - + - - + + - + - - + + + - - + + + + + + + + - - + + + - - - - - - - + + + + + + + + @@ -887,33 +891,95 @@ - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - + + + From 84e6cc06f905bb60a4b304f6a58b02db4e42b2f8 Mon Sep 17 00:00:00 2001 From: Mihail Buryakov Date: Wed, 3 Feb 2016 20:22:42 +0300 Subject: [PATCH 2/5] MPS-23292: do not show all results if their quantity exceeds 30000 --- .../jetbrains.mps.ide/models/refactoring.mps | 218 +++++++++++++++++- .../mps/ide/refactoring/dependencies | 6 + .../jetbrains/mps/ide/refactoring/generated | 2 +- .../refactoring/RefactoringAccessImpl.java | 21 +- .../jetbrains/mps/ide/refactoring/trace.info | 94 +++++--- 5 files changed, 296 insertions(+), 45 deletions(-) diff --git a/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps b/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps index 39c551d77c18..27d0fd394c2b 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps +++ b/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps @@ -215,6 +215,7 @@ + @@ -230,6 +231,9 @@ + + + @@ -324,6 +328,9 @@ + + + @@ -331,6 +338,7 @@ + @@ -4457,6 +4465,15 @@ + + + + + + + + + @@ -4721,8 +4738,14 @@ - - + + + + + + + + @@ -4807,8 +4830,23 @@ - - + + + + + + + + + + + + + + + + + @@ -4821,6 +4859,178 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies index 4e7d148aef3f..0c42707b82c0 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies @@ -87,14 +87,20 @@ + + + + + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated index 28235b64ec98..1ab905f015cd 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated @@ -1,3 +1,3 @@ - + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringAccessImpl.java b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringAccessImpl.java index a1d84d2cc01b..aa41e073918c 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringAccessImpl.java +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringAccessImpl.java @@ -14,8 +14,14 @@ import jetbrains.mps.ide.platform.refactoring.RefactoringViewAction; import jetbrains.mps.ide.findusages.model.SearchResults; import jetbrains.mps.refactoring.framework.RefactoringContext; +import jetbrains.mps.ide.project.ProjectHelper; +import com.intellij.openapi.ui.Messages; +import jetbrains.mps.internal.collections.runtime.ListSequence; +import java.util.List; +import jetbrains.mps.ide.findusages.model.SearchResult; public class RefactoringAccessImpl extends RefactoringAccessEx implements ApplicationComponent { + private static final int MAX_SEARCH_RESULTS = 30000; public RefactoringAccessImpl(MPSCoreComponents coreComponents) { } @Override @@ -47,11 +53,22 @@ public ModelElementTargetChooser createTargetChooser(Project project, SNode node @Override public void showRefactoringView(Project project, RefactoringViewAction callback, SearchResults searchResults, boolean hasModelsToGenerate, String name) { RefactoringView refactoringView = project.getComponent(RefactoringView.class); - refactoringView.showRefactoringView(project, callback, searchResults, hasModelsToGenerate, name); + refactoringView.showRefactoringView(project, callback, truncateSearchResults(project, searchResults), hasModelsToGenerate, name); } @Override public void showRefactoringView(RefactoringContext refactoringContext, RefactoringViewAction callback, SearchResults searchResults, boolean hasModelsToGenerate, String name) { RefactoringView refactoringView = refactoringContext.getCurrentOperationContext().getComponent(RefactoringView.class); - refactoringView.showRefactoringView(refactoringContext, callback, searchResults, hasModelsToGenerate); + refactoringView.showRefactoringView(refactoringContext, callback, truncateSearchResults(ProjectHelper.toIdeaProject(refactoringContext.getSelectedProject()), searchResults), hasModelsToGenerate); + } + private SearchResults truncateSearchResults(Project project, SearchResults searchResults) { + if (searchResults.getSearchResults().size() > MAX_SEARCH_RESULTS) { + Messages.showWarningDialog(project, "More than " + MAX_SEARCH_RESULTS + " usages found. Only first " + MAX_SEARCH_RESULTS + " results will be displayed.", "Refactor"); + + SearchResults truncatedSearchResults = new SearchResults(); + truncatedSearchResults.getSearchedNodes().addAll(searchResults.getSearchedNodes()); + truncatedSearchResults.getSearchResults().addAll(ListSequence.fromList(((List>) searchResults.getSearchResults())).take(MAX_SEARCH_RESULTS).toListSequence()); + return truncatedSearchResults; + } + return searchResults; } } diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info index dd9b777bd8b7..2be78514e435 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info @@ -558,72 +558,90 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - - - + + + - + - - + + - + - + + + + + + + + + From 3bce41749a9e9a0d708205315ab4196bfa30c249 Mon Sep 17 00:00:00 2001 From: Mihail Buryakov Date: Sun, 31 Jan 2016 15:14:11 +0300 Subject: [PATCH 3/5] MPS-23323 Introduce Local Variable Refactoring searches for duplicates in the whole root instead of current baseLanguage query --- .../solution/refactorings.mps | 277 +++++++++++++++--- .../jetbrains/mps/baseLanguage/util/generated | 112 +------ .../util/plugin/refactorings/dependencies | 4 + .../util/plugin/refactorings/generated | 2 +- .../IntroduceLocalVariableRefactoring.java | 27 +- .../util/plugin/refactorings/trace.info | 230 ++++++++------- 6 files changed, 392 insertions(+), 260 deletions(-) diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/solution/refactorings.mps b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/solution/refactorings.mps index a40dbcad3e80..fbb4bf1021cd 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/solution/refactorings.mps +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/solution/refactorings.mps @@ -62,6 +62,7 @@ + @@ -322,6 +323,9 @@ + + + @@ -454,6 +458,9 @@ + + + @@ -537,6 +544,7 @@ + @@ -1424,65 +1432,260 @@ - - - - - - + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + - - - - + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + - - - + + + + + + + + + + + + + + @@ -1490,7 +1693,7 @@ - + diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/generated b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/generated index 7730e28a4d39..0195aa5347e7 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/generated +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/generated @@ -1,113 +1,3 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/dependencies b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/dependencies index 5a7221b1345f..ea0d340d9621 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/dependencies +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/dependencies @@ -565,12 +565,16 @@ + + + + diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/generated b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/generated index 872687bd2f04..21b7ce96d5b7 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/generated +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen.caches/jetbrains/mps/baseLanguage/util/plugin/refactorings/generated @@ -1,3 +1,3 @@ - + diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/IntroduceLocalVariableRefactoring.java b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/IntroduceLocalVariableRefactoring.java index f2cb9686fb9d..418e440cc7bb 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/IntroduceLocalVariableRefactoring.java +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/IntroduceLocalVariableRefactoring.java @@ -8,9 +8,11 @@ import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory; import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations; import jetbrains.mps.internal.collections.runtime.ListSequence; +import java.util.List; +import jetbrains.mps.internal.collections.runtime.IWhereFilter; import jetbrains.mps.smodel.behaviour.BHReflection; import jetbrains.mps.core.aspects.behaviour.SMethodTrimmedId; -import java.util.List; +import jetbrains.mps.internal.collections.runtime.Sequence; import org.jetbrains.mps.openapi.persistence.PersistenceFacade; import jetbrains.mps.smodel.SModelUtil_new; import org.jetbrains.mps.openapi.model.SNodeAccessUtil; @@ -42,12 +44,25 @@ public SNode doRefactoring() { return varDeclaration; } @Override - protected SNode getRootToFindDuplicates(SNode node) { - SNode result = SNodeOperations.getNodeAncestor(node, MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b200L, "jetbrains.mps.baseLanguage.structure.StatementList"), false, false); - while ((SNodeOperations.getNodeAncestor(result, MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b200L, "jetbrains.mps.baseLanguage.structure.StatementList"), false, false) != null)) { - result = SNodeOperations.getNodeAncestor(result, MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b200L, "jetbrains.mps.baseLanguage.structure.StatementList"), false, false); + public SNode getRootToFindDuplicates(final SNode node) { + List ancestors = SNodeOperations.getNodeAncestors(node, null, false); + SNode statementListContainer = SNodeOperations.getNodeAncestor(node, MetaAdapterFactory.getInterfaceConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x11750ef8265L, "jetbrains.mps.baseLanguage.structure.IStatementListContainer"), false, false); + SNode metaContainer = ListSequence.fromList(ancestors).findFirst(new IWhereFilter() { + public boolean accept(SNode it) { + return ((int) (Integer) BHReflection.invoke(it, SMethodTrimmedId.create("getMetaLevel", null, "3t0v3yFOD1A"))) != ((int) (Integer) BHReflection.invoke(node, SMethodTrimmedId.create("getMetaLevel", null, "3t0v3yFOD1A"))); + } + }); + int statementListContainerIndex = ListSequence.fromList(ancestors).indexOf(statementListContainer); + int metaContainerIndex = ListSequence.fromList(ancestors).indexOf(metaContainer); + if (statementListContainerIndex >= 0 && metaContainerIndex >= 0) { + ancestors = ListSequence.fromList(ancestors).take(Math.min(statementListContainerIndex, metaContainerIndex)).toListSequence(); + } else if (statementListContainerIndex < 0 && metaContainerIndex >= 0) { + ancestors = ListSequence.fromList(ancestors).take(metaContainerIndex).toListSequence(); + } else if (statementListContainerIndex >= 0 && metaContainerIndex < 0) { + ancestors = ListSequence.fromList(ancestors).take(statementListContainerIndex).toListSequence(); } - return result; + + return Sequence.fromIterable(SNodeOperations.ofConcept(ancestors, MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b200L, "jetbrains.mps.baseLanguage.structure.StatementList"))).last(); } @Override public void replaceNode(SNode node, SNode declaration) { diff --git a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/trace.info b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/trace.info index 104a5649aa04..675003706de9 100644 --- a/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/trace.info +++ b/languages/baseLanguage/baseLanguage/solutions/jetbrains.mps.baseLanguage.util/source_gen/jetbrains/mps/baseLanguage/util/plugin/refactorings/trace.info @@ -2328,146 +2328,166 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + - + - - - - - - + + + - + - + - - - - + - - - + + + + + + + + + + - + - + - + - + + + + - - + + + From 8fc9b48cbda488a1784e6f9f019168d2afec848d Mon Sep 17 00:00:00 2001 From: Mihail Buryakov Date: Mon, 1 Feb 2016 16:12:58 +0300 Subject: [PATCH 4/5] MPS-23044: Persisting 'Safe Delete' option state --- .../jetbrains.mps.ide/models/actions.mps | 104 +++++----- .../jetbrains.mps.ide/models/refactoring.mps | 179 +++++++++++++++++- .../jetbrains/mps/ide/actions/dependencies | 1 + .../jetbrains/mps/ide/actions/generated | 2 +- .../mps/ide/refactoring/dependencies | 13 ++ .../jetbrains/mps/ide/refactoring/generated | 2 +- .../mps/ide/actions/DeleteModels_Action.java | 6 +- .../jetbrains/mps/ide/actions/trace.info | 135 ++++++------- .../ide/refactoring/RefactoringSettings.java | 43 +++++ .../jetbrains/mps/ide/refactoring/trace.info | 30 +++ .../source/META-INF/MPSComponents.xml | 3 + 11 files changed, 398 insertions(+), 120 deletions(-) create mode 100644 workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringSettings.java diff --git a/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps b/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps index daf1e834795f..d24e1106d20a 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps +++ b/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps @@ -2,27 +2,27 @@ - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + @@ -522,7 +522,7 @@ - + @@ -7706,6 +7706,21 @@ + + + + + + + + + + + + + + + @@ -7718,8 +7733,8 @@ - - + + @@ -7728,26 +7743,6 @@ - - - - - - - - - - - - - - - - - - - - @@ -7801,6 +7796,27 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps b/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps index 27d0fd394c2b..90454eb33ab3 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps +++ b/workbench/mps-workbench/jetbrains.mps.ide/models/refactoring.mps @@ -2,11 +2,11 @@ - - - - - + + + + + @@ -58,6 +58,7 @@ + @@ -86,10 +87,15 @@ + + + + + @@ -5595,5 +5601,168 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/dependencies b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/dependencies index 244c7f628dc0..00768c884117 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/dependencies +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/dependencies @@ -576,6 +576,7 @@ + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated index 9d13bf6145ce..97835d537acf 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated @@ -1,3 +1,3 @@ - + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies index 0c42707b82c0..9198bf9a1440 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/dependencies @@ -109,6 +109,19 @@ + + + + + + + + + + + + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated index 1ab905f015cd..7c02b2b6ccf9 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/refactoring/generated @@ -1,3 +1,3 @@ - + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/DeleteModels_Action.java b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/DeleteModels_Action.java index 8eb652e62ce5..6ec923fd4fb9 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/DeleteModels_Action.java +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/DeleteModels_Action.java @@ -12,6 +12,7 @@ import java.util.List; import org.jetbrains.mps.openapi.model.SModel; import org.jetbrains.annotations.NotNull; +import jetbrains.mps.ide.refactoring.RefactoringSettings; import jetbrains.mps.workbench.dialogs.DeleteDialog; import org.jetbrains.mps.openapi.module.ModelAccess; import jetbrains.mps.smodel.MPSModuleRepository; @@ -60,13 +61,14 @@ protected boolean collectActionData(AnActionEvent event, final Map _params) { - final DeleteDialog.DeleteOption safeOption = new DeleteDialog.DeleteOption("Safe Delete", false, true); - DeleteDialog.DeleteOption filesOption = new DeleteDialog.DeleteOption("Delete Files", false, true); + boolean safeDelete = RefactoringSettings.getInstance().SAFE_DELETE; + final DeleteDialog.DeleteOption safeOption = new DeleteDialog.DeleteOption("Safe Delete", safeDelete, true); DeleteDialog dialog = new DeleteDialog(((MPSProject) MapSequence.fromMap(_params).get("project")), "Delete Models", "Are you sure you want to delete selected models?", safeOption); dialog.show(); if (!(dialog.isOK())) { return; } + RefactoringSettings.getInstance().SAFE_DELETE = safeOption.selected; ModelAccess modelAccess = ((MPSProject) MapSequence.fromMap(_params).get("project")).getRepository().getModelAccess(); modelAccess.executeCommandInEDT(new Runnable() { diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/trace.info b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/trace.info index cba6da7a4ccd..79c4f0b8946c 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/trace.info +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/actions/trace.info @@ -7405,91 +7405,92 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - - - + + + - + - + + - - + - - + + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringSettings.java b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringSettings.java new file mode 100644 index 000000000000..0475c9806a28 --- /dev/null +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/RefactoringSettings.java @@ -0,0 +1,43 @@ +package jetbrains.mps.ide.refactoring; + +/*Generated by MPS */ + +import com.intellij.openapi.components.State; +import com.intellij.openapi.components.Storage; +import com.intellij.openapi.components.StoragePathMacros; +import com.intellij.openapi.components.PersistentStateComponent; +import com.intellij.openapi.components.ApplicationComponent; +import com.intellij.openapi.application.ApplicationManager; +import org.jetbrains.annotations.Nullable; +import com.intellij.util.xmlb.XmlSerializerUtil; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; + +@State(name = "MpsRefactoringSettings", storages = @Storage(file = StoragePathMacros.APP_CONFIG + "/refactoringSettings.xml") +) +public class RefactoringSettings implements PersistentStateComponent, ApplicationComponent { + + public boolean SAFE_DELETE = true; + + public static RefactoringSettings getInstance() { + return ApplicationManager.getApplication().getComponent(RefactoringSettings.class); + } + @Nullable + public RefactoringSettings getState() { + return this; + } + public void loadState(RefactoringSettings state) { + XmlSerializerUtil.copyBean(state, this); + } + + public void initComponent() { + } + public void disposeComponent() { + } + @NonNls + @NotNull + public String getComponentName() { + return "Refactoring Settings"; + } + +} diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info index 2be78514e435..5c3fba09d9c6 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen/jetbrains/mps/ide/refactoring/trace.info @@ -794,6 +794,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/workbench/mps-workbench/source/META-INF/MPSComponents.xml b/workbench/mps-workbench/source/META-INF/MPSComponents.xml index f1efd792b0a5..761af4895ed4 100644 --- a/workbench/mps-workbench/source/META-INF/MPSComponents.xml +++ b/workbench/mps-workbench/source/META-INF/MPSComponents.xml @@ -97,6 +97,9 @@ jetbrains.mps.ide.generator.GenerationSettings + + jetbrains.mps.ide.refactoring.RefactoringSettings + jetbrains.mps.ide.generator.index.IndexBasedModelDigest From ca281ec8538dbe5cef84badeff77a6de207bcc55 Mon Sep 17 00:00:00 2001 From: Mihail Buryakov Date: Fri, 5 Feb 2016 11:08:16 +0300 Subject: [PATCH 5/5] fixing MPS-23044: resave model --- workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps | 2 +- .../source_gen.caches/jetbrains/mps/ide/actions/generated | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps b/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps index d24e1106d20a..8ff42226b274 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps +++ b/workbench/mps-workbench/jetbrains.mps.ide/models/actions.mps @@ -522,7 +522,7 @@ - + diff --git a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated index 97835d537acf..7a6132cd44e7 100644 --- a/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated +++ b/workbench/mps-workbench/jetbrains.mps.ide/source_gen.caches/jetbrains/mps/ide/actions/generated @@ -1,3 +1,3 @@ - +