How to use

from

method

in

org.kframework.definition.DefinitionTransformer

public static Definition resolveIOStreams(KExceptionManager kem,Definition d) {
  return DefinitionTransformer.from(new ResolveIOStreams(d, kem)::resolve, "resolving io streams")
      .andThen(DefinitionTransformer.from(Kompile::filterStreamModules, "resolving io streams"))
      .apply(d);
}

/**
 * @param the generic {@link Kompile}
 * @return the special steps for the Java backend
 */
@Override
public Function<Definition, Definition> steps() {
  DefinitionTransformer convertDataStructureToLookup = DefinitionTransformer.fromSentenceTransformer((m, s) -> new ConvertDataStructureToLookup(m, false).convert(s), "convert data structures to lookups");
  return d -> DefinitionTransformer.fromRuleBodyTransformer(RewriteToTop::bubbleRewriteToTopInsideCells, "bubble out rewrites below cells")
      .andThen(DefinitionTransformer.fromSentenceTransformer(JavaBackend::convertListItemToNonFunction, "remove function attribute from ListItem production"))
      .andThen(DefinitionTransformer.fromSentenceTransformer(new NormalizeAssoc(KORE.c()), "normalize assoc"))
      .andThen(DefinitionTransformer.from(AddBottomSortForListsWithIdenticalLabels.singleton(), "add bottom sorts for lists"))
      .andThen(DefinitionTransformer.fromSentenceTransformer((m, s) -> new ExpandMacros(m, files, kompileOptions, false).expand(s), "expand macros"))
      .andThen(DefinitionTransformer.fromSentenceTransformer(new NormalizeAssoc(KORE.c()), "normalize assoc"))
      .andThen(convertDataStructureToLookup)
      .andThen(DefinitionTransformer.fromRuleBodyTransformer(JavaBackend::ADTKVariableToSortedVariable, "ADT.KVariable to SortedVariable"))
      .andThen(DefinitionTransformer.fromRuleBodyTransformer(JavaBackend::convertKSeqToKApply, "kseq to kapply"))
      .andThen(DefinitionTransformer.fromRuleBodyTransformer(NormalizeKSeq.self()::apply, "normalize kseq"))
      .andThen(JavaBackend::markRegularRules)
      .andThen(DefinitionTransformer.fromSentenceTransformer(new AddConfigurationRecoveryFlags(), "add refers_THIS_CONFIGURATION_marker"))
      .andThen(DefinitionTransformer.fromSentenceTransformer(JavaBackend::markSingleVariables, "mark single variables"))
      .andThen(DefinitionTransformer.from(new AssocCommToAssoc(), "convert AC matching to A matching"))
      .andThen(DefinitionTransformer.from(new MergeRules(), "merge rules into one rule with or clauses"))
      .apply(Kompile.defaultSteps(kompileOptions, kem, files).apply(d));
     // .andThen(KoreToMiniToKore::apply) // for serialization/deserialization test
}

