Lint script (#361)

## Changes
* This closes the C++ Style Refactor project.
* Resolves #316.
* Resolves #317.
* Resolves #319.
* Closes #357.
* Reformats all C++ code according to [Google C++ Style Guide].
* Adds `.clang-format` file specifying the exceptions to the Google style guide.
* Adds lint.sh script which prints a diff generated by `clang-format` (if any) and the errors generated by `cpplint`, and allows one to apply formatting in place with `./lint.sh -i`.
* Adds Lint step to CI before Build.
* Updates .gitbub/CONTRIBUTING.md with instructions on how to use lint.sh.
* Adds the missing test file to the Xcode project.

## Comments
* Linting in CI is not parallelized and is using the same Docker image because it will eventually include linting of the Wolfram Language code as well as described in #247.
* Bin packing is now disallowed in addition to the existing style exceptions.
* All `cpplint` errors are fixed as well, not just the formatting.
* `#include <chrono>` is not allowed by `cpplint` for Chromium-specific reasons, so added `// NOLINT` there.
* Renamed `SetTest.cpp` -> `Set_test.cpp` because the suffix appears to be hard-coded to `cpplint`.
* Before the formatting, the code was mostly following this style (imperfectly):
```
---
Language: Cpp
BasedOnStyle: Google
ColumnLimit: 120
BinPackArguments: false
BinPackParameters: false
AllowShortFunctionsOnASingleLine: Empty
IndentWidth: 4
NamespaceIndentation: All
AccessModifierOffset: -4
FixNamespaceComments: false
SpaceAfterTemplateKeyword: false
BreakConstructorInitializers: AfterColon
SpacesBeforeTrailingComments: 1
...
```

## Examples
* Break formatting/code style somewhere in the code, and run `./lint.sh`. For example, we can remove `explicit` on line 22 of Match.cpp, and add a spurious space on the line below:
```
> ./lint.sh 
--- libSetReplace/Match.cpp
+++ formatted
@@ -24 +24 @@
-  bool  operator()(const MatchPtr& a, const MatchPtr& b) const {
+  bool operator()(const MatchPtr& a, const MatchPtr& b) const {

libSetReplace/Match.cpp:22:  Single-parameter constructors should be marked explicit.  [runtime/explicit] [5]
Done processing libSetReplace/Match.cpp
Total errors found: 1
```

* We can run `./lint.sh -i` to fix the space automatically:
```
> ./lint.sh -i
--- libSetReplace/Match.cpp
+++ formatted
@@ -24 +24 @@
-  bool  operator()(const MatchPtr& a, const MatchPtr& b) const {
+  bool operator()(const MatchPtr& a, const MatchPtr& b) const {

libSetReplace/Match.cpp:22:  Single-parameter constructors should be marked explicit.  [runtime/explicit] [5]
Done processing libSetReplace/Match.cpp
Total errors found: 1
```

* The output is the same, however, if we run `./lint.sh` again, there will be no diff:
```
> ./lint.sh   
libSetReplace/Match.cpp:22:  Single-parameter constructors should be marked explicit.  [runtime/explicit] [5]
Done processing libSetReplace/Match.cpp
Total errors found: 1
```

* Finally, if we put explicit back in, there will be no output, which means everything is ok:
```
> ./lint.sh
```

Author: maxitg

.circleci/config.yml

@@ -10,6 +10,10 @@ jobs:
     steps:
       - checkout
 
+      - run:
+          name: Lint
+          command: ./lint.sh
+
       - run:
           name: Build
           command: ./build.wls

.clang-format

@@ -0,0 +1,10 @@
+---
+Language: Cpp
+BasedOnStyle: Google
+AllowShortIfStatementsOnASingleLine: Always
+BinPackArguments: false
+BinPackParameters: false
+ColumnLimit: 120
+DerivePointerAlignment: false
+Standard: c++17
+...

.github/CONTRIBUTING.md

@@ -347,33 +347,34 @@ In addition to that, here are some more-or-less established rules:
 * Start global constants with `$`, whether internal or public, and tags (such as used in [`Throw`](https://reference.wolfram.com/language/ref/Throw.html) or [`Sow`](https://reference.wolfram.com/language/ref/Sow.html), or as generic enum labels) with `$$`.
 
 #### C++
-New code should follow [Google C++ Style](https://google.github.io/styleguide/cppguide.html) guidelines, save for
-the exceptions laid out in the list below. The code in this repository is currently undergoing refactoring to
-conform to this specification. You can track the progress of this refactoring
-[here](https://github.com/maxitg/SetReplace/projects/2).
-
-The following are exceptions to Google C++ Style:
+The code should follow [Google C++ Style](https://google.github.io/styleguide/cppguide.html) guidelines, save for the
+following exceptions:
 * Maximum line length is 120 characters.
 * Function and variable names, including const and constexpr variables, use lower camel case.
 * Namespace and class names use upper camel case.
 * C++ exceptions may be thrown.
-* All indentation uses four spaces, except for access specifiers which uses one.
 * White space in pointer and reference declarations goes after the `*` or `&` character. For example:
     * `int* foo;`
     * `const std::string& string;`
+* If splitting function arguments into multiple lines, each argument should go on a separate line.
 * License, authors, and file descriptions should not be put at the top of files.
 * Doxygen is used for documentation.
+* We use `.cpp` and `.hpp` extensions for source files.
 
-A useful tool for confirming your code's adherence to the above code style is to use
-[cpplint](https://raw.githubusercontent.com/google/styleguide/gh-pages/cpplint/cpplint.py). You can lint a C++ source
-or header file like this:
-```bash
-cpplint.py --linelength=120 --filter=-legal/copyright file_name
-```
-If cpplint flags a portion of your code, please make sure it is adhering to the proper code style. If it is a false
+We use [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html) for formatting and
+[`cpplint`](https://raw.githubusercontent.com/google/styleguide/gh-pages/cpplint/cpplint.py) for linting.
+
+To run these automatically, call `./lint.sh`. This will print a formatting diff and error messages from `cpplint`.
+If there are no errors found, it will exit with no output.
+To edit the code in place with the fixed formatting use `./lint.sh -i`.
+
+If `cpplint` flags a portion of your code, please make sure it is adhering to the proper code style. If it is a false
 positive or if there is no reasonable way to avoid the flag, you may put `// NOLINT` at the end of the line if there is
 space, or `// NOLINTNEXTLINE` on a new line above if there is no space. For any usages of `// NOLINT` or
 `// NOLINTNEXTLINE`, please describe the reason for its inclusion both in a code comment and in your pull request's
 comments section.
 
+If you want to disable formatting, use `// clang-format off` and `// clang-format on` around the manually formatted
+code.
+
 That's all for our guidelines, now let's go figure out the fundamental theory of physics! :rocket:

SetReplace.xcodeproj/project.pbxproj

@@ -22,6 +22,8 @@
 /* Begin PBXFileReference section */
 		6909EBA922258611001458D2 /* Match.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Match.cpp; sourceTree = "<group>"; };
 		6909EBAA22258611001458D2 /* Match.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Match.hpp; sourceTree = "<group>"; };
+		691E077A2471CED500D2BDD5 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
+		691E077C2471D1DD00D2BDD5 /* Set_test.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Set_test.cpp; sourceTree = "<group>"; };
 		695F486E222443F20058E057 /* Set.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Set.cpp; sourceTree = "<group>"; };
 		695F486F222443F20058E057 /* Set.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Set.hpp; sourceTree = "<group>"; };
 		6961A1D523184ABC009461C8 /* Expression.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Expression.cpp; sourceTree = "<group>"; };
@@ -44,6 +46,15 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		691E07792471CED500D2BDD5 /* test */ = {
+			isa = PBXGroup;
+			children = (
+				691E077A2471CED500D2BDD5 /* CMakeLists.txt */,
+				691E077C2471D1DD00D2BDD5 /* Set_test.cpp */,
+			);
+			path = test;
+			sourceTree = "<group>";
+		};
 		695F485A222440B90058E057 = {
 			isa = PBXGroup;
 			children = (
@@ -63,16 +74,17 @@
 		695F4865222440B90058E057 /* libSetReplace */ = {
 			isa = PBXGroup;
 			children = (
-				69ED0F4023170D5D0014A48E /* IDTypes.hpp */,
 				69B2D41122244AFC008778A3 /* Expression.hpp */,
 				6961A1D523184ABC009461C8 /* Expression.cpp */,
-				69B2D41422244D1F008778A3 /* Rule.hpp */,
+				69ED0F4023170D5D0014A48E /* IDTypes.hpp */,
 				6909EBAA22258611001458D2 /* Match.hpp */,
 				6909EBA922258611001458D2 /* Match.cpp */,
+				69B2D41422244D1F008778A3 /* Rule.hpp */,
 				695F486F222443F20058E057 /* Set.hpp */,
 				695F486E222443F20058E057 /* Set.cpp */,
-				69CAF8732257B23B006F9C60 /* SetReplace.cpp */,
 				69CAF8742257B23B006F9C60 /* SetReplace.hpp */,
+				69CAF8732257B23B006F9C60 /* SetReplace.cpp */,
+				691E07792471CED500D2BDD5 /* test */,
 			);
 			path = libSetReplace;
 			sourceTree = "<group>";

libSetReplace/Expression.cpp

@@ -5,67 +5,67 @@
 #include <utility>
 
 namespace SetReplace {
-    class AtomsIndex::Implementation {
-     private:
-        const std::function<AtomsVector(ExpressionID)> getAtomsVector_;
-        std::unordered_map<Atom, std::unordered_set<ExpressionID>> index_;
+class AtomsIndex::Implementation {
+ private:
+  const std::function<AtomsVector(ExpressionID)> getAtomsVector_;
+  std::unordered_map<Atom, std::unordered_set<ExpressionID>> index_;
 
-     public:
-        explicit Implementation(std::function<AtomsVector(ExpressionID)> getAtomsVector)
-            : getAtomsVector_(std::move(getAtomsVector)) {}
+ public:
+  explicit Implementation(std::function<AtomsVector(ExpressionID)> getAtomsVector)
+      : getAtomsVector_(std::move(getAtomsVector)) {}
 
-        void removeExpressions(const std::vector<ExpressionID>& expressionIDs) {
-            const std::unordered_set<ExpressionID> expressionsToDelete(expressionIDs.begin(), expressionIDs.end());
+  void removeExpressions(const std::vector<ExpressionID>& expressionIDs) {
+    const std::unordered_set<ExpressionID> expressionsToDelete(expressionIDs.begin(), expressionIDs.end());
 
-            std::unordered_set<Atom> involvedAtoms;
-            for (const auto& expression : expressionIDs) {
-                const auto& atomsVector = getAtomsVector_(expression);
-                involvedAtoms.insert(atomsVector.begin(), atomsVector.end());
-            }
+    std::unordered_set<Atom> involvedAtoms;
+    for (const auto& expression : expressionIDs) {
+      const auto& atomsVector = getAtomsVector_(expression);
+      involvedAtoms.insert(atomsVector.begin(), atomsVector.end());
+    }
 
-            for (const auto& atom : involvedAtoms) {
-                auto& atomExpressionSet = index_[atom];
-                auto atomExpressionIterator = atomExpressionSet.begin();
-                const auto atomExpressionSetEnd = atomExpressionSet.cend();
-                while (atomExpressionIterator != atomExpressionSetEnd) {
-                    if (expressionsToDelete.count(*atomExpressionIterator)) {
-                        atomExpressionIterator = atomExpressionSet.erase(atomExpressionIterator);
-                    } else {
-                        ++atomExpressionIterator;
-                    }
-                }
-                if (atomExpressionSet.empty()) {
-                    index_.erase(atom);
-                }
-            }
+    for (const auto& atom : involvedAtoms) {
+      auto& atomExpressionSet = index_[atom];
+      auto atomExpressionIterator = atomExpressionSet.begin();
+      const auto atomExpressionSetEnd = atomExpressionSet.cend();
+      while (atomExpressionIterator != atomExpressionSetEnd) {
+        if (expressionsToDelete.count(*atomExpressionIterator)) {
+          atomExpressionIterator = atomExpressionSet.erase(atomExpressionIterator);
+        } else {
+          ++atomExpressionIterator;
         }
+      }
+      if (atomExpressionSet.empty()) {
+        index_.erase(atom);
+      }
+    }
+  }
 
-        void addExpressions(const std::vector<ExpressionID>& expressionIDs) {
-            for (const auto& expressionID : expressionIDs) {
-                for (const auto& atom : getAtomsVector_(expressionID)) {
-                    index_[atom].insert(expressionID);
-                }
-            }
-        }
+  void addExpressions(const std::vector<ExpressionID>& expressionIDs) {
+    for (const auto& expressionID : expressionIDs) {
+      for (const auto& atom : getAtomsVector_(expressionID)) {
+        index_[atom].insert(expressionID);
+      }
+    }
+  }
 
-        std::unordered_set<ExpressionID> expressionsContainingAtom(const Atom atom) const {
-            const auto resultIterator = index_.find(atom);
-            return resultIterator != index_.end() ? resultIterator->second : std::unordered_set<ExpressionID>();
-        }
-    };
+  std::unordered_set<ExpressionID> expressionsContainingAtom(const Atom atom) const {
+    const auto resultIterator = index_.find(atom);
+    return resultIterator != index_.end() ? resultIterator->second : std::unordered_set<ExpressionID>();
+  }
+};
 
-    AtomsIndex::AtomsIndex(const std::function<AtomsVector(ExpressionID)>& getAtomsVector)
-        : implementation_(std::make_shared<Implementation>(getAtomsVector)) {}
+AtomsIndex::AtomsIndex(const std::function<AtomsVector(ExpressionID)>& getAtomsVector)
+    : implementation_(std::make_shared<Implementation>(getAtomsVector)) {}
 
-    void AtomsIndex::removeExpressions(const std::vector<ExpressionID>& expressionIDs) {
-        implementation_->removeExpressions(expressionIDs);
-    }
+void AtomsIndex::removeExpressions(const std::vector<ExpressionID>& expressionIDs) {
+  implementation_->removeExpressions(expressionIDs);
+}
 
-    void AtomsIndex::addExpressions(const std::vector<ExpressionID>& expressionIDs) {
-        implementation_->addExpressions(expressionIDs);
-    }
+void AtomsIndex::addExpressions(const std::vector<ExpressionID>& expressionIDs) {
+  implementation_->addExpressions(expressionIDs);
+}
 
-    std::unordered_set<ExpressionID> AtomsIndex::expressionsContainingAtom(const Atom atom) const {
-        return implementation_->expressionsContainingAtom(atom);
-    }
+std::unordered_set<ExpressionID> AtomsIndex::expressionsContainingAtom(const Atom atom) const {
+  return implementation_->expressionsContainingAtom(atom);
 }
+}  // namespace SetReplace

libSetReplace/Expression.hpp

@@ -1,63 +1,63 @@
-#ifndef Expression_hpp
-#define Expression_hpp
+#ifndef LIBSETREPLACE_EXPRESSION_HPP_
+#define LIBSETREPLACE_EXPRESSION_HPP_
 
 #include <functional>
 #include <memory>
-#include <vector>
 #include <unordered_set>
+#include <vector>
 
 #include "IDTypes.hpp"
 
 namespace SetReplace {
-    /** @brief List of atoms without references to events, as can be used in, i.e., rule specification.
-     */
-    using AtomsVector = std::vector<Atom>;
-
-    /** @brief Expression, as a part of the set, i.e., (hyper)edges in the graph.
-     */
-    struct SetExpression {
-        /** @brief Ordered list of atoms the expression contains.
-         */
-        AtomsVector atoms;
-
-        /** @brief Substitution event that has this expression as part of its output.
-         */
-        EventID creatorEvent;
-
-        /** @brief Substitution event that has this expression as part of its input.
-         */
-        EventID destroyerEvent = finalStateEvent;
-
-        /** @brief Layer of the causal network this expression belongs to.
-         */
-        Generation generation;
-    };
-
-    /** @brief AtomsIndex keeps references to set expressions accessible by atoms, which is useful for matching.
-     */
-    class AtomsIndex {
-    public:
-        /** @brief Creates an empty index.
-         * @param getAtomsVector datasource function that returns the list of atoms for a requested expression.
-         */
-        explicit AtomsIndex(const std::function<AtomsVector(ExpressionID)>& getAtomsVector);
-
-        /** @brief Removes expressions with specified IDs from the index.
-         */
-        void removeExpressions(const std::vector<ExpressionID>& expressionIDs);
-
-        /** @brief Adds expressions with specified IDs to the index.
-         */
-        void addExpressions(const std::vector<ExpressionID>& expressionIDs);
-
-        /** @brief Returns the list of expressions containing a specified atom.
-         */
-        std::unordered_set<ExpressionID> expressionsContainingAtom(Atom atom) const;
-
-     private:
-        class Implementation;
-        std::shared_ptr<Implementation> implementation_;
-    };
-}
-
-#endif /* Expression_hpp */
+/** @brief List of atoms without references to events, as can be used in, i.e., rule specification.
+ */
+using AtomsVector = std::vector<Atom>;
+
+/** @brief Expression, as a part of the set, i.e., (hyper)edges in the graph.
+ */
+struct SetExpression {
+  /** @brief Ordered list of atoms the expression contains.
+   */
+  AtomsVector atoms;
+
+  /** @brief Substitution event that has this expression as part of its output.
+   */
+  EventID creatorEvent;
+
+  /** @brief Substitution event that has this expression as part of its input.
+   */
+  EventID destroyerEvent = finalStateEvent;
+
+  /** @brief Layer of the causal network this expression belongs to.
+   */
+  Generation generation;
+};
+
+/** @brief AtomsIndex keeps references to set expressions accessible by atoms, which is useful for matching.
+ */
+class AtomsIndex {
+ public:
+  /** @brief Creates an empty index.
+   * @param getAtomsVector datasource function that returns the list of atoms for a requested expression.
+   */
+  explicit AtomsIndex(const std::function<AtomsVector(ExpressionID)>& getAtomsVector);
+
+  /** @brief Removes expressions with specified IDs from the index.
+   */
+  void removeExpressions(const std::vector<ExpressionID>& expressionIDs);
+
+  /** @brief Adds expressions with specified IDs to the index.
+   */
+  void addExpressions(const std::vector<ExpressionID>& expressionIDs);
+
+  /** @brief Returns the list of expressions containing a specified atom.
+   */
+  std::unordered_set<ExpressionID> expressionsContainingAtom(Atom atom) const;
+
+ private:
+  class Implementation;
+  std::shared_ptr<Implementation> implementation_;
+};
+}  // namespace SetReplace
+
+#endif  // LIBSETREPLACE_EXPRESSION_HPP_