libexpr: apply static analysis "quick fix" to splitted files

This PR contains no functioanl change, there are bunch of suggesstions
by clang-tidy in the file and there are fixes available.

Including:

- 0 -> nullptr
- use `auto` for iterator types
- sort `#include`s
- closing namespace comment
- use `.empty()` instead of comparing it with empty object
- use `auto` if it the type is apparently specified (e.g. `new Type`)
- add const specifier or `&` to improve readability

Author: inclyc

src/libexpr/lexer/prologue.inc

@@ -84,7 +84,7 @@ static StringToken unescapeStr(SymbolTable & symbols, char * s, size_t length)
     return {result, size_t(t - result)};
 }
 
-}
+} // namespace nix
 
 #define YY_USER_INIT initLoc(yylloc)
 #define YY_USER_ACTION adjustLoc(yylloc, yytext, yyleng);

src/libexpr/parser/epilogue.inc

@@ -1,17 +1,17 @@
-#include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/types.h>
+
 #include <fcntl.h>
 #include <unistd.h>
 
 #include "parser-tab.hh"
-
 #include "lexer-tab.hh"
 
 #include "eval.hh"
-#include "filetransfer.hh"
 #include "fetchers.hh"
-#include "store-api.hh"
+#include "filetransfer.hh"
 #include "flake/flake.hh"
+#include "store-api.hh"
 
 namespace nix {
 
@@ -97,7 +97,7 @@ SourcePath EvalState::findFile(const std::string_view path)
 
 SourcePath EvalState::findFile(const SearchPath & searchPath, const std::string_view path, const PosIdx pos)
 {
-    for (auto & i : searchPath.elements) {
+    for (const auto & i : searchPath.elements) {
         auto suffixOpt = i.prefix.suffixIfPotentialMatch(path);
 
         if (!suffixOpt)
@@ -109,7 +109,7 @@ SourcePath EvalState::findFile(const SearchPath & searchPath, const std::string_
             continue;
         auto r = *rOpt;
 
-        Path res = suffix == "" ? r : concatStrings(r, "/", suffix);
+        Path res = suffix.empty() ? r : concatStrings(r, "/", suffix);
         if (pathExists(res))
             return CanonPath(canonPath(res));
     }
@@ -125,12 +125,12 @@ SourcePath EvalState::findFile(const SearchPath & searchPath, const std::string_
                      : "file '%s' was not found in the Nix search path (add it using $NIX_PATH or -I)",
                  path),
              .errPos = positions[pos]}),
-        0, 0);
+        nullptr, nullptr);
 }
 
 std::optional<std::string> EvalState::resolveSearchPathPath(const SearchPath::Path & value0)
 {
-    auto & value = value0.s;
+    const auto & value = value0.s;
     auto i = searchPathResolved.find(value);
     if (i != searchPathResolved.end())
         return i->second;
@@ -175,4 +175,4 @@ std::optional<std::string> EvalState::resolveSearchPathPath(const SearchPath::Pa
     return res;
 }
 
-}
+} // namespace nix

src/libexpr/parser/prologue.inc

@@ -1,4 +1,3 @@
-
 #include "parser-tab.hh"
 #include "lexer-tab.hh"
 
@@ -32,37 +31,37 @@ static void addAttr(ExprAttrs * attrs, AttrPath && attrPath, Expr * e, const Pos
     // ===========================
     for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
         if (i->symbol) {
-            ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
+            auto j = attrs->attrs.find(i->symbol);
             if (j != attrs->attrs.end()) {
                 if (!j->second.inherited) {
-                    ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
+                    auto * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
                     if (!attrs2)
                         dupAttr(state, attrPath, pos, j->second.pos);
                     attrs = attrs2;
                 } else
                     dupAttr(state, attrPath, pos, j->second.pos);
             } else {
-                ExprAttrs * nested = new ExprAttrs;
+                auto * nested = new ExprAttrs;
                 attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
                 attrs = nested;
             }
         } else {
-            ExprAttrs * nested = new ExprAttrs;
+            auto * nested = new ExprAttrs;
             attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, nested, pos));
             attrs = nested;
         }
     }
     // Expr insertion.
     // ==========================
     if (i->symbol) {
-        ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
+        auto j = attrs->attrs.find(i->symbol);
         if (j != attrs->attrs.end()) {
             // This attr path is already defined. However, if both
             // e and the expr pointed by the attr path are two attribute sets,
             // we want to merge them.
             // Otherwise, throw an error.
-            auto ae = dynamic_cast<ExprAttrs *>(e);
-            auto jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
+            auto * ae = dynamic_cast<ExprAttrs *>(e);
+            auto * jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
             if (jAttrs && ae) {
                 for (auto & ad : ae->attrs) {
                     auto j2 = jAttrs->attrs.find(ad.first);
@@ -222,7 +221,7 @@ static inline PosIdx makeCurPos(const YYLTYPE & loc, ParseData * data)
 
 #define CUR_POS makeCurPos(*yylocp, data)
 
-}
+} // namespace nix
 
 void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * error)
 {

src/libexpr/parser/requires.hh

@@ -4,12 +4,11 @@
 
 #include <variant>
 
-#include "util.hh"
-
-#include "nixexpr.hh"
-#include "eval.hh"
 #include "eval-settings.hh"
+#include "eval.hh"
 #include "globals.hh"
+#include "nixexpr.hh"
+#include "util.hh"
 
 namespace nix {
 
@@ -29,7 +28,7 @@ struct ParserFormals
     bool ellipsis = false;
 };
 
-}
+} // namespace nix
 
 // using C a struct allows us to avoid having to define the special
 // members that using string_view here would implicitly delete.