Apply clang-format universally.

* It is tough to contribute to a project that doesn't use a formatter,
* It is extra hard to contribute to a project which has configured the formatter, but ignores it for some files
* Code formatting makes it harder to hide obscure / weird bugs by accident or on purpose,

Let's rip the bandaid off?

Note that PRs currently in flight should be able to be merged relatively easily by applying `clang-format` to their tip prior to merge.

src/libexpr-test-support/include/nix/expr/tests/libexpr.hh

@@ -16,141 +16,159 @@
 #include "nix/store/tests/libstore.hh"
 
 namespace nix {
-    class LibExprTest : public LibStoreTest {
-        public:
-            static void SetUpTestSuite() {
-                LibStoreTest::SetUpTestSuite();
-                initGC();
-            }
-
-        protected:
-            LibExprTest()
-                : LibStoreTest()
-                , state({}, store, fetchSettings, evalSettings, nullptr)
-            {
-                evalSettings.nixPath = {};
-            }
-            Value eval(std::string input, bool forceValue = true) {
-                Value v;
-                Expr * e = state.parseExprFromString(input, state.rootPath(CanonPath::root));
-                assert(e);
-                state.eval(e, v);
-                if (forceValue)
-                    state.forceValue(v, noPos);
-                return v;
-            }
-
-            Value * maybeThunk(std::string input, bool forceValue = true) {
-                Expr * e = state.parseExprFromString(input, state.rootPath(CanonPath::root));
-                assert(e);
-                return e->maybeThunk(state, state.baseEnv);
-            }
-
-            Symbol createSymbol(const char * value) {
-                return state.symbols.create(value);
-            }
-
-            bool readOnlyMode = true;
-            fetchers::Settings fetchSettings{};
-            EvalSettings evalSettings{readOnlyMode};
-            EvalState state;
-    };
-
-    MATCHER(IsListType, "") {
-        return arg != nList;
+class LibExprTest : public LibStoreTest
+{
+public:
+    static void SetUpTestSuite()
+    {
+        LibStoreTest::SetUpTestSuite();
+        initGC();
     }
 
-    MATCHER(IsList, "") {
-        return arg.type() == nList;
+protected:
+    LibExprTest()
+        : LibStoreTest()
+        , state({}, store, fetchSettings, evalSettings, nullptr)
+    {
+        evalSettings.nixPath = {};
     }
 
-    MATCHER(IsString, "") {
-        return arg.type() == nString;
+    Value eval(std::string input, bool forceValue = true)
+    {
+        Value v;
+        Expr * e = state.parseExprFromString(input, state.rootPath(CanonPath::root));
+        assert(e);
+        state.eval(e, v);
+        if (forceValue)
+            state.forceValue(v, noPos);
+        return v;
     }
 
-    MATCHER(IsNull, "") {
-        return arg.type() == nNull;
+    Value * maybeThunk(std::string input, bool forceValue = true)
+    {
+        Expr * e = state.parseExprFromString(input, state.rootPath(CanonPath::root));
+        assert(e);
+        return e->maybeThunk(state, state.baseEnv);
     }
 
-    MATCHER(IsThunk, "") {
-        return arg.type() == nThunk;
+    Symbol createSymbol(const char * value)
+    {
+        return state.symbols.create(value);
     }
 
-    MATCHER(IsAttrs, "") {
-        return arg.type() == nAttrs;
-    }
+    bool readOnlyMode = true;
+    fetchers::Settings fetchSettings{};
+    EvalSettings evalSettings{readOnlyMode};
+    EvalState state;
+};
 
-    MATCHER_P(IsStringEq, s, fmt("The string is equal to \"%1%\"", s)) {
-        if (arg.type() != nString) {
+MATCHER(IsListType, "")
+{
+    return arg != nList;
+}
+
+MATCHER(IsList, "")
+{
+    return arg.type() == nList;
+}
+
+MATCHER(IsString, "")
+{
+    return arg.type() == nString;
+}
+
+MATCHER(IsNull, "")
+{
+    return arg.type() == nNull;
+}
+
+MATCHER(IsThunk, "")
+{
+    return arg.type() == nThunk;
+}
+
+MATCHER(IsAttrs, "")
+{
+    return arg.type() == nAttrs;
+}
+
+MATCHER_P(IsStringEq, s, fmt("The string is equal to \"%1%\"", s))
+{
+    if (arg.type() != nString) {
+        return false;
+    }
+    return std::string_view(arg.c_str()) == s;
+}
+
+MATCHER_P(IsIntEq, v, fmt("The string is equal to \"%1%\"", v))
+{
+    if (arg.type() != nInt) {
+        return false;
+    }
+    return arg.integer().value == v;
+}
+
+MATCHER_P(IsFloatEq, v, fmt("The float is equal to \"%1%\"", v))
+{
+    if (arg.type() != nFloat) {
+        return false;
+    }
+    return arg.fpoint() == v;
+}
+
+MATCHER(IsTrue, "")
+{
+    if (arg.type() != nBool) {
+        return false;
+    }
+    return arg.boolean() == true;
+}
+
+MATCHER(IsFalse, "")
+{
+    if (arg.type() != nBool) {
+        return false;
+    }
+    return arg.boolean() == false;
+}
+
+MATCHER_P(IsPathEq, p, fmt("Is a path equal to \"%1%\"", p))
+{
+    if (arg.type() != nPath) {
+        *result_listener << "Expected a path got " << arg.type();
+        return false;
+    } else {
+        auto path = arg.path();
+        if (path.path != CanonPath(p)) {
+            *result_listener << "Expected a path that equals \"" << p << "\" but got: " << path.path;
             return false;
         }
-        return std::string_view(arg.c_str()) == s;
     }
+    return true;
+}
 
-    MATCHER_P(IsIntEq, v, fmt("The string is equal to \"%1%\"", v)) {
-        if (arg.type() != nInt) {
-            return false;
-        }
-        return arg.integer().value == v;
+MATCHER_P(IsListOfSize, n, fmt("Is a list of size [%1%]", n))
+{
+    if (arg.type() != nList) {
+        *result_listener << "Expected list got " << arg.type();
+        return false;
+    } else if (arg.listSize() != (size_t) n) {
+        *result_listener << "Expected as list of size " << n << " got " << arg.listSize();
+        return false;
     }
+    return true;
+}
 
-    MATCHER_P(IsFloatEq, v, fmt("The float is equal to \"%1%\"", v)) {
-        if (arg.type() != nFloat) {
-            return false;
-        }
-        return arg.fpoint() == v;
+MATCHER_P(IsAttrsOfSize, n, fmt("Is a set of size [%1%]", n))
+{
+    if (arg.type() != nAttrs) {
+        *result_listener << "Expected set got " << arg.type();
+        return false;
+    } else if (arg.attrs()->size() != (size_t) n) {
+        *result_listener << "Expected a set with " << n << " attributes but got " << arg.attrs()->size();
+        return false;
     }
-
-    MATCHER(IsTrue, "") {
-        if (arg.type() != nBool) {
-            return false;
-        }
-        return arg.boolean() == true;
-    }
-
-    MATCHER(IsFalse, "") {
-        if (arg.type() != nBool) {
-            return false;
-        }
-        return arg.boolean() == false;
-    }
-
-    MATCHER_P(IsPathEq, p, fmt("Is a path equal to \"%1%\"", p)) {
-        if (arg.type() != nPath) {
-            *result_listener << "Expected a path got " << arg.type();
-            return false;
-        } else {
-            auto path = arg.path();
-            if (path.path != CanonPath(p)) {
-                *result_listener << "Expected a path that equals \"" << p << "\" but got: " << path.path;
-                return false;
-            }
-        }
-        return true;
-    }
-
-
-    MATCHER_P(IsListOfSize, n, fmt("Is a list of size [%1%]", n)) {
-        if (arg.type() != nList) {
-            *result_listener << "Expected list got " << arg.type();
-            return false;
-        } else if (arg.listSize() != (size_t)n) {
-            *result_listener << "Expected as list of size " << n << " got " << arg.listSize();
-            return false;
-        }
-        return true;
-    }
-
-    MATCHER_P(IsAttrsOfSize, n, fmt("Is a set of size [%1%]", n)) {
-        if (arg.type() != nAttrs) {
-            *result_listener << "Expected set got " << arg.type();
-            return false;
-        } else if (arg.attrs()->size() != (size_t) n) {
-            *result_listener << "Expected a set with " << n << " attributes but got " << arg.attrs()->size();
-            return false;
-        }
-        return true;
-    }
-
+    return true;
+}
 
 } /* namespace nix */

src/libexpr-test-support/include/nix/expr/tests/nix_api_expr.hh

@@ -18,6 +18,7 @@ protected:
         state = nix_state_create(nullptr, nullptr, store);
         value = nix_alloc_value(nullptr, state);
     }
+
     ~nix_api_expr_test()
     {
         nix_gc_decref(nullptr, value);
@@ -28,4 +29,4 @@ protected:
     nix_value * value;
 };
 
-}
+} // namespace nixC

src/libexpr-test-support/include/nix/expr/tests/value/context.hh

@@ -9,23 +9,27 @@ namespace rc {
 using namespace nix;
 
 template<>
-struct Arbitrary<NixStringContextElem::Opaque> {
+struct Arbitrary<NixStringContextElem::Opaque>
+{
     static Gen<NixStringContextElem::Opaque> arbitrary();
 };
 
 template<>
-struct Arbitrary<NixStringContextElem::Built> {
+struct Arbitrary<NixStringContextElem::Built>
+{
     static Gen<NixStringContextElem::Built> arbitrary();
 };
 
 template<>
-struct Arbitrary<NixStringContextElem::DrvDeep> {
+struct Arbitrary<NixStringContextElem::DrvDeep>
+{
     static Gen<NixStringContextElem::DrvDeep> arbitrary();
 };
 
 template<>
-struct Arbitrary<NixStringContextElem> {
+struct Arbitrary<NixStringContextElem>
+{
     static Gen<NixStringContextElem> arbitrary();
 };
 
-}
+} // namespace rc

src/libexpr-test-support/tests/value/context.cc

@@ -36,4 +36,4 @@ Gen<NixStringContextElem> Arbitrary<NixStringContextElem>::arbitrary()
         });
 }
 
-}
+} // namespace rc