Transformation pass to remove all empty relations and rules that use empty relations. More...

#include <RemoveEmptyRelations.h>

Inheritance diagram for souffle::ast::transform::RemoveEmptyRelationsTransformer:

Collaboration diagram for souffle::ast::transform::RemoveEmptyRelationsTransformer:

Public Member Functions
RemoveEmptyRelationsTransformer *	clone () const override

std::string	getName () const override

Public Member Functions inherited from souffle::ast::transform::Transformer
bool	apply (TranslationUnit &translationUnit)

virtual	~Transformer ()=default

Static Public Member Functions
static bool	removeEmptyRelations (TranslationUnit &translationUnit)
	Eliminate all empty relations (and their uses) in the given program. More...

Private Member Functions
bool	transform (TranslationUnit &translationUnit) override

Static Private Member Functions
static bool	removeEmptyRelationUses (TranslationUnit &translationUnit, const QualifiedName &emptyRelation)
	Eliminate rules that contain empty relations and/or rewrite them. More...

Detailed Description

Transformation pass to remove all empty relations and rules that use empty relations.

Definition at line 31 of file RemoveEmptyRelations.h.

Member Function Documentation

◆ clone()

RemoveEmptyRelationsTransformer* souffle::ast::transform::RemoveEmptyRelationsTransformer::clone ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 49 of file RemoveEmptyRelations.h.

◆ getName()

std::string souffle::ast::transform::RemoveEmptyRelationsTransformer::getName ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 37 of file RemoveEmptyRelations.h.

41 {

◆ removeEmptyRelations()

bool souffle::ast::transform::RemoveEmptyRelationsTransformer::removeEmptyRelations ( TranslationUnit & translationUnit )

static

Eliminate all empty relations (and their uses) in the given program.

Parameters

translationUnit the program to be processed

Returns: whether the program was modified

Definition at line 40 of file RemoveEmptyRelations.cpp.

                   : program.getRelations()) {
         if (!getClauses(program, *rel).empty() || ioTypes->isInput(rel)) {
             continue;
         }
         emptyRelations.insert(rel->getQualifiedName());
  
         bool usedInAggregate = false;
         visitDepthFirst(program, [&](const Aggregator& agg) {
             for (const auto lit : agg.getBodyLiterals()) {
                 visitDepthFirst(*lit, [&](const Atom& atom) {
                     if (getAtomRelation(&atom, &program) == rel) {
                         usedInAggregate = true;
                     }
                 });
             }
         });
  
         if (!usedInAggregate && !ioTypes->isOutput(rel)) {
             removeRelation(translationUnit, rel->getQualifiedName());
             changed = true;
         }
     }
  
     for (const auto& relName : emptyRelations) {
         changed |= removeEmptyRelationUses(translationUnit, relName);
     }
  
     return changed;
 }
  
 bool RemoveEmptyRelationsTransformer::removeEmptyRelationUses(
         TranslationUnit& translationUnit, const QualifiedName& emptyRelationName) {
     Program& program = translationUnit.getProgram();

References souffle::ast::Aggregator::getBodyLiterals(), souffle::ast::getClauses(), rel(), and souffle::ast::visitDepthFirst().

Here is the call graph for this function:

◆ removeEmptyRelationUses()

bool souffle::ast::transform::RemoveEmptyRelationsTransformer::removeEmptyRelationUses	(	TranslationUnit &	translationUnit,
		const QualifiedName &	emptyRelation
	)

staticprivate

Eliminate rules that contain empty relations and/or rewrite them.

Parameters

translationUnit	the program to be processed
emptyRelation	relation that is empty

Returns: whether the program was modified

Definition at line 75 of file RemoveEmptyRelations.cpp.

                                                     { clauses.push_back(&cur); });
  
     // clean all clauses
     for (const Clause* cl : clauses) {
         // check for an atom whose relation is the empty relation
  
         bool removed = false;
         for (Literal* lit : cl->getBodyLiterals()) {
             if (auto* arg = dynamic_cast<Atom*>(lit)) {
                 if (arg->getQualifiedName() == emptyRelationName) {
                     program.removeClause(cl);
                     removed = true;
                     changed = true;
                     break;
                 }
             }
         }
  
         if (!removed) {
             // check whether a negation with empty relations exists
  
             bool rewrite = false;
             for (Literal* lit : cl->getBodyLiterals()) {
                 if (auto* neg = dynamic_cast<Negation*>(lit)) {
                     if (neg->getAtom()->getQualifiedName() == emptyRelationName) {
                         rewrite = true;
                         break;
                     }
                 }
             }
  
             if (rewrite) {
                 // clone clause without negation for empty relations
  
                 auto res = Own<Clause>(cloneHead(cl));
  
                 for (Literal* lit : cl->getBodyLiterals()) {
                     if (auto* neg = dynamic_cast<Negation*>(lit)) {
                         if (neg->getAtom()->getQualifiedName() != emptyRelationName) {
                             res->addToBody(souffle::clone(lit));
                         }
                     } else {
                         res->addToBody(souffle::clone(lit));
                     }
                 }
  
                 program.removeClause(cl);
                 program.addClause(std::move(res));
                 changed = true;
             }
         }
     }
  
     return changed;
 }
  
 }  // namespace souffle::ast::transform