コード例 #1
0
ファイル: UsagesSearchType.java プロジェクト: JetBrains/MPS
  @Override
  public Set<SReference> search(
      Set<SNode> nodes, @NotNull SearchScope scope, @NotNull ProgressMonitor monitor) {
    final HashSet<SReference> rv = new HashSet<SReference>();
    CollectConsumer<SReference> consumer = new CollectConsumer<SReference>(rv);
    Collection<FindUsagesParticipant> participants =
        PersistenceRegistry.getInstance().getFindUsagesParticipants();

    monitor.start("Finding usages...", participants.size() + 4);
    try {
      Collection<SModel> current = new LinkedHashSet<SModel>();
      Collection<SModel> simpleSearch = new LinkedHashSet<SModel>();
      for (SModel m : IterableUtil.asCollection(scope.getModels())) {
        if (m instanceof EditableSModel && ((EditableSModel) m).isChanged()) {
          simpleSearch.add(m);
        } else {
          current.add(m);
        }
      }

      for (FindUsagesParticipant participant : participants) {
        final Set<SModel> next = new HashSet<SModel>(current);
        participant.findUsages(
            current,
            nodes,
            consumer,
            new Consumer<SModel>() {
              @Override
              public void consume(SModel sModel) {
                assert !(sModel instanceof EditableSModel && ((EditableSModel) sModel).isChanged());
                next.remove(sModel);
              }
            });
        current = next;
        monitor.advance(1);
      }

      ProgressMonitor subMonitor = monitor.subTask(4, SubProgressKind.DEFAULT);
      subMonitor.start("", current.size() + simpleSearch.size());
      NodeUsageFinder nf = new NodeUsageFinder(nodes, consumer);
      showNoFastFindTipIfNeeded(current);
      current.addAll(simpleSearch);
      for (SModel m : current) {
        subMonitor.step(m.getModelName());
        nf.collectUsages(m);
        if (monitor.isCanceled()) {
          break;
        }
        subMonitor.advance(1);
      }
      subMonitor.done();
    } finally {
      monitor.done();
    }
    return rv;
  }
コード例 #2
0
 public static boolean findInModule(SModule module, String modelName, String rootName) {
   for (SModel d : module.getModels()) {
     if (d.getModelName().equals(modelName)) {
       for (SNode _n : d.getRootNodes()) {
         SNode n = (SNode) _n;
         if (SNodeOperations.isInstanceOf(n, "jetbrains.mps.baseLanguage.structure.Classifier")
             && SPropertyOperations.getString(
                     SNodeOperations.cast(n, "jetbrains.mps.baseLanguage.structure.Classifier"),
                     "name")
                 .equals(rootName)) {
           return true;
         }
       }
     }
   }
   return false;
 }
コード例 #3
0
  @Override
  public Set<SReference> search(
      Set<SNode> nodes, SearchScope scope, @NotNull ProgressMonitor monitor) {
    CollectConsumer<SReference> consumer = new CollectConsumer(new HashSet<SReference>());
    Collection<FindUsagesParticipant> participants =
        FastFindUsagesRegistry.getInstance().getParticipants();

    monitor.start("Finding usages...", participants.size() + 4);
    try {
      Collection<SModel> current = IterableUtil.asCollection(scope.getModels());
      for (FindUsagesParticipant participant : participants) {
        final Set<SModel> next = new HashSet<SModel>(current);
        participant.findUsages(
            current,
            nodes,
            consumer,
            new Consumer<SModel>() {
              @Override
              public void consume(SModel sModel) {
                next.remove(sModel);
              }
            });
        current = next;
        monitor.advance(1);
      }

      ProgressMonitor subMonitor = monitor.subTask(4, SubProgressKind.DEFAULT);
      subMonitor.start("", current.size());
      for (SModel m : current) {
        subMonitor.step(m.getModelName());
        FindUsagesManager.collectUsages(m, nodes, consumer);
        if (monitor.isCanceled()) break;
        subMonitor.advance(1);
      }
      subMonitor.done();
    } finally {
      monitor.done();
    }
    return (Set<SReference>) consumer.getResult();
  }
コード例 #4
0
  public int getModelKind(SModel model, @Nullable SReference reference) {
    DataSource source = (model != null ? model.getSource() : null);
    IFile modelFile =
        (source instanceof FileDataSource ? ((FileDataSource) source).getFile() : null);
    if (modelFile != null) {
      String filePath = modelFile.getAbsolutePath().replace('\\', '/');
      if (filePath.startsWith(languagesUtilPath)) {
        return OTHER;
      }
    }

    SModule module = model.getModule();
    if (module instanceof Language) {
      LanguageAspect aspect = Language.getModelAspect(model);
      if (aspect != null) {
        switch (aspect) {
          case ACTIONS:
            return EDITOR;
          case BEHAVIOR:
            return CORE;
          case CONSTRAINTS:
            return CORE;
          case DATA_FLOW:
            return CORE;
          case EDITOR:
            return EDITOR;
          case FIND_USAGES:
            return CORE;
          case INTENTIONS:
            return EDITOR;
          case PLUGIN:
            return WORKBENCH;
          case REFACTORINGS:
            return CORE;
          case SCRIPTS:
            return CORE;
          case STRUCTURE:
            return CORE;
          case STUBS:
            return CORE;
          case TEST:
            return EDITOR;
          case TEXT_GEN:
            return CORE;
          case TYPESYSTEM:
            return CORE;
          default:
        }
      }
      return CORE;

    } else if (module instanceof Solution) {

      String moduleFqName = module.getModuleName();
      if (moduleFqName.equals("JDK")) {
        return CORE;
      }
      if (moduleFqName.equals("MPS.Core")) {
        return CORE;
      }
      if (moduleFqName.equals("MPS.Editor")) {
        return EDITOR;
      }
      if (moduleFqName.equals("MPS.Workbench")) {
        return WORKBENCH;
      }
      if (moduleFqName.equals("MPS.Classpath")) {
        SNode refTargetRoot = reference.getTargetNode().getContainingRoot();
        if (SNodeOperations.isInstanceOf(
            refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier")) {
          String cName =
              SPropertyOperations.getString(
                  SNodeOperations.cast(
                      refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier"),
                  "name");
          String modelName = model.getModelName();
          if (findInModule(coreModule, modelName, cName)) {
            return CORE;
          }
          if (findInModule(editorModule, modelName, cName)) {
            return EDITOR;
          }
          return WORKBENCH;
        }
        return OTHER;
      }

      Solution sol = (Solution) module;
      switch (sol.getKind()) {
        case NONE:
          return OTHER;
        case PLUGIN_CORE:
          return CORE;
        case PLUGIN_EDITOR:
          return EDITOR;
        case PLUGIN_OTHER:
          return WORKBENCH;
        default:
      }
    }
    return OTHER;
  }