refactor: replace bitmask enum with http_method from http_parser, list-based composite

- Remove AsyncWebRequestMethod namespace and bitmask enum
- #include <http_parser.h> (with __has_include fallback) for http_method enum;
  HTTP_GET, HTTP_POST, etc. now come directly from the platform, eliminating
  the source of name conflicts with Arduino core / esp-idf headers
- typedef http_method WebRequestMethod
- WebRequestMethodComposite: fixed-size list-based class (empty = match any);
  operator| builds the list, operator^ checks membership
- Remove ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS and ASYNCWEBSERVER_NO_HTTP_ANY
- HTTP_ALL = WebRequestMethodComposite() macro (always safe);
  HTTP_ANY = same but #ifndef-guarded (not defined if external macro exists)
- AsyncWebServerRequest::_method changed to WebRequestMethod (single method)
- method() return type changed to WebRequestMethod
- Fix constexpr static bool JsonHandlerMethods bug in AsyncJson.cpp (fix-400)
- All canHandle checks use operator^ instead of bitmask &

Co-authored-by: mathieucarbou <61346+mathieucarbou@users.noreply.github.com>

Author: Copilot

src/AsyncJson.cpp

@@ -112,19 +112,21 @@ size_t AsyncMessagePackResponse::_fillBuffer(uint8_t *data, size_t len) {
 #endif
 
 // Body handler supporting both content types: JSON and MessagePack
-constexpr static bool JsonHandlerMethods =
-  AsyncWebRequestMethod::HTTP_GET | AsyncWebRequestMethod::HTTP_POST | AsyncWebRequestMethod::HTTP_PUT | AsyncWebRequestMethod::HTTP_PATCH;
 
 #if ARDUINOJSON_VERSION_MAJOR == 6
 AsyncCallbackJsonWebHandler::AsyncCallbackJsonWebHandler(AsyncURIMatcher uri, ArJsonRequestHandlerFunction onRequest, size_t maxJsonBufferSize)
-  : _uri(std::move(uri)), _method(JsonHandlerTypes), _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {}
+  : _uri(std::move(uri)),
+    _method(HTTP_GET | HTTP_POST | HTTP_PUT | HTTP_PATCH),
+    _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {}
 #else
 AsyncCallbackJsonWebHandler::AsyncCallbackJsonWebHandler(AsyncURIMatcher uri, ArJsonRequestHandlerFunction onRequest)
-  : _uri(std::move(uri)), _method(JsonHandlerMethods), _onRequest(onRequest), _maxContentLength(16384) {}
+  : _uri(std::move(uri)),
+    _method(HTTP_GET | HTTP_POST | HTTP_PUT | HTTP_PATCH),
+    _onRequest(onRequest), _maxContentLength(16384) {}
 #endif
 
 bool AsyncCallbackJsonWebHandler::canHandle(AsyncWebServerRequest *request) const {
-  if (!_onRequest || !request->isHTTP() || !(_method & request->method())) {
+  if (!_onRequest || !request->isHTTP() || !(_method ^ request->method())) {
     return false;
   }
 
@@ -133,17 +135,17 @@ bool AsyncCallbackJsonWebHandler::canHandle(AsyncWebServerRequest *request) cons
   }
 
 #if ASYNC_MSG_PACK_SUPPORT == 1
-  return request->method() == AsyncWebRequestMethod::HTTP_GET || request->contentType().equalsIgnoreCase(asyncsrv::T_application_json)
+  return request->method() == HTTP_GET || request->contentType().equalsIgnoreCase(asyncsrv::T_application_json)
          || request->contentType().equalsIgnoreCase(asyncsrv::T_application_msgpack);
 #else
-  return request->method() == AsyncWebRequestMethod::HTTP_GET || request->contentType().equalsIgnoreCase(asyncsrv::T_application_json);
+  return request->method() == HTTP_GET || request->contentType().equalsIgnoreCase(asyncsrv::T_application_json);
 #endif
 }
 
 void AsyncCallbackJsonWebHandler::handleRequest(AsyncWebServerRequest *request) {
   if (_onRequest) {
     // GET request:
-    if (request->method() == AsyncWebRequestMethod::HTTP_GET) {
+    if (request->method() == HTTP_GET) {
       JsonVariant json;
       _onRequest(request, json);
       return;

src/ESPAsyncWebServer.h

@@ -45,6 +45,28 @@
 #error Platform not supported
 #endif
 
+// HTTP method enum from the underlying http_parser library.
+// All supported TCP libraries (AsyncTCP, ESPAsyncTCP, RPAsyncTCP) are built on
+// http_parser, so http_method is available on all supported platforms.
+// Using the platform's enum avoids redefining HTTP_GET, HTTP_POST, etc. ourselves,
+// which eliminates name conflicts with other libraries (e.g., Arduino WebServer.h).
+#if __has_include(<http_parser.h>)
+#  include <http_parser.h>
+#else
+// Fallback definition matching the llhttp/http_parser spec (used by all platforms).
+// This is provided only for toolchains that do not expose http_parser.h directly.
+typedef enum {
+  HTTP_DELETE = 0, HTTP_GET = 1, HTTP_HEAD = 2, HTTP_POST = 3, HTTP_PUT = 4,
+  HTTP_CONNECT = 5, HTTP_OPTIONS = 6, HTTP_TRACE = 7, HTTP_COPY = 8, HTTP_LOCK = 9,
+  HTTP_MKCOL = 10, HTTP_MOVE = 11, HTTP_PROPFIND = 12, HTTP_PROPPATCH = 13,
+  HTTP_SEARCH = 14, HTTP_UNLOCK = 15, HTTP_BIND = 16, HTTP_REBIND = 17,
+  HTTP_UNBIND = 18, HTTP_ACL = 19, HTTP_REPORT = 20, HTTP_MKACTIVITY = 21,
+  HTTP_CHECKOUT = 22, HTTP_MERGE = 23, HTTP_MSEARCH = 24, HTTP_NOTIFY = 25,
+  HTTP_SUBSCRIBE = 26, HTTP_UNSUBSCRIBE = 27, HTTP_PATCH = 28, HTTP_PURGE = 29,
+  HTTP_MKCALENDAR = 30, HTTP_LINK = 31, HTTP_UNLINK = 32,
+} http_method;
+#endif
+
 #include "AsyncWebServerVersion.h"
 #define ASYNCWEBSERVER_FORK_ESP32Async
 
@@ -78,61 +100,94 @@ class AsyncCallbackWebHandler;
 class AsyncResponseStream;
 class AsyncMiddlewareChain;
 
-// Namespace for web request method defines
-namespace AsyncWebRequestMethod {
-// The long name here is because we sometimes include this in the global namespace
-enum AsyncWebRequestMethodType {
-  HTTP_GET = 0b0000000000000001,
-  HTTP_POST = 0b0000000000000010,
-  HTTP_DELETE = 0b0000000000000100,
-  HTTP_PUT = 0b0000000000001000,
-  HTTP_PATCH = 0b0000000000010000,
-  HTTP_HEAD = 0b0000000000100000,
-  HTTP_OPTIONS = 0b0000000001000000,
-  HTTP_PROPFIND = 0b0000000010000000,
-  HTTP_LOCK = 0b0000000100000000,
-  HTTP_UNLOCK = 0b0000001000000000,
-  HTTP_PROPPATCH = 0b0000010000000000,
-  HTTP_MKCOL = 0b0000100000000000,
-  HTTP_MOVE = 0b0001000000000000,
-  HTTP_COPY = 0b0010000000000000,
-  HTTP_RESERVED = 0b0100000000000000,
-  HTTP_ALL = 0b0111111111111111,
-};
-};  // namespace AsyncWebRequestMethod
+// WebRequestMethod: a single HTTP request method, taken directly from the
+// platform's http_parser enum.  HTTP_GET, HTTP_POST, HTTP_DELETE, HTTP_PUT,
+// HTTP_PATCH, HTTP_HEAD, HTTP_OPTIONS, HTTP_PROPFIND, HTTP_LOCK, HTTP_UNLOCK,
+// HTTP_PROPPATCH, HTTP_MKCOL, HTTP_MOVE, HTTP_COPY and many others are already
+// defined globally by <http_parser.h> above — no redefinition needed here.
+typedef http_method WebRequestMethod;
+
+// WebRequestMethodComposite: an ordered list of HTTP methods that a handler
+// accepts.  An empty composite matches *any* method (HTTP_ANY / HTTP_ALL
+// semantics).  Using a list avoids bitmask arithmetic on the platform enum's
+// non-power-of-two sequential values.
+class WebRequestMethodComposite {
+public:
+  // Maximum number of methods that can be listed.  In practice, handlers
+  // accept at most a handful of methods; use the empty composite (HTTP_ALL)
+  // when you want to match any method.
+  static const uint8_t MAX_METHODS = 8;
 
-typedef AsyncWebRequestMethod::AsyncWebRequestMethodType WebRequestMethod;
-typedef uint16_t WebRequestMethodComposite;
+  // Empty composite = match any method.
+  WebRequestMethodComposite() : _count(0) {}
 
-// Type-safe helper functions for composite methods
-extern constexpr inline WebRequestMethodComposite operator|(WebRequestMethodComposite l, WebRequestMethod r) {
-  return l | static_cast<WebRequestMethodComposite>(r);
-};
-extern constexpr inline WebRequestMethodComposite operator|(WebRequestMethod l, WebRequestMethod r) {
-  return static_cast<WebRequestMethodComposite>(l) | r;
-};
+  // Single-method composite.  Intentionally implicit so that a bare
+  // WebRequestMethod (e.g. HTTP_GET) is accepted wherever a composite is
+  // expected.
+  WebRequestMethodComposite(WebRequestMethod m) : _count(1) {
+    _methods[0] = m;
+  }
 
-// HTTP_ANY is commonly defined as a macro in Arduino core HTTP client libraries (e.g., ESP8266 HTTPClient.h).
-// Macros are expanded by the preprocessor before C++ namespace resolution, so even a namespace-qualified
-// reference like AsyncWebRequestMethod::HTTP_ANY would be incorrectly expanded to AsyncWebRequestMethod::0.
-// To avoid this conflict, HTTP_ANY is provided here as a C++ constexpr (not a macro), after undefining
-// any previously defined HTTP_ANY macro. Use HTTP_ALL as the canonical non-conflicting name.
-// To suppress this behavior entirely (keeping any pre-existing HTTP_ANY macro and not providing the alias),
-// define ASYNCWEBSERVER_NO_HTTP_ANY before including this header.
-#if !defined(ASYNCWEBSERVER_NO_HTTP_ANY)
-#ifdef HTTP_ANY
-#warning \
-  "HTTP_ANY macro is already defined and will be undefined to avoid conflicts with ESPAsyncWebServer. To suppress this and keep the original macro, define ASYNCWEBSERVER_NO_HTTP_ANY and use AsyncWebRequestMethod::HTTP_ALL instead."
-#undef HTTP_ANY
-#endif
-namespace AsyncWebRequestMethod {
-static constexpr AsyncWebRequestMethodType HTTP_ANY = HTTP_ALL;
-}  // namespace AsyncWebRequestMethod
-#endif
+  // Append a method; silently ignores the call once MAX_METHODS is reached.
+  WebRequestMethodComposite &add(WebRequestMethod m) {
+    if (_count < MAX_METHODS) {
+      _methods[_count++] = m;
+    }
+    return *this;
+  }
+
+  // Returns true when this composite contains (or should match) the given
+  // method.  An empty composite matches any method.
+  bool contains(WebRequestMethod m) const {
+    if (_count == 0) return true;
+    for (uint8_t i = 0; i < _count; i++) {
+      if (_methods[i] == m) return true;
+    }
+    return false;
+  }
+
+  // Equality: true when the composite holds exactly this one method.
+  bool operator==(WebRequestMethod m) const {
+    return _count == 1 && _methods[0] == m;
+  }
+  bool operator!=(WebRequestMethod m) const { return !(*this == m); }
+
+  // True when this is an empty (match-any) composite.
+  bool empty() const { return _count == 0; }
+
+private:
+  WebRequestMethod _methods[MAX_METHODS];
+  uint8_t _count;
+};
 
-#if !defined(ASYNCWEBSERVER_NO_GLOBAL_HTTP_METHODS)
-// Import the method enum values to the global namespace
-using namespace AsyncWebRequestMethod;
+// Build a composite from two individual methods: HTTP_GET | HTTP_POST
+inline WebRequestMethodComposite operator|(WebRequestMethod l, WebRequestMethod r) {
+  WebRequestMethodComposite c;
+  c.add(l).add(r);
+  return c;
+}
+
+// Extend a composite with one more method: (HTTP_GET | HTTP_POST) | HTTP_PUT
+inline WebRequestMethodComposite operator|(WebRequestMethodComposite c, WebRequestMethod r) {
+  c.add(r);
+  return c;
+}
+
+// Membership test: returns true when composite c contains method m.
+// Usage: if (handler._method ^ request->method()) { /* matched */ }
+inline bool operator^(const WebRequestMethodComposite &c, WebRequestMethod m) {
+  return c.contains(m);
+}
+
+// HTTP_ALL: empty composite — matches any HTTP method.
+// HTTP_ANY: backward-compatible alias for HTTP_ALL.
+// HTTP_ANY is only defined here when external headers have not already defined
+// it as a macro (e.g., Arduino core may define HTTP_ANY as an integer).  When
+// an external macro is present the name remains an integer; user code should
+// migrate to HTTP_ALL which is always safe.
+#define HTTP_ALL WebRequestMethodComposite()
+#ifndef HTTP_ANY
+#define HTTP_ANY WebRequestMethodComposite()
 #endif
 
 #ifndef HAVE_FS_FILE_OPEN_MODE
@@ -283,7 +338,7 @@ class AsyncWebServerRequest {
   uint8_t _parseState;
 
   uint8_t _version;
-  WebRequestMethodComposite _method;
+  WebRequestMethod _method;
   String _url;
   String _host;
   String _contentType;
@@ -373,7 +428,7 @@ class AsyncWebServerRequest {
   uint8_t version() const {
     return _version;
   }
-  WebRequestMethodComposite method() const {
+  WebRequestMethod method() const {
     return _method;
   }
   const String &url() const {
@@ -401,10 +456,10 @@ class AsyncWebServerRequest {
   bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED)
     const;
   bool isWebSocketUpgrade() const {
-    return _method == AsyncWebRequestMethod::HTTP_GET && isExpectedRequestedConnType(RCT_WS);
+    return _method == HTTP_GET && isExpectedRequestedConnType(RCT_WS);
   }
   bool isSSE() const {
-    return _method == AsyncWebRequestMethod::HTTP_GET && isExpectedRequestedConnType(RCT_EVENT);
+    return _method == HTTP_GET && isExpectedRequestedConnType(RCT_EVENT);
   }
   bool isHTTP() const {
     return isExpectedRequestedConnType(RCT_DEFAULT, RCT_HTTP);
@@ -1574,7 +1629,7 @@ class AsyncWebServer : public AsyncMiddlewareChain {
   bool removeHandler(AsyncWebHandler *handler);
 
   AsyncCallbackWebHandler &on(AsyncURIMatcher uri, ArRequestHandlerFunction onRequest) {
-    return on(std::move(uri), AsyncWebRequestMethod::HTTP_ALL, onRequest);
+    return on(std::move(uri), HTTP_ALL, onRequest);
   }
   AsyncCallbackWebHandler &on(
     AsyncURIMatcher uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload = nullptr,

src/Middleware.cpp

@@ -249,7 +249,7 @@ void AsyncCorsMiddleware::run(AsyncWebServerRequest *request, ArMiddlewareNext n
   // Origin header ? => CORS handling
   if (request->hasHeader(asyncsrv::T_CORS_O)) {
     // check if this is a preflight request => handle it and return
-    if (request->method() == AsyncWebRequestMethod::HTTP_OPTIONS) {
+    if (request->method() == HTTP_OPTIONS) {
       AsyncWebServerResponse *response = request->beginResponse(200);
       addCORSHeaders(request, response);
       request->send(response);

src/WebHandlerImpl.h

@@ -62,7 +62,7 @@ class AsyncCallbackWebHandler : public AsyncWebHandler {
   bool _isRegex;
 
 public:
-  AsyncCallbackWebHandler() : _uri(), _method(AsyncWebRequestMethod::HTTP_ALL), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {}
+  AsyncCallbackWebHandler() : _uri(), _method(), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {}
   void setUri(AsyncURIMatcher uri);
   void setMethod(WebRequestMethodComposite method) {
     _method = method;

src/WebHandlers.cpp

@@ -103,7 +103,7 @@ AsyncStaticWebHandler &AsyncStaticWebHandler::setLastModified() {
 }
 
 bool AsyncStaticWebHandler::canHandle(AsyncWebServerRequest *request) const {
-  return request->isHTTP() && request->method() == AsyncWebRequestMethod::HTTP_GET && request->url().startsWith(_uri) && _getFile(request);
+  return request->isHTTP() && request->method() == HTTP_GET && request->url().startsWith(_uri) && _getFile(request);
 }
 
 bool AsyncStaticWebHandler::_getFile(AsyncWebServerRequest *request) const {
@@ -300,7 +300,7 @@ void AsyncCallbackWebHandler::setUri(AsyncURIMatcher uri) {
 }
 
 bool AsyncCallbackWebHandler::canHandle(AsyncWebServerRequest *request) const {
-  if (!_onRequest || !request->isHTTP() || !(_method & request->method())) {
+  if (!_onRequest || !request->isHTTP() || !(_method ^ request->method())) {
     return false;
   }
   return _uri.matches(request);