How to use

concretize

method

in

org.kframework.compile.AddParentCells

K concretize(K term) {
  if (term instanceof KApply) {
    KApply app = (KApply) term;
    KApply newTerm = KApply(app.klabel(), KList(app.klist().stream()
        .map(this::concretize).collect(Collectors.toList())));
    if (cfg.isParentCell(newTerm.klabel())) {
      return concretizeCell(newTerm);
    } else {
      return newTerm;
    }
  } else if (term instanceof KRewrite) {
    KRewrite rew = (KRewrite) term;
    return KRewrite(concretize(rew.left()), concretize(rew.right()));
  } else if (term instanceof KSequence) {
    return KSequence(((KSequence) term).stream()
        .map(this::concretize).collect(Collectors.toList()));
  } else {
    return term;
  }
}

  public Sentence concretize(Sentence m) {
    if (m instanceof Rule) {
      Rule r = (Rule) m;
      return new Rule(concretize(r.body()), r.requires(), r.ensures(), r.att());
    } else if (m instanceof Context) {
      Context c = (Context) m;
      return new Context(concretize(c.body()), c.requires(), c.att());
    } else {
      return m;
    }
  }
}

  public Sentence concretize(Sentence s) {
    s = addRootCell.addImplicitCells(s);
    s = addParentCells.concretize(s);
    s = closeCells.close(s);

    s = sortCells.preprocess(s);
    s = sortCells.sortCells(s);
    s = sortCells.postprocess(s);
    return s;
  }
}

@Test
public void testNonCellItemRewrite() {
  K term = cell("<T>", KRewrite(KApply(KLabel("label")),cells(KApply(KLabel(".K")), cell("<k>",KVariable("X")))));
  exception.expect(KEMException.class);
  exception.expectMessage("Can't mix items with different parent cells under a rewrite");
  pass.concretize(term);
}

@Test
public void testNonCellItem() {
  K term = cell("<T>", KApply(KLabel(".K")), cell("<k>",KVariable("X")));
  K expected = cell("<T>",cells(KApply(KLabel(".K")), cell("<ts>", cell("<t>", cell("<k>", KVariable("X"))))));
  Assert.assertEquals(expected, pass.concretize(term));
}

@Test
public void testLeafContent() {
  K term = cell("<T>", cell("<k>",
      KSequence(KApply(KLabel("_+_"), KVariable("I"), KVariable("J")),
          KVariable("Rest"))));
  K expected = cell("<T>", cell("<ts>", cell("<t>", cell("<k>",
      KSequence(KApply(KLabel("_+_"), KVariable("I"), KVariable("J")),
          KVariable("Rest"))))));
  Assert.assertEquals(expected, pass.concretize(term));
}

@Test
public void testNestedCompletion() {
  K term = cell("<T>",
      cell("<t>", cell("<msg>", intToToken(0)), cell("<msgId>", intToToken(1))),
      cell("<k>", intToToken(2)),
      cell("<env>", intToToken(3)),
      cell("<msgId>", intToToken(4)),
      cell("<msgId>", intToToken(5)),
      cell("<t>", cell("<k>", intToToken(6))));
  K expected = cell("<T>",cell("<ts>",
      cell("<t>", cell("<msg>", intToToken(0)), cell("<msg>", cell("<msgId>", intToToken(1)))),
      cell("<t>", cell("<k>", intToToken(6))),
      cell("<t>", cell("<k>", intToToken(2)), cell("<env>", intToToken(3)),
        cell("<msg>", cell("<msgId>", intToToken(4))),
        cell("<msg>", cell("<msgId>", intToToken(5))))
      ));
  Assert.assertEquals(expected, pass.concretize(term));
}