private boolean incrementalDecision(final int owner,
                                      final Proto member,
                                      final Collection<? super File> affectedFiles,
                                      final Collection<? extends File> currentlyCompiled,
                                      final @Nullable DependentFilesFilter filter) {
    final Util self = new Util();
    final int classname = member instanceof ClassRepr? member.name : owner;

    // Public branch --- hopeless
    if (member.isPublic()) {
      debug("Public access, switching to a non-incremental mode");
      return false;
    }

    final Set<File> toRecompile = FileCollectionFactory.createCanonicalFileSet();

    // Protected branch
    if (member.isProtected()) {
      debug("Protected access, softening non-incremental decision: adding all relevant subclasses for a recompilation");
      debug("Root class: ", classname);

      final IntSet propagated;
      if (member instanceof FieldRepr) {
        propagated = self.propagateFieldAccess(member.name, classname);
      }
      else {
        propagated = getAllSubclasses(classname);
        propagated.remove(classname);
      }
      propagated.forEach(className -> {
        final Iterable<File> fileNames = classToSourceFileGet(className);
        if (fileNames != null) {
          if (myDebugS.isDebugEnabled()) {
            for (File fileName : fileNames) {
              debug("Adding ", fileName);
            }
          }
          ContainerUtil.addAll(toRecompile, fileNames);
        }
      });
    }

    final String cName = myContext.getValue(classname);
    if (cName != null) {
      final String packageName = ClassRepr.getPackageName(cName);

      debug("Softening non-incremental decision: adding all package classes for a recompilation");
      debug("Package name: ", packageName);

      // Package-local branch
      myClassToRelativeSourceFilePath.forEachEntry((relFilePaths, value) -> {
        final String clsName = myContext.getValue(value);
        if (clsName != null && ClassRepr.getPackageName(clsName).equals(packageName)) {
          for (String rel : relFilePaths) {
            File file = toFull(rel);
            if (filter == null || filter.accept(file)) {
              debug("Adding: ", rel);
              toRecompile.add(file);
            }
          }
        }
      });
    }

    // filtering already compiled and non-existing paths
    toRecompile.removeAll(currentlyCompiled);
    for (Iterator<File> it = toRecompile.iterator(); it.hasNext(); ) {
      final File file = it.next();
      if (!file.exists()) {
        it.remove();
      }
    }

    affectedFiles.addAll(toRecompile);

    return true;
  }
private boolean incrementalDecision(final int owner,
                                      final Proto member,
                                      final Collection<? super File> affectedFiles,
                                      final Collection<? extends File> currentlyCompiled,
                                      final @Nullable DependentFilesFilter filter)