Issue 6378 - [emscripten] Make DependentString constexpr

compiled/String.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 43 matching lines @@
 
   static constexpr size_type FLAGS_MASK = 0xC0000000;
   static constexpr size_type LENGTH_MASK = 0x3FFFFFFF;
 
   static constexpr size_type npos = -1;
 
 protected:
   value_type* mBuf;
   size_type mLen;
 
-  explicit String(value_type* buf, size_type len, size_type flags)
+  constexpr explicit String(value_type* buf, size_type len, size_type flags)
       : mBuf(buf), mLen((len & LENGTH_MASK) | flags)
   {
   }
 
-  ~String()
-  {
-  }
+  ~String() = default;
 
   void reset(value_type* buf, size_type len, size_type flags)
   {
     mBuf = buf;
     mLen = (len & LENGTH_MASK) | flags;
   }
 
 public:
-  size_type length() const
+  constexpr size_type length() const
   {
     return mLen & LENGTH_MASK;
   }
 
-  bool empty() const
+  constexpr bool empty() const
   {
     return !(mLen & LENGTH_MASK);
   }
 
-  const value_type* data() const
+  constexpr const value_type* data() const
   {
     return mBuf;
   }
 
   value_type* data()
   {
     String_assert_writable(is_writable());
     return mBuf;
   }
 
   const value_type& operator[](size_type pos) const
   {
     return mBuf[pos];
   }
 
   value_type& operator[](size_type pos)
   {
     String_assert_writable(is_writable());
     return mBuf[pos];
   }
 
-  bool is_writable() const
+  constexpr bool is_writable() const
   {
     return (mLen & FLAGS_MASK) == READ_WRITE;
   }
 
   bool equals(const String& other) const
   {
     if (length() != other.length())
       return false;
 
     return std::memcmp(mBuf, other.mBuf, sizeof(value_type) * length()) == 0;
@@ skipping 49 matching lines @@
 
     if (pos >= length())
       pos = length() - 1;
 
     for (int i = pos; i >= 0; --i)
       if (mBuf[i] == c)
         return i;
     return npos;
   }
 
-  bool is_invalid() const
+  constexpr bool is_invalid() const
   {
     return (mLen & FLAGS_MASK) == INVALID;
   }
 
-  bool is_deleted() const
+  constexpr bool is_deleted() const
   {
     return (mLen & FLAGS_MASK) == DELETED;
   }
 
   void toLower()
   {
     size_type len = length();
     for (size_type i = 0; i < len; ++i)
     {
       value_type currChar = mBuf[i];
@@ skipping 21 matching lines @@
   std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
   os << converter.to_bytes(str.data(), str.data() + str.length());
 #endif
   return os;
 }
 #endif
 
 class DependentString : public String
 {
 public:
   explicit DependentString()

[sergei, 2018/03/14 16:22:53]

what about this one too?

[René Jeschke, 2018/03/14 16:27:07]

Is there a reason why we would want invalid nullptr constexpr strings? We can't
change them, so they would be absolutely useless.

If there's a use-case for those, I'll make this one constexpr, too.

[sergei, 2018/03/14 17:01:46]

It's difficult to say right now, and it's also up to a compiler as I guess, e.g.
it's used in containers (Map, Set), so maybe it would be safer to have it
constexpr too, so it does not accidentally prevent e.g. some global constant Map
from being constexpr.

       : String(nullptr, 0, INVALID)
   {
   }
 
+  template <int N1>
+  constexpr explicit DependentString(const value_type (&buf)[N1])
+      : String(const_cast<value_type*>(buf), N1 - 1, READ_ONLY)
+  {
+  }
+
   explicit DependentString(value_type* buf, size_type len)
       : String(buf, len, READ_WRITE)
   {
   }
 
   explicit DependentString(const value_type* buf, size_type len)
       : String(const_cast<value_type*>(buf), len, READ_ONLY)
   {
   }
 
@@ skipping 293 matching lines @@
   return OwnedString{value};
 }
 
 DependentString TrimSpaces(const String& value);
 
 // Splits the `value` string into two `DependentString`s excluding the character staying at `separatorPos`.
 // Useful for parsing.
 std::pair<DependentString, DependentString> SplitString(const String& value, String::size_type separatorPos);
 
 ABP_NS_END