TestsErrorsChecker.java

package jetbrains.mps.lang.test.runtime;

/*Generated by MPS */

import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.errors.IErrorReporter;
import jetbrains.mps.smodel.event.SModelCommandListener;
import java.util.List;
import jetbrains.mps.smodel.event.SModelEvent;
import jetbrains.mps.smodel.GlobalSModelEventsManager;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.errors.MessageStatus;
import java.util.Set;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.HashSet;
import jetbrains.mps.internal.collections.runtime.Sequence;
import jetbrains.mps.internal.collections.runtime.IWhereFilter;
import jetbrains.mps.checkers.TypesystemChecker;
import jetbrains.mps.checkers.AbstractConstraintsCheckerRootCheckerAdapter;
import jetbrains.mps.checkers.ConstraintsChecker;
import jetbrains.mps.checkers.RefScopeChecker;
import jetbrains.mps.checkers.TargetConceptChecker;
import jetbrains.mps.project.validation.ValidationUtil;
import org.jetbrains.mps.openapi.util.Processor;
import jetbrains.mps.project.validation.ValidationProblem;
import jetbrains.mps.project.validation.NodeValidationProblem;
import jetbrains.mps.errors.SimpleErrorReporter;
import jetbrains.mps.checkers.ErrorReportUtil;
import org.jetbrains.annotations.Nullable;

/**
 * 
 * @deprecated needs to be united with the common model checking logic. Here we have the second cache of the same things.
 */
@Deprecated
public class TestsErrorsChecker {
  private static final Logger LOG = LogManager.getLogger(TestsErrorsChecker.class);
  private SNode myRoot;

  /**
   * contains cached warnings and errors for the current root
   */
  private static TestsErrorsChecker.ModelErrorsHolder<IErrorReporter> ourModelErrorsHolder = new TestsErrorsChecker.ModelErrorsHolder<IErrorReporter>();

  /**
   * clears our cache on any model change
   */
  private static SModelCommandListener ourModelChangesListener;

  private static void initModelListener() {
    if (ourModelChangesListener == null) {
      ourModelChangesListener = new SModelCommandListener() {
        public void eventsHappenedInCommand(List<SModelEvent> events) {
          if (!(events.isEmpty())) {
            ourModelErrorsHolder = new TestsErrorsChecker.ModelErrorsHolder();
          }
        }
      };
      GlobalSModelEventsManager.getInstance().addGlobalCommandListener(ourModelChangesListener);
    }
  }

  static {
    initModelListener();
  }

  @Deprecated
  public TestsErrorsChecker(SNode root) {
    assert root == SNodeOperations.getContainingRoot(root);
    myRoot = root;
  }

  public Iterable<IErrorReporter> getAllErrors() {
    return getRootErrors();
  }

  public Iterable<IErrorReporter> getErrors(@NotNull SNode node) {
    Iterable<IErrorReporter> result = getRootErrors();
    return filterReportersByNode(result, node);
  }

  public Iterable<IErrorReporter> getErrorsSpecificType(SNode node, final MessageStatus errorType) {
    Set<IErrorReporter> result = SetSequence.fromSet(new HashSet<IErrorReporter>());
    SetSequence.fromSet(result).addSequence(Sequence.fromIterable(getErrors(node)).where(new IWhereFilter<IErrorReporter>() {
      public boolean accept(IErrorReporter it) {
        return it.getMessageStatus() == errorType;
      }
    }));
    return result;
  }

  private Iterable<IErrorReporter> filterReportersByNode(final Iterable<IErrorReporter> errors, @NotNull final SNode aNode) {
    return Sequence.fromIterable(errors).where(new IWhereFilter<IErrorReporter>() {
      public boolean accept(IErrorReporter it) {
        assert it.getSNode() != null;
        return it.getSNode().getNodeId().equals(aNode.getNodeId());
      }
    });
  }

  private Iterable<IErrorReporter> getRootErrors() {
    Set<IErrorReporter> cachedErrors = TestsErrorsChecker.ourModelErrorsHolder.get(myRoot);
    if (cachedErrors != null) {
      return SetSequence.fromSet(cachedErrors).toListSequence();
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("Collecting errors in the root " + myRoot);
    }
    final Set<IErrorReporter> result = SetSequence.fromSet(new HashSet<IErrorReporter>());
    SetSequence.fromSet(result).addSequence(SetSequence.fromSet(new TypesystemChecker().getErrors(myRoot, null)));
    // todo: add UsedLanguageChecker 
    SetSequence.fromSet(result).addSequence(SetSequence.fromSet(new AbstractConstraintsCheckerRootCheckerAdapter(AbstractConstraintsCheckerRootCheckerAdapter.SKIP_CONSTRAINTS_CONDITION, new ConstraintsChecker(), new RefScopeChecker(), new TargetConceptChecker()).getErrors(myRoot, null)));
    ValidationUtil.validateModelContent(Sequence.<SNode>singleton(myRoot), new Processor<ValidationProblem>() {
      public boolean process(ValidationProblem vp) {
        if (!((vp instanceof NodeValidationProblem))) {
          return true;
        }
        SNode node = ((NodeValidationProblem) vp).getNode();
        SetSequence.fromSet(result).addElement(new SimpleErrorReporter(node, vp.getMessage(), null, null));
        return true;
      }
    });

    Set<IErrorReporter> res = SetSequence.fromSetWithValues(new HashSet<IErrorReporter>(), SetSequence.fromSet(result).where(new IWhereFilter<IErrorReporter>() {
      public boolean accept(IErrorReporter it) {
        return !(ErrorReportUtil.manuallySuppressed(it.getSNode()));
      }
    }));
    TestsErrorsChecker.ourModelErrorsHolder.set(myRoot, res);
    return res;
  }

  private static class ModelErrorsHolder<T> {
    private Set<T> myCachedErrors;
    private SNode myRoot;

    @Nullable
    public Set<T> get(SNode root) {
      if (myCachedErrors != null && sameRoot(root)) {
        return myCachedErrors;
      }
      return null;
    }

    private boolean sameRoot(SNode root) {
      return root == myRoot;
    }

    public void set(SNode root, Set<T> errors) {
      myRoot = root;
      myCachedErrors = SetSequence.fromSet(new HashSet<T>());
      SetSequence.fromSet(myCachedErrors).addSequence(SetSequence.fromSet(errors));
    }
  }
}