couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/json/include/tao/json/external/pegtl/change_control.hpp

@@ -23,9 +23,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          return TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, NewControl >( in, st... );
       }

data/ext/third_party/json/include/tao/json/external/pegtl/change_state.hpp

@@ -23,23 +23,23 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
-         NewState s( static_cast< const Input& >( in ), st... );
+         NewState s( static_cast< const ParseInput& >( in ), st... );
          if( TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, s ) ) {
             if constexpr( A == apply_mode::action ) {
-               Action< Rule >::success( static_cast< const Input& >( in ), s, st... );
+               Action< Rule >::success( static_cast< const ParseInput& >( in ), s, st... );
             }
             return true;
          }
          return false;
       }
 
-      template< typename Input,
+      template< typename ParseInput,
                 typename... States >
-      static void success( const Input& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
+      static void success( const ParseInput& in, NewState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
       {
          s.success( in, st... );
       }

data/ext/third_party/json/include/tao/json/external/pegtl/change_states.hpp

@@ -27,14 +27,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 template< typename... >
                 class Control,
                 std::size_t... Ns,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( std::index_sequence< Ns... > /*unused*/, Input& in, States&&... st )
+      [[nodiscard]] static bool match( std::index_sequence< Ns... > /*unused*/, ParseInput& in, States&&... st )
       {
          auto t = std::tie( st... );
          if( TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, std::get< Ns >( t )... ) ) {
             if constexpr( A == apply_mode::action ) {
-               Action< Rule >::success( static_cast< const Input& >( in ), st... );
+               Action< Rule >::success( static_cast< const ParseInput& >( in ), st... );
             }
             return true;
          }
@@ -48,9 +48,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          return match< Rule, A, M, Action, Control >( std::index_sequence_for< NewStates... >(), in, NewStates()..., st... );
       }

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/alphabet.hpp

@@ -8,59 +8,59 @@
 
 namespace TAO_JSON_PEGTL_NAMESPACE::alphabet
 {
-   static const int a = 'a';
-   static const int b = 'b';
-   static const int c = 'c';
-   static const int d = 'd';
-   static const int e = 'e';
-   static const int f = 'f';
-   static const int g = 'g';
-   static const int h = 'h';
-   static const int i = 'i';
-   static const int j = 'j';
-   static const int k = 'k';
-   static const int l = 'l';
-   static const int m = 'm';
-   static const int n = 'n';
-   static const int o = 'o';
-   static const int p = 'p';
-   static const int q = 'q';
-   static const int r = 'r';
-   static const int s = 's';
-   static const int t = 't';
-   static const int u = 'u';
-   static const int v = 'v';
-   static const int w = 'w';
-   static const int x = 'x';
-   static const int y = 'y';
-   static const int z = 'z';
+   static const char a = 'a';
+   static const char b = 'b';
+   static const char c = 'c';
+   static const char d = 'd';
+   static const char e = 'e';
+   static const char f = 'f';
+   static const char g = 'g';
+   static const char h = 'h';
+   static const char i = 'i';
+   static const char j = 'j';
+   static const char k = 'k';
+   static const char l = 'l';
+   static const char m = 'm';
+   static const char n = 'n';
+   static const char o = 'o';
+   static const char p = 'p';
+   static const char q = 'q';
+   static const char r = 'r';
+   static const char s = 's';
+   static const char t = 't';
+   static const char u = 'u';
+   static const char v = 'v';
+   static const char w = 'w';
+   static const char x = 'x';
+   static const char y = 'y';
+   static const char z = 'z';
 
-   static const int A = 'A';  // NOLINT(readability-identifier-naming)
-   static const int B = 'B';  // NOLINT(readability-identifier-naming)
-   static const int C = 'C';  // NOLINT(readability-identifier-naming)
-   static const int D = 'D';  // NOLINT(readability-identifier-naming)
-   static const int E = 'E';  // NOLINT(readability-identifier-naming)
-   static const int F = 'F';  // NOLINT(readability-identifier-naming)
-   static const int G = 'G';  // NOLINT(readability-identifier-naming)
-   static const int H = 'H';  // NOLINT(readability-identifier-naming)
-   static const int I = 'I';  // NOLINT(readability-identifier-naming)
-   static const int J = 'J';  // NOLINT(readability-identifier-naming)
-   static const int K = 'K';  // NOLINT(readability-identifier-naming)
-   static const int L = 'L';  // NOLINT(readability-identifier-naming)
-   static const int M = 'M';  // NOLINT(readability-identifier-naming)
-   static const int N = 'N';  // NOLINT(readability-identifier-naming)
-   static const int O = 'O';  // NOLINT(readability-identifier-naming)
-   static const int P = 'P';  // NOLINT(readability-identifier-naming)
-   static const int Q = 'Q';  // NOLINT(readability-identifier-naming)
-   static const int R = 'R';  // NOLINT(readability-identifier-naming)
-   static const int S = 'S';  // NOLINT(readability-identifier-naming)
-   static const int T = 'T';  // NOLINT(readability-identifier-naming)
-   static const int U = 'U';  // NOLINT(readability-identifier-naming)
-   static const int V = 'V';  // NOLINT(readability-identifier-naming)
-   static const int W = 'W';  // NOLINT(readability-identifier-naming)
-   static const int X = 'X';  // NOLINT(readability-identifier-naming)
-   static const int Y = 'Y';  // NOLINT(readability-identifier-naming)
-   static const int Z = 'Z';  // NOLINT(readability-identifier-naming)
+   static const char A = 'A';  // NOLINT(readability-identifier-naming)
+   static const char B = 'B';  // NOLINT(readability-identifier-naming)
+   static const char C = 'C';  // NOLINT(readability-identifier-naming)
+   static const char D = 'D';  // NOLINT(readability-identifier-naming)
+   static const char E = 'E';  // NOLINT(readability-identifier-naming)
+   static const char F = 'F';  // NOLINT(readability-identifier-naming)
+   static const char G = 'G';  // NOLINT(readability-identifier-naming)
+   static const char H = 'H';  // NOLINT(readability-identifier-naming)
+   static const char I = 'I';  // NOLINT(readability-identifier-naming)
+   static const char J = 'J';  // NOLINT(readability-identifier-naming)
+   static const char K = 'K';  // NOLINT(readability-identifier-naming)
+   static const char L = 'L';  // NOLINT(readability-identifier-naming)
+   static const char M = 'M';  // NOLINT(readability-identifier-naming)
+   static const char N = 'N';  // NOLINT(readability-identifier-naming)
+   static const char O = 'O';  // NOLINT(readability-identifier-naming)
+   static const char P = 'P';  // NOLINT(readability-identifier-naming)
+   static const char Q = 'Q';  // NOLINT(readability-identifier-naming)
+   static const char R = 'R';  // NOLINT(readability-identifier-naming)
+   static const char S = 'S';  // NOLINT(readability-identifier-naming)
+   static const char T = 'T';  // NOLINT(readability-identifier-naming)
+   static const char U = 'U';  // NOLINT(readability-identifier-naming)
+   static const char V = 'V';  // NOLINT(readability-identifier-naming)
+   static const char W = 'W';  // NOLINT(readability-identifier-naming)
+   static const char X = 'X';  // NOLINT(readability-identifier-naming)
+   static const char Y = 'Y';  // NOLINT(readability-identifier-naming)
+   static const char Z = 'Z';  // NOLINT(readability-identifier-naming)
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::alphabet
 

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/analyze.hpp

@@ -0,0 +1,176 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_ANALYZE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_ANALYZE_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iostream>
+#include <map>
+#include <set>
+#include <stdexcept>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "../config.hpp"
+#include "../demangle.hpp"
+
+#include "analyze_traits.hpp"
+
+#include "internal/set_stack_guard.hpp"
+
+#include "../internal/dependent_false.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      struct analyze_entry
+      {
+         explicit analyze_entry( const analyze_type in_type ) noexcept
+            : type( in_type )
+         {}
+
+         const analyze_type type;
+         std::vector< std::string_view > subs;
+      };
+
+      class analyze_cycles_impl
+      {
+      public:
+         analyze_cycles_impl( analyze_cycles_impl&& ) = delete;
+         analyze_cycles_impl( const analyze_cycles_impl& ) = delete;
+
+         ~analyze_cycles_impl() = default;
+
+         void operator=( analyze_cycles_impl&& ) = delete;
+         void operator=( const analyze_cycles_impl& ) = delete;
+
+         [[nodiscard]] std::size_t problems()
+         {
+            for( auto i = m_info.begin(); i != m_info.end(); ++i ) {
+               m_results[ i->first ] = work( i, false );
+               m_cache.clear();
+            }
+            return m_problems;
+         }
+
+         template< typename Rule >
+         [[nodiscard]] bool consumes() const
+         {
+            return m_results.at( demangle< Rule >() );
+         }
+
+      protected:
+         explicit analyze_cycles_impl( const bool verbose ) noexcept
+            : m_verbose( verbose ),
+              m_problems( 0 )
+         {}
+
+         [[nodiscard]] std::map< std::string_view, analyze_entry >::const_iterator find( const std::string_view name ) const noexcept
+         {
+            const auto iter = m_info.find( name );
+            assert( iter != m_info.end() );
+            return iter;
+         }
+
+         [[nodiscard]] bool work( const std::map< std::string_view, analyze_entry >::const_iterator& start, const bool accum )
+         {
+            if( const auto j = m_cache.find( start->first ); j != m_cache.end() ) {
+               return j->second;
+            }
+            if( const auto g = set_stack_guard( m_stack, start->first ) ) {
+               switch( start->second.type ) {
+                  case analyze_type::any: {
+                     bool a = false;
+                     for( const auto& r : start->second.subs ) {
+                        a = a || work( find( r ), accum || a );
+                     }
+                     return m_cache[ start->first ] = true;
+                  }
+                  case analyze_type::opt: {
+                     bool a = false;
+                     for( const auto& r : start->second.subs ) {
+                        a = a || work( find( r ), accum || a );
+                     }
+                     return m_cache[ start->first ] = false;
+                  }
+                  case analyze_type::seq: {
+                     bool a = false;
+                     for( const auto& r : start->second.subs ) {
+                        a = a || work( find( r ), accum || a );
+                     }
+                     return m_cache[ start->first ] = a;
+                  }
+                  case analyze_type::sor: {
+                     bool a = true;
+                     for( const auto& r : start->second.subs ) {
+                        a = a && work( find( r ), accum );
+                     }
+                     return m_cache[ start->first ] = a;
+                  }
+               }
+               assert( false );  // LCOV_EXCL_LINE
+            }
+            if( !accum ) {
+               ++m_problems;
+               if( m_verbose ) {
+                  std::cerr << "problem: cycle without progress detected at rule class " << start->first << std::endl;  // LCOV_EXCL_LINE
+               }
+            }
+            return m_cache[ start->first ] = accum;
+         }
+
+         const bool m_verbose;
+
+         std::size_t m_problems;
+
+         std::map< std::string_view, analyze_entry > m_info;
+         std::set< std::string_view > m_stack;
+         std::map< std::string_view, bool > m_cache;
+         std::map< std::string_view, bool > m_results;
+      };
+
+      template< typename Name >
+      std::string_view analyze_insert( std::map< std::string_view, analyze_entry >& info )
+      {
+         using Traits = analyze_traits< Name, typename Name::rule_t >;
+
+         const auto [ i, b ] = info.try_emplace( demangle< Name >(), Traits::type_v );
+         if( b ) {
+            analyze_insert_impl( typename Traits::subs_t(), i->second.subs, info );
+         }
+         return i->first;
+      }
+
+      template< typename... Subs >
+      void analyze_insert_impl( type_list< Subs... > /*unused*/, std::vector< std::string_view >& subs, std::map< std::string_view, analyze_entry >& info )
+      {
+         ( subs.emplace_back( analyze_insert< Subs >( info ) ), ... );
+      }
+
+      template< typename Grammar >
+      class analyze_cycles
+         : public analyze_cycles_impl
+      {
+      public:
+         explicit analyze_cycles( const bool verbose )
+            : analyze_cycles_impl( verbose )
+         {
+            analyze_insert< Grammar >( m_info );
+         }
+      };
+
+   }  // namespace internal
+
+   template< typename Grammar >
+   [[nodiscard]] std::size_t analyze( const bool verbose = true )
+   {
+      return internal::analyze_cycles< Grammar >( verbose ).problems();
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/analyze_traits.hpp

@@ -0,0 +1,275 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_ANALYZE_TRAITS_HPP
+#define TAO_JSON_PEGTL_CONTRIB_ANALYZE_TRAITS_HPP
+
+#include <type_traits>
+
+#include "../ascii.hpp"
+#include "../config.hpp"
+#include "../rules.hpp"
+#include "../type_list.hpp"
+
+#include "forward.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      enum class analyze_type
+      {
+         any,  // Consumption-on-success is always true; assumes bounded repetition of conjunction of sub-rules.
+         opt,  // Consumption-on-success not necessarily true; assumes bounded repetition of conjunction of sub-rules.
+         seq,  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) conjunction of sub-rules.
+         sor   // Consumption-on-success depends on consumption of (non-zero bounded repetition of) disjunction of sub-rules.
+      };
+
+   }  // namespace internal
+
+   template< typename... Rules >
+   struct analyze_any_traits
+   {
+      static constexpr internal::analyze_type type_v = internal::analyze_type::any;
+      using subs_t = type_list< Rules... >;
+   };
+
+   template< typename... Rules >
+   struct analyze_opt_traits
+   {
+      static constexpr internal::analyze_type type_v = internal::analyze_type::opt;
+      using subs_t = type_list< Rules... >;
+   };
+
+   template< typename... Rules >
+   struct analyze_seq_traits
+   {
+      static constexpr internal::analyze_type type_v = internal::analyze_type::seq;
+      using subs_t = type_list< Rules... >;
+   };
+
+   template< typename... Rules >
+   struct analyze_sor_traits
+   {
+      static constexpr internal::analyze_type type_v = internal::analyze_type::sor;
+      using subs_t = type_list< Rules... >;
+   };
+
+   template< typename Name, template< typename... > class Action, typename... Rules >
+   struct analyze_traits< Name, internal::action< Action, Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename Peek >
+   struct analyze_traits< Name, internal::any< Peek > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename... Actions >
+   struct analyze_traits< Name, internal::apply< Actions... > >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, typename... Actions >
+   struct analyze_traits< Name, internal::apply0< Actions... > >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::at< Rules... > >
+      : analyze_traits< Name, typename opt< Rules... >::rule_t >
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::bof >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::bol >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, unsigned Cnt >
+   struct analyze_traits< Name, internal::bytes< Cnt > >
+      : std::conditional_t< ( Cnt != 0 ), analyze_any_traits<>, analyze_opt_traits<> >
+   {};
+
+   template< typename Name, template< typename... > class Control, typename... Rules >
+   struct analyze_traits< Name, internal::control< Control, Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::disable< Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::discard >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::enable< Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::eof >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::eol >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::eolf >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::failure >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Rule, typename... Actions >
+   struct analyze_traits< Name, internal::if_apply< Rule, Actions... > >
+      : analyze_traits< Name, typename Rule::rule_t >
+   {};
+
+   template< typename Name, typename Cond, typename... Rules >
+   struct analyze_traits< Name, internal::if_must< true, Cond, Rules... > >
+      : analyze_traits< Name, typename opt< Cond, Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename Cond, typename... Rules >
+   struct analyze_traits< Name, internal::if_must< false, Cond, Rules... > >
+      : analyze_traits< Name, typename seq< Cond, Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename Cond, typename Then, typename Else >
+   struct analyze_traits< Name, internal::if_then_else< Cond, Then, Else > >
+      : analyze_traits< Name, typename sor< seq< Cond, Then >, Else >::rule_t >
+   {};
+
+   template< typename Name, char... Cs >
+   struct analyze_traits< Name, internal::istring< Cs... > >
+      : std::conditional_t< ( sizeof...( Cs ) != 0 ), analyze_any_traits<>, analyze_opt_traits<> >
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::must< Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::not_at< Rules... > >
+      : analyze_traits< Name, typename opt< Rules... >::rule_t >
+   {};
+
+   template< typename Name, internal::result_on_found R, typename Peek, typename Peek::data_t... Cs >
+   struct analyze_traits< Name, internal::one< R, Peek, Cs... > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Rule, typename... Rules >
+   struct analyze_traits< Name, internal::opt< Rule, Rules... > >
+      : analyze_opt_traits< Rule, Rules... >
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::plus< Rules... > >
+      : analyze_traits< Name, typename seq< Rules..., opt< Name > >::rule_t >
+   {};
+
+   template< typename Name, typename T >
+   struct analyze_traits< Name, internal::raise< T > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, internal::result_on_found R, typename Peek, typename Peek::data_t Lo, typename Peek::data_t Hi >
+   struct analyze_traits< Name, internal::range< R, Peek, Lo, Hi > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Peek, typename Peek::data_t... Cs >
+   struct analyze_traits< Name, internal::ranges< Peek, Cs... > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, typename Head, typename... Rules >
+   struct analyze_traits< Name, internal::rematch< Head, Rules... > >
+      : analyze_traits< Name, typename sor< Head, sor< seq< Rules, any >... > >::rule_t >  // TODO: Correct (enough)?
+   {};
+
+   template< typename Name, unsigned Cnt, typename... Rules >
+   struct analyze_traits< Name, internal::rep< Cnt, Rules... > >
+      : analyze_traits< Name, std::conditional_t< ( Cnt != 0 ), typename seq< Rules... >::rule_t, typename opt< Rules... >::rule_t > >
+   {};
+
+   template< typename Name, unsigned Min, unsigned Max, typename... Rules >
+   struct analyze_traits< Name, internal::rep_min_max< Min, Max, Rules... > >
+      : analyze_traits< Name, std::conditional_t< ( Min != 0 ), typename seq< Rules... >::rule_t, typename opt< Rules... >::rule_t > >
+   {};
+
+   template< typename Name, unsigned Max, typename... Rules >
+   struct analyze_traits< Name, internal::rep_opt< Max, Rules... > >
+      : analyze_traits< Name, typename opt< Rules... >::rule_t >
+   {};
+
+   template< typename Name, unsigned Amount >
+   struct analyze_traits< Name, internal::require< Amount > >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, typename Rule, typename... Rules >
+   struct analyze_traits< Name, internal::seq< Rule, Rules... > >
+      : analyze_seq_traits< Rule, Rules... >
+   {};
+
+   template< typename Name, typename Rule, typename... Rules >
+   struct analyze_traits< Name, internal::sor< Rule, Rules... > >
+      : analyze_sor_traits< Rule, Rules... >
+   {};
+
+   template< typename Name, typename... Rules >
+   struct analyze_traits< Name, internal::star< Rules... > >
+      : analyze_traits< Name, typename opt< Rules..., Name >::rule_t >
+   {};
+
+   template< typename Name, typename State, typename... Rules >
+   struct analyze_traits< Name, internal::state< State, Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name, char... Cs >
+   struct analyze_traits< Name, internal::string< Cs... > >
+      : std::conditional_t< ( sizeof...( Cs ) != 0 ), analyze_any_traits<>, analyze_opt_traits<> >
+   {};
+
+   template< typename Name >
+   struct analyze_traits< Name, internal::success >
+      : analyze_opt_traits<>
+   {};
+
+   template< typename Name, typename Exception, typename... Rules >
+   struct analyze_traits< Name, internal::try_catch_type< Exception, Rules... > >
+      : analyze_traits< Name, typename seq< Rules... >::rule_t >
+   {};
+
+   template< typename Name, typename Cond >
+   struct analyze_traits< Name, internal::until< Cond > >
+      : analyze_traits< Name, typename Cond::rule_t >
+   {};
+
+   template< typename Name, typename Cond, typename... Rules >
+   struct analyze_traits< Name, internal::until< Cond, Rules... > >
+      : analyze_traits< Name, typename seq< star< Rules... >, Cond >::rule_t >
+   {};
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif