Update rules for relative patterns

Author: glankk

lib/importproject.cpp

@@ -1254,7 +1254,7 @@ static std::list<std::string> readXmlStringList(const tinyxml2::XMLElement *node
             continue;
         const char *attr = attribute ? child->Attribute(attribute) : child->GetText();
         if (attr)
-            ret.push_back(joinRelativePath(path, attr));
+            ret.emplace_back(joinRelativePath(path, attr));
     }
     return ret;
 }
@@ -1266,12 +1266,8 @@ static std::list<std::string> readXmlPathMatchList(const tinyxml2::XMLElement *n
         if (strcmp(child->Name(), name) != 0)
             continue;
         const char *attr = attribute ? child->Attribute(attribute) : child->GetText();
-        if (attr) {
-            if (attr[0] == '.')
-                ret.push_back(joinRelativePath(path, attr));
-            else
-                ret.emplace_back(attr);
-        }
+        if (attr)
+            ret.emplace_back(PathMatch::joinRelativePattern(path, attr));
     }
     return ret;
 }

lib/pathmatch.cpp

@@ -47,12 +47,12 @@ bool PathMatch::match(const std::string &pattern, const std::string &path, const
 
     /* A "real" path is absolute or relative to the base path. A pattern that isn't "real" can match at any
      * path component boundary. */
-    bool real = Path::isAbsolute(pattern) || pattern[0] == '.';
+    bool real = Path::isAbsolute(pattern) || isRelativePattern(pattern);
 
     /* Pattern iterator */
-    PathIterator s = PathIterator::from_pattern(pattern, basepath, mode == Mode::icase);
+    PathIterator s = PathIterator::fromPattern(pattern, basepath, mode == Mode::icase);
     /* Path iterator */
-    PathIterator t = PathIterator::from_path(path, basepath, mode == Mode::icase);
+    PathIterator t = PathIterator::fromPath(path, basepath, mode == Mode::icase);
     /* Pattern restart position */
     PathIterator p = s;
     /* Path restart position */

lib/pathmatch.h

@@ -34,24 +34,25 @@
 
 /**
  *  Path matching rules:
- *  - All patterns are simplified first (path separators vary by platform):
+ *  - All patterns are canonicalized (path separators vary by platform):
  *    - '/./' => '/'
  *    - '/dir/../' => '/'
  *    - '//' => '/'
- *    - Trailing slashes are removed
+ *    - Trailing slashes are removed (root slash is preserved)
  *  - Patterns can contain globs:
  *    - '**' matches any number of characters including path separators.
  *    - '*' matches any number of characters except path separators.
  *    - '?' matches any single character except path separators.
  *  - If a pattern looks like an absolute path (e.g. starts with '/', but varies by platform):
- *    - Match all files where the pattern matches the start of the file's simplified absolute path up until a path
+ *    - Match all files where the pattern matches the start of the file's canonical absolute path up until a path
  *      separator or the end of the pathname.
- *  - If a pattern starts with '.':
+ *  - If a pattern looks like a relative path, i.e. is '.' or '..', or
+ *    starts with '.' or '..' followed by a path separator:
  *    - The pattern is interpreted as a path relative to `basepath` and then converted to an absolute path and
  *      treated as such according to the above procedure. If the pattern is relative to some other directory, it should
  *      be modified to be relative to `basepath` first (this should be done with patterns in project files, for example).
  *  - Otherwise:
- *    - Match all files where the pattern matches any part of the file's simplified absolute path up until a
+ *    - Match all files where the pattern matches any part of the file's canonical absolute path up until a
  *      path separator or the end of the pathname, and the matching part directly follows a path separator.
  **/
 
@@ -66,15 +67,15 @@ class CPPCHECKLIB PathMatch {
      *
      * scase: Case sensitive.
      * icase: Case insensitive.
-     **/
+     */
     enum class Mode : std::uint8_t {
         scase,
         icase,
     };
 
     /**
      * @brief The default mode for the current platform.
-     **/
+     */
 #ifdef _WIN32
     static constexpr Mode platform_mode = Mode::icase;
 #else
@@ -109,6 +110,44 @@ class CPPCHECKLIB PathMatch {
      */
     static bool match(const std::string &pattern, const std::string &path, const std::string &basepath = std::string(), Mode mode = platform_mode);
 
+    /**
+     * @brief Check if a pattern is a relative path name.
+     *
+     * @param pattern Pattern to check.
+     * @return true if the pattern has the form of a relative path name pattern.
+     */
+    static bool isRelativePattern(const std::string &pattern)
+    {
+        if (pattern.empty() || pattern[0] != '.')
+            return false;
+
+        if (pattern.size() < 2 || pattern[1] == '/' || pattern[1] == '\\')
+            return true;
+
+        if (pattern[1] != '.')
+            return false;
+
+        if (pattern.size() < 3 || pattern[2] == '/' || pattern[2] == '\\')
+            return true;
+
+        return false;
+    }
+
+    /**
+     * @brief Join a pattern with a base path.
+     *
+     * @param basepath The base path to join the pattern to.
+     * @param pattern The pattern to join.
+     * @return The pattern appended to the base path with a separator if the pattern is a relative
+     * path name, otherwise just returns pattern.
+     */
+    static std::string joinRelativePattern(const std::string &basepath, const std::string &pattern)
+    {
+        if (isRelativePattern(pattern))
+            return Path::join(basepath, pattern);
+        return pattern;
+    }
+
 private:
     friend class TestPathMatch;
     class PathIterator;
@@ -142,16 +181,16 @@ class CPPCHECKLIB PathMatch {
  **/
 class PathMatch::PathIterator {
 public:
-    /* Create from a pattern and base path, patterns must begin with '.' to be considered relative */
-    static PathIterator from_pattern(const std::string &pattern, const std::string &basepath, bool icase)
+    /* Create from a pattern and base path */
+    static PathIterator fromPattern(const std::string &pattern, const std::string &basepath, bool icase)
     {
-        if (!pattern.empty() && pattern[0] == '.')
+        if (isRelativePattern(pattern))
             return PathIterator(basepath.c_str(), pattern.c_str(), icase);
         return PathIterator(pattern.c_str(), nullptr, icase);
     }
 
     /* Create from path and base path */
-    static PathIterator from_path(const std::string &path, const std::string &basepath, bool icase)
+    static PathIterator fromPath(const std::string &path, const std::string &basepath, bool icase)
     {
         if (Path::isAbsolute(path))
             return PathIterator(path.c_str(), nullptr, icase);
@@ -270,7 +309,7 @@ class PathMatch::PathIterator {
                     nextc();
                     c = current();
                     if (c == '/') {
-                        /* Skip '<name>/../' */
+                        /* Skip 'dir/../' */
                         nextc();
                         skips(false);
                         while (mPos.l != 0 && current() != '/')