Transformer resolving aliases for anonymous records. More...

#include <ResolveAnonymousRecordAliases.h>

Inheritance diagram for souffle::ast::transform::ResolveAnonymousRecordAliasesTransformer:

Collaboration diagram for souffle::ast::transform::ResolveAnonymousRecordAliasesTransformer:

Public Member Functions
ResolveAnonymousRecordAliasesTransformer *	clone () const override

std::string	getName () const override

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

virtual	~Transformer ()=default

Private Member Functions
std::map< std::string, const RecordInit * >	findVariablesRecordMapping (TranslationUnit &, const Clause &)
	For each variable equal to some anonymous record, assign a value of that record. More...

bool	replaceNamedVariables (TranslationUnit &, Clause &)
	Use mapping found by findVariablesRecordMapping to substitute a records for each variable that operates on records. More...

bool	replaceUnnamedVariable (Clause &)
	For unnamed variables, replace each equation _ op record with true. More...

bool	transform (TranslationUnit &translationUnit) override

Detailed Description

Transformer resolving aliases for anonymous records.

The transformer works by searching the clause for equalities of the form a = [...], where a is an anonymous record, and replacing all occurrences of a with the RHS.

The transformer is to be called in conjunction with FoldAnonymousRecords.

Definition at line 39 of file ResolveAnonymousRecordAliases.h.

Member Function Documentation

◆ clone()

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

inlineoverridevirtual

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

Definition at line 49 of file ResolveAnonymousRecordAliases.h.

◆ findVariablesRecordMapping()

std::map< std::string, const RecordInit * > souffle::ast::transform::ResolveAnonymousRecordAliasesTransformer::findVariablesRecordMapping	(	TranslationUnit &	tu,
		const Clause &	clause
	)

private

For each variable equal to some anonymous record, assign a value of that record.

Definition at line 44 of file ResolveAnonymousRecordAliases.cpp.

                                              { return isA<ast::Variable>(node); };
     auto isRecord = [](Node* node) -> bool { return isA<RecordInit>(node); };
  
     auto& typeAnalysis = *tu.getAnalysis<analysis::TypeAnalysis>();
     auto groundedTerms = analysis::getGroundedTerms(tu, clause);
  
     for (auto* literal : clause.getBodyLiterals()) {
         if (auto constraint = dynamic_cast<BinaryConstraint*>(literal)) {
             if (!isEqConstraint(constraint->getBaseOperator())) {
                 continue;
             }
  
             auto left = constraint->getLHS();
             auto right = constraint->getRHS();
  
             if (!isVariable(left) && !isVariable(right)) {
                 continue;
             }
  
             if (!isRecord(left) && !isRecord(right)) {
                 continue;
             }
  
             // TODO (darth_tytus): This should change in the future.
             // Currently type system assigns to anonymous records {- All types - }
             // which is inelegant.
             if (!typeAnalysis.getTypes(left).isAll()) {
                 continue;
             }
  
             auto* variable = static_cast<ast::Variable*>(isVariable(left) ? left : right);
             const auto& variableName = variable->getName();
  
             if (!groundedTerms.find(variable)->second) {
                 continue;
             }
  
             // We are interested only in the first mapping.
             if (variableRecordMap.find(variableName) != variableRecordMap.end()) {
                 continue;
             }
  
             auto* record = static_cast<RecordInit*>(isRecord(left) ? left : right);
  
             variableRecordMap.insert({variableName, record});
         }
     }
  
     return variableRecordMap;
 }
  
 bool ResolveAnonymousRecordAliasesTransformer::replaceNamedVariables(TranslationUnit& tu, Clause& clause) {
     struct ReplaceVariables : public NodeMapper {
         std::map<std::string, const RecordInit*> varToRecordMap;

◆ getName()

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

inlineoverridevirtual

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

Definition at line 45 of file ResolveAnonymousRecordAliases.h.

        :
     bool transform(TranslationUnit& translationUnit) override;
  

◆ replaceNamedVariables()

bool souffle::ast::transform::ResolveAnonymousRecordAliasesTransformer::replaceNamedVariables	(	TranslationUnit &	tu,
		Clause &	clause
	)

private

Use mapping found by findVariablesRecordMapping to substitute a records for each variable that operates on records.

Definition at line 99 of file ResolveAnonymousRecordAliases.cpp.

                 : varToRecordMap(std::move(varToRecordMap)){};
  
         Own<Node> operator()(Own<Node> node) const override {
             if (auto variable = dynamic_cast<ast::Variable*>(node.get())) {
                 auto iteratorToRecord = varToRecordMap.find(variable->getName());
                 if (iteratorToRecord != varToRecordMap.end()) {
                     return souffle::clone(iteratorToRecord->second);
                 }
             }
  
             node->apply(*this);
  
             return node;
         }
     };
  
     auto variableToRecordMap = findVariablesRecordMapping(tu, clause);
     bool changed = variableToRecordMap.size() > 0;
     if (changed) {
         ReplaceVariables update(std::move(variableToRecordMap));
         clause.apply(update);
     }
     return changed;
 }
  
 bool ResolveAnonymousRecordAliasesTransformer::replaceUnnamedVariable(Clause& clause) {
     struct ReplaceUnnamed : public NodeMapper {
         mutable bool changed{false};

◆ replaceUnnamedVariable()

bool souffle::ast::transform::ResolveAnonymousRecordAliasesTransformer::replaceUnnamedVariable ( Clause & clause )

private

For unnamed variables, replace each equation _ op record with true.

Definition at line 129 of file ResolveAnonymousRecordAliases.cpp.

                                                             {
             auto isUnnamed = [](Node* node) -> bool { return isA<UnnamedVariable>(node); };
             auto isRecord = [](Node* node) -> bool { return isA<RecordInit>(node); };
  
             if (auto constraint = dynamic_cast<BinaryConstraint*>(node.get())) {
                 auto left = constraint->getLHS();
                 auto right = constraint->getRHS();
                 bool hasUnnamed = isUnnamed(left) || isUnnamed(right);
                 bool hasRecord = isRecord(left) || isRecord(right);
                 auto op = constraint->getBaseOperator();
                 if (hasUnnamed && hasRecord && isEqConstraint(op)) {
                     return mk<BooleanConstraint>(true);
                 }
             }
  
             node->apply(*this);
  
             return node;
         }
     };
  
     ReplaceUnnamed update;
     clause.apply(update);
  
     return update.changed;
 }
  
 bool ResolveAnonymousRecordAliasesTransformer::transform(TranslationUnit& translationUnit) {
     bool changed = false;
     Program& program = translationUnit.getProgram();