@Override
public SearchResults find(SearchQuery query, @NotNull ProgressMonitor monitor) {
SearchResults<SNode> searchResults = new SearchResults<SNode>();
Object value = query.getObjectHolder().getObject();
SModule module = null;
if (value instanceof SModule) {
module = ((SModule) value);
} else if (value instanceof SModuleReference) {
module = query.getScope().resolve(((SModuleReference) value));
}
if (!(module instanceof Language)) {
return searchResults;
}
Language language = (Language) module;
SModel structureModel = language.getStructureModelDescriptor();
if (structureModel == null) {
return searchResults;
}
if (!(structureModel.getRootNodes().iterator().hasNext())) {
return searchResults;
}
List<SNode> roots = new LinkedList<SNode>();
for (SNode root : structureModel.getRootNodes()) {
roots.add(root);
}
searchResults.getSearchedNodes().addAll(roots);
monitor.start("", IterableUtil.asCollection(structureModel.getRootNodes()).size() + 1);
try {
SearchResults<SModel> modelResults =
FindUtils.getSearchResults(
monitor.subTask(1),
new SearchQuery(
structureModel.getReference(), GlobalScopeMinusTransient.getInstance()),
new ModelImportsUsagesFinder());
List<SModel> models = new ArrayList<SModel>();
for (SearchResult<SModel> sModelSearchResult : modelResults.getSearchResults()) {
models.add(sModelSearchResult.getObject());
}
SearchScope scope = new ModelsScope(models.toArray(new SModel[models.size()]));
SearchResults<SNode> results = new SearchResults();
for (SNode node : roots) {
if (monitor.isCanceled()) {
break;
}
results.addAll(
FindUtils.getSearchResults(
monitor.subTask(1),
node,
scope,
"jetbrains.mps.lang.structure.findUsages.NodeUsages_Finder"));
results.removeDuplicates();
}
searchResults.getSearchResults().addAll(results.getSearchResults());
return searchResults;
} finally {
monitor.done();
}
}
public SearchResults getAffectedNodes(final RefactoringContext refactoringContext) {
SearchResults searchResults = new SearchResults();
for (SNode selNode : ListSequence.fromList(refactoringContext.getSelectedNodes())) {
searchResults.addAll(
FindUtils.getSearchResults(
new EmptyProgressMonitor(),
selNode,
GlobalScope.getInstance(),
"jetbrains.mps.lang.structure.findUsages.NodeAndDescendantsUsages_Finder"));
}
return searchResults;
}
public SearchResults find(SearchQuery query, ProgressMonitor monitor) {
SearchResults<SNode> searchResults = new SearchResults<SNode>();
IHolder holder = query.getObjectHolder();
assert holder instanceof ModuleHolder;
IModule module = ((ModuleHolder) holder).getObject();
assert module instanceof Language;
Language language = (Language) module;
SModelDescriptor structureModel = language.getStructureModelDescriptor();
if (structureModel == null) {
return searchResults;
}
SModel sModel = structureModel.getSModel();
if (sModel == null) {
return searchResults;
}
if (sModel.rootsCount() == 0) {
return searchResults;
}
List<SNode> roots = new LinkedList<SNode>();
for (SNode root : sModel.roots()) {
roots.add(root);
}
searchResults.getSearchedNodes().addAll(roots);
monitor.start("", sModel.rootsCount() + 1);
try {
SearchResults<SModel> modelResults =
FindUtils.getSearchResults(
monitor.subTask(1),
new SearchQuery(sModel, GlobalScopeMinusTransient.getInstance()),
new ModelUsagesFinder());
List<SModelDescriptor> models = new ArrayList<SModelDescriptor>();
for (SearchResult<SModel> sModelSearchResult : modelResults.getSearchResults()) {
models.add(sModelSearchResult.getObject().getModelDescriptor());
}
IScope scope = new ModelsOnlyScope(models.toArray(new SModelDescriptor[models.size()]));
SearchResults results = new SearchResults();
for (SNode node : roots) {
if (monitor != null && monitor.isCanceled()) {
break;
}
results.addAll(
FindUtils.getSearchResults(
monitor.subTask(1),
node,
scope,
"jetbrains.mps.lang.structure.findUsages.NodeUsages_Finder"));
results.removeDuplicates();
}
searchResults.getSearchResults().addAll(results.getSearchResults());
return searchResults;
} finally {
monitor.done();
}
}
public SearchResults<SNode> nodesToRefactoringResult(
Collection<SNode> searchedNodes, Iterable<SNode> usages, final String category) {
SearchResults<SNode> searchResults = new SearchResults<SNode>();
searchResults.getSearchedNodes().addAll(searchedNodes);
searchResults
.getSearchResults()
.addAll(
Sequence.fromIterable(usages)
.select(
new ISelector<SNode, SearchResult<SNode>>() {
public SearchResult<SNode> select(SNode it) {
return new SearchResult<SNode>(it, category);
}
})
.toListSequence());
return searchResults;
}
@Override
public SearchResults find(SearchQuery query, ProgressMonitor monitor) {
myResults = new SearchResults<SNode>();
SearchScope queryScope = query.getScope();
monitor.start("Searching applicable nodes", myScripts.size());
try {
for (RefactoringScript scriptInstance : myScripts) {
if (monitor.isCanceled()) {
break;
}
Collection<AbstractMigrationRefactoring> refactorings = scriptInstance.getRefactorings();
for (AbstractMigrationRefactoring ref : refactorings) {
if (monitor.isCanceled()) {
break;
}
monitor.step(scriptInstance.getName() + " [" + ref.getAdditionalInfo() + "]");
Set<SNode> instances =
FindUsagesFacade.getInstance()
.findInstances(
queryScope,
Collections.singleton(ref.getApplicableConcept()),
false,
new EmptyProgressMonitor());
for (SNode instance : instances) {
try {
if (ref.isApplicableInstanceNode(instance)) {
String category =
StringUtil.escapeXml(scriptInstance.getName())
+ " </b>["
+ StringUtil.escapeXml(ref.getAdditionalInfo())
+ "]<b>";
SearchResult<SNode> result = new SearchResult<SNode>(instance, category);
myMigrationBySearchResult.put(result, ref);
myResults.getSearchResults().add(result);
}
} catch (Throwable th) {
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("Failed to evaluate script applicability", th);
}
}
}
}
monitor.advance(1);
}
fireResultsChanged();
return myResults;
} finally {
monitor.done();
}
}
public void appendProblems(
SearchScope scope,
SearchResults<SNode> usages,
StringBuilder errors,
ProgressMonitor progressMonitor) {
List<SNode> myOverriding =
MethodRefactoringUtils.findOverridingMethods(scope, myMethod, progressMonitor);
errors.append(getOverridingErrors(myOverriding));
if (usages != null) {
for (SearchResult<SNode> res : ListSequence.fromList(usages.getSearchResults())) {
appendRefactoringProblems(res.getObject(), errors);
}
} else {
appendRefactoringProblems(myCall, errors);
}
}
