Style and include fixes

src/AnalysisType.h

@@ -18,8 +18,15 @@
 
 #include "AstType.h"
 #include "Util.h"
+#include <algorithm>
 #include <cassert>
+#include <memory>
+#include <set>
 #include <sstream>
+#include <string>
+#include <typeinfo>
+#include <utility>
+#include <vector>
 
 namespace souffle {
 
@@ -151,7 +158,7 @@ class InnerAnalysisType : public AnalysisType {
     // each inner type belongs to a separate sublattice, depending on the kind
     virtual Kind getKind() const = 0;
 
-    virtual InnerAnalysisType* clone() const = 0;
+    InnerAnalysisType* clone() const override = 0;
 };
 
 /** A top primitive in a lattice, just below the top element */
@@ -289,7 +296,7 @@ class BottomPrimitiveAnalysisType : public InnerAnalysisType {
 /** A base type in the lattice, just above the bottom primitives */
 class BaseAnalysisType : public InnerAnalysisType {
 public:
-    BaseAnalysisType(Kind kind, AstTypeIdentifier name) : kind(kind), name(name) {}
+    BaseAnalysisType(Kind kind, AstTypeIdentifier name) : kind(kind), name(std::move(name)) {}
     BaseAnalysisType(const BaseAnalysisType&) = default;
     BaseAnalysisType(BaseAnalysisType&&) = default;
 

src/AstArgument.h

@@ -478,7 +478,7 @@ class AstRecordInit : public AstArgument {
 public:
     AstRecordInit() = default;
 
-    AstRecordInit(const AstTypeIdentifier& type) : type(type) {}
+    AstRecordInit(AstTypeIdentifier type) : type(std::move(type)) {}
 
     ~AstRecordInit() override = default;
 

src/AstGroundAnalysis.cpp

@@ -19,6 +19,7 @@
 #include "AstClause.h"
 #include "AstConstraintAnalysis.h"
 #include "AstLiteral.h"
+#include "AstNode.h"
 #include "BinaryConstraintOps.h"
 #include "Constraints.h"
 #include "Util.h"

src/AstIOTypeAnalysis.cpp

@@ -16,9 +16,12 @@
 
 #include "AstIOTypeAnalysis.h"
 #include "AstIO.h"
+#include "AstProgram.h"
 #include "AstRelation.h"
 #include "AstTranslationUnit.h"
 #include "AstVisitor.h"
+#include "Util.h"
+#include <ostream>
 
 namespace souffle {
 

src/AstNode.h

@@ -20,12 +20,12 @@
 #include "SrcLocation.h"
 #include "Util.h"
 
+#include <cstddef>
+#include <cstring>
 #include <limits>
 #include <memory>
 #include <typeinfo>
 
-#include <cstddef>
-#include <cstring>
 #include <libgen.h>
 #include <unistd.h>
 

src/AstProfileUse.h

@@ -26,6 +26,8 @@
 
 namespace souffle {
 
+class AstTranslationUnit;
+
 /**
  * AstAnalysis that loads profile data and has a profile query interface.
  */

src/AstProgram.h

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "AstClause.h"
 #include "AstComponent.h"
 #include "AstFunctorDeclaration.h"
 #include "AstIO.h"
@@ -37,12 +38,6 @@
 
 namespace souffle {
 
-class AstClause;
-class AstLoad;
-class AstPrintSize;
-class AstStore;
-class AstRelation;
-
 /**
  *  Intermediate representation of a datalog program
  *          that consists of relations, clauses and types

src/AstSemanticChecker.cpp

@@ -15,12 +15,14 @@
  ***********************************************************************/
 
 #include "AstSemanticChecker.h"
+#include "AnalysisType.h"
 #include "AstArgument.h"
 #include "AstAttribute.h"
 #include "AstClause.h"
 #include "AstFunctorDeclaration.h"
 #include "AstGroundAnalysis.h"
 #include "AstIO.h"
+#include "AstIOTypeAnalysis.h"
 #include "AstLiteral.h"
 #include "AstNode.h"
 #include "AstProgram.h"
@@ -46,6 +48,7 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <functional>
 #include <iostream>
 #include <map>
 #include <memory>

src/AstSemanticChecker.h

@@ -16,13 +16,12 @@
 
 #pragma once
 
+#include "AstArgument.h"
 #include "AstTransformer.h"
 #include <string>
 
 namespace souffle {
 
-class AstAggregator;
-class AstArgument;
 class AstAtom;
 class AstClause;
 class AstLiteral;

src/AstTransforms.cpp

@@ -15,23 +15,24 @@
  ***********************************************************************/
 
 #include "AstTransforms.h"
+#include "AnalysisType.h"
 #include "AstAttribute.h"
 #include "AstClause.h"
+#include "AstIOTypeAnalysis.h"
 #include "AstLiteral.h"
 #include "AstNode.h"
 #include "AstProgram.h"
 #include "AstRelation.h"
 #include "AstRelationIdentifier.h"
+#include "AstTranslationUnit.h"
 #include "AstTypeAnalysis.h"
-#include "AstTypeEnvironmentAnalysis.h"
 #include "AstTypes.h"
 #include "AstUtils.h"
 #include "AstVisitor.h"
 #include "BinaryConstraintOps.h"
 #include "GraphUtils.h"
 #include "PrecedenceGraph.h"
-#include "TypeLattice.h"
-#include "TypeSystem.h"
+#include <cassert>
 #include <cstddef>
 #include <functional>
 #include <map>
@@ -41,6 +42,8 @@
 
 namespace souffle {
 
+class TypeLattice;
+
 bool NullTransformer::transform(AstTranslationUnit& translationUnit) {
     return false;
 }

src/AstTransforms.h

@@ -18,7 +18,6 @@
 
 #include "AstArgument.h"
 #include "AstTransformer.h"
-#include "AstTranslationUnit.h"
 #include "DebugReport.h"
 #include "Util.h"
 #include <functional>
@@ -31,8 +30,8 @@
 namespace souffle {
 
 class AstClause;
-class AstProgram;
 class AstRelation;
+class AstTranslationUnit;
 
 /**
  * Transformation pass to eliminate grounded aliases.

src/AstTranslator.cpp

@@ -49,13 +49,10 @@
 #include <cassert>
 #include <chrono>
 #include <cstddef>
-#include <fstream>
-#include <functional>
-#include <iostream>
 #include <map>
 #include <memory>
 #include <set>
-#include <typeinfo>
+#include <sstream>
 #include <utility>
 #include <vector>
 
@@ -753,7 +750,7 @@ std::unique_ptr<RamStatement> AstTranslator::ClauseTranslator::translateClause(
 
         // translate arguments's of atom (if exists) to conditions
         if (atom != nullptr) {
-            for (size_t pos = 0; pos < atom->argSize(); ++pos) {
+            for (size_t pos = 0; pos < atom->getArguments().size(); ++pos) {
                 // variable bindings are issued differently since we don't want self
                 // referential variable bindings
                 if (const auto* var = dynamic_cast<const AstVariable*>(atom->getArgument(pos))) {

src/AstTranslator.h

@@ -28,6 +28,7 @@
 #include <set>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace souffle {
 

src/AstTypeAnalysis.cpp

@@ -15,10 +15,22 @@
  ***********************************************************************/
 
 #include "AstTypeAnalysis.h"
+#include "AstArgument.h"
+#include "AstAttribute.h"
+#include "AstClause.h"
+#include "AstFunctorDeclaration.h"
+#include "AstLiteral.h"
+#include "AstProgram.h"
+#include "AstRelation.h"
 #include "AstTranslationUnit.h"
+#include "AstType.h"
 #include "AstTypeEnvironmentAnalysis.h"
+#include "AstVisitor.h"
+#include "BinaryConstraintOps.h"
+#include "FunctorOps.h"
 #include "Global.h"
 #include "TypeConstraint.h"
+#include "TypeSystem.h"
 #include <ostream>
 
 namespace souffle {
@@ -30,38 +42,38 @@ void TypeSolver::generateConstraints() {
         ConstraintFinder(const AstProgram* program, const TypeLattice* lattice, TypeSolver* solver)
                 : program(program), lattice(lattice), solver(solver) {}
 
-        void visitNode(const AstNode& node) {
+        void visitNode(const AstNode& node) override {
             // by default, extract the constraints generated by all children
             for (const AstNode* child : node.getChildNodes()) {
                 visit(*child);
             }
         }
 
-        void visitCounter(const AstCounter& counter) {
+        void visitCounter(const AstCounter& counter) override {
             // counters must be numbers
             solver->addConstraint(std::make_unique<FixedConstraint>(
                     &counter, std::make_unique<ConstantAnalysisType>(Kind::NUMBER)));
         }
 
-        void visitNumberConstant(const AstNumberConstant& constant) {
+        void visitNumberConstant(const AstNumberConstant& constant) override {
             // number constants must actually be numbers
             solver->addConstraint(std::make_unique<FixedConstraint>(
                     &constant, std::make_unique<ConstantAnalysisType>(Kind::NUMBER)));
         }
 
-        void visitStringConstant(const AstStringConstant& constant) {
+        void visitStringConstant(const AstStringConstant& constant) override {
             // string constants must actually be strings
             solver->addConstraint(std::make_unique<FixedConstraint>(
                     &constant, std::make_unique<ConstantAnalysisType>(Kind::SYMBOL)));
         }
 
-        void visitNullConstant(const AstNullConstant& constant) {
+        void visitNullConstant(const AstNullConstant& constant) override {
             // nils must be record types
             solver->addConstraint(std::make_unique<FixedConstraint>(
                     &constant, std::make_unique<ConstantAnalysisType>(Kind::RECORD)));
         }
 
-        void visitTypeCast(const AstTypeCast& cast) {
+        void visitTypeCast(const AstTypeCast& cast) override {
             // extract child constraints
             visitNode(cast);
 
@@ -71,7 +83,7 @@ void TypeSolver::generateConstraints() {
                     std::make_unique<FixedConstraint>(&cast, std::unique_ptr<AnalysisType>(type->clone())));
         }
 
-        void visitIntrinsicFunctor(const AstIntrinsicFunctor& functor) {
+        void visitIntrinsicFunctor(const AstIntrinsicFunctor& functor) override {
             // extract child constraints
             visitNode(functor);
 
@@ -116,7 +128,7 @@ void TypeSolver::generateConstraints() {
             }
         }
 
-        void visitUserDefinedFunctor(const AstUserDefinedFunctor& functor) {
+        void visitUserDefinedFunctor(const AstUserDefinedFunctor& functor) override {
             // extract child constraints
             visitNode(functor);
 
@@ -156,7 +168,7 @@ void TypeSolver::generateConstraints() {
             solver->addConstraint(std::move(constantConstraint));
         }
 
-        void visitRecordInit(const AstRecordInit& record) {
+        void visitRecordInit(const AstRecordInit& record) override {
             // extract child constraints
             visitNode(record);
 
@@ -215,7 +227,7 @@ void TypeSolver::generateConstraints() {
             solver->addConstraint(std::move(finalConstraint));
         }
 
-        void visitAggregator(const AstAggregator& aggregate) {
+        void visitAggregator(const AstAggregator& aggregate) override {
             // extract child constraints
             visitNode(aggregate);
 
@@ -236,7 +248,7 @@ void TypeSolver::generateConstraints() {
             }
         }
 
-        void visitAtom(const AstAtom& atom) {
+        void visitAtom(const AstAtom& atom) override {
             // extract child constraints
             visitNode(atom);
 
@@ -252,12 +264,12 @@ void TypeSolver::generateConstraints() {
             }
         }
 
-        void visitNegation(const AstNegation& negation) {
+        void visitNegation(const AstNegation& negation) override {
             // only extract child constraints of the internal atom
             return visitNode(*negation.getAtom());
         }
 
-        void visitBinaryConstraint(const AstBinaryConstraint& binary) {
+        void visitBinaryConstraint(const AstBinaryConstraint& binary) override {
             // extract child constraints
             visitNode(binary);
 
@@ -270,7 +282,7 @@ void TypeSolver::generateConstraints() {
             }
         }
 
-        void visitClause(const AstClause& clause) {
+        void visitClause(const AstClause& clause) override {
             // get constraints from body literals only
             for (const AstLiteral* literal : clause.getBodyLiterals()) {
                 visit(*literal);