public static Function<Definition, Definition> defaultSteps(KompileOptions kompileOptions, KExceptionManager kem, FileUtil files) {
  DefinitionTransformer resolveStrict = DefinitionTransformer.from(new ResolveStrict(kompileOptions)::resolve, "resolving strict and seqstrict attributes");
  DefinitionTransformer resolveHeatCoolAttribute = DefinitionTransformer.fromSentenceTransformer(new ResolveHeatCoolAttribute(new HashSet<>(kompileOptions.transition), EnumSet.of(HEAT_RESULT, COOL_RESULT_CONDITION, COOL_RESULT_INJECTION))::resolve, "resolving heat and cool attributes");
  DefinitionTransformer resolveAnonVars = DefinitionTransformer.fromSentenceTransformer(new ResolveAnonVar()::resolve, "resolving \"_\" vars");
  DefinitionTransformer resolveSemanticCasts =
      DefinitionTransformer.fromSentenceTransformer(new ResolveSemanticCasts(kompileOptions.backend.equals(Backends.JAVA))::resolve, "resolving semantic casts");
  DefinitionTransformer resolveFun = DefinitionTransformer.from(new ResolveFun()::resolve, "resolving #fun");
  DefinitionTransformer generateSortPredicateSyntax = DefinitionTransformer.from(new GenerateSortPredicateSyntax()::gen, "adding sort predicate productions");
  DefinitionTransformer generatedTopFormat = DefinitionTransformer.from(GeneratedTopFormat::resolve, "setting generatedTop format attribute");
  DefinitionTransformer subsortKItem = DefinitionTransformer.from(Kompile::subsortKItem, "subsort all sorts to KItem");
  GenerateCoverage cov = new GenerateCoverage(kompileOptions.coverage, files);
  DefinitionTransformer genCoverage = DefinitionTransformer.fromRuleBodyTransformerWithRule(cov::gen, "generate coverage instrumentation");

@Override
public Function<Definition, Definition> steps() {
  DefinitionTransformer resolveStrict = DefinitionTransformer.from(new ResolveStrict(kompileOptions)::resolve, "resolving strict and seqstrict attributes");
  DefinitionTransformer resolveHeatCoolAttribute = DefinitionTransformer.fromSentenceTransformer(new ResolveHeatCoolAttribute(new HashSet<>(kompileOptions.transition), heatCoolConditions)::resolve, "resolving heat and cool attributes");
  DefinitionTransformer resolveAnonVars = DefinitionTransformer.fromSentenceTransformer(new ResolveAnonVar()::resolve, "resolving \"_\" vars");
  DefinitionTransformer resolveSemanticCasts =
      DefinitionTransformer.fromSentenceTransformer(new ResolveSemanticCasts(true)::resolve, "resolving semantic casts");
  DefinitionTransformer resolveFun = DefinitionTransformer.from(new ResolveFun()::resolve, "resolving #fun");
  DefinitionTransformer generateSortPredicateSyntax = DefinitionTransformer.from(new GenerateSortPredicateSyntax()::gen, "adding sort predicate productions");
  DefinitionTransformer subsortKItem = DefinitionTransformer.from(Kompile::subsortKItem, "subsort all sorts to KItem");
  DefinitionTransformer expandMacros = DefinitionTransformer.fromSentenceTransformer((m, s) -> new ExpandMacros(m, files, kompileOptions, false).expand(s), "expand macros");
  Function1<Definition, Definition> resolveFreshConstants = d -> DefinitionTransformer.from(new ResolveFreshConstants(d, true)::resolve, "resolving !Var variables").apply(d);
  DefinitionTransformer generatedTopFormat = DefinitionTransformer.from(GeneratedTopFormat::resolve, "setting generatedTop format attribute");
  Function1<Definition, Definition> resolveIO = (d -> Kompile.resolveIOStreams(kem, d));

/**
 * Generates the module appropriate for generating the parser of a partial configuration,
 * with the exact cell labels not known apriori.
 */
public static Definition toGenericAbstractConfigurationParser(Definition d) {
  RuleGrammarGenerator rgg = new RuleGrammarGenerator(d);
  return DefinitionTransformer.from(rgg::getConfigGrammar, "toGenericAbstractConfigurationParser").apply(d);
}

/**
 * Generates the definition containing the modules appropriate for generating rule parsers.
 */
public static Definition toRuleParser(Definition d) {
  RuleGrammarGenerator rgg = new RuleGrammarGenerator(d);
  return DefinitionTransformer.from(rgg::getRuleGrammar, "toRuleParser").apply(d);
}

public static Definition resolveFreshConstants(Definition input) {
  return DefinitionTransformer.from(new ResolveFreshConstants(input, false)::resolve, "resolving !Var variables")
      .apply(input);
}

public static Function1<Definition, Definition> excludeModulesByTag(Set<String> excludedModuleTags) {
  DefinitionTransformer dt = DefinitionTransformer.from(mod -> excludeModulesByTag(excludedModuleTags, mod), "remove modules based on attributes");
  return dt.andThen(d -> Definition(d.mainModule(), immutable(stream(d.entryModules()).filter(mod -> excludedModuleTags.stream().noneMatch(tag -> mod.att().contains(tag))).collect(Collectors.toSet())), d.att()));
}

  definitionWithConfigBubble = DefinitionTransformer.from(mod -> {
    if (mod == definition.mainModule()) {
      java.util.Set<Module> imports = mutable(mod.imports());
  Definition defWithConfig = DefinitionTransformer.from(resolveConfig::apply, "parsing configurations").apply(definitionWithConfigBubble);
  return defWithConfig;
} catch (KEMException e) {

  def = DefinitionTransformer.from(resolveConfig::apply, "parse config bubbles").apply(def);
} catch (KEMException e) {
  errors.add(e);

public Definition resolveNonConfigBubbles(Definition defWithConfig, RuleGrammarGenerator gen) {
  Module ruleParserModule = gen.getRuleGrammar(defWithConfig.mainModule());
  ParseCache cache = loadCache(ruleParserModule);
  ParseInModule parser = RuleGrammarGenerator.getCombinedGrammar(cache.getModule(), isStrict);
  try (Scanner scanner = parser.getScanner()) {
    return DefinitionTransformer.from(m -> this.resolveNonConfigBubbles(m, scanner, gen), "parsing rules").apply(defWithConfig);
  }
}