Add cpp_dependent_type

include/cppast/cpp_type.hpp

@@ -30,6 +30,8 @@ namespace cppast
         template_parameter,
         template_instantiation,
 
+        dependent,
+
         unexposed,
     };
 
@@ -174,6 +176,50 @@ namespace cppast
         cpp_type_ref entity_;
     };
 
+    class cpp_template_parameter_type;
+    class cpp_template_instantiation_type;
+
+    /// A [cppast::cpp_type]() that depends on another type.
+    class cpp_dependent_type final : public cpp_type
+    {
+    public:
+        /// \returns A newly created type dependent on a [cppast::cpp_template_parameter_type]().
+        static std::unique_ptr<cpp_dependent_type> build(
+            std::string name, std::unique_ptr<cpp_template_parameter_type> dependee);
+
+        /// \returns A newly created type dependent on a [cppast::cpp_template_instantiation_type]().
+        static std::unique_ptr<cpp_dependent_type> build(
+            std::string name, std::unique_ptr<cpp_template_instantiation_type> dependee);
+
+        /// \returns The name of the dependent type.
+        /// \notes It does not include a scope.
+        const std::string& name() const noexcept
+        {
+            return name_;
+        }
+
+        /// \returns A reference to the [cppast::cpp_type]() it depends one.
+        /// \notes This is either [cppast::cpp_template_parameter_type]() or [cppast:cpp_template_instantiation_type]().
+        const cpp_type& dependee() const noexcept
+        {
+            return *dependee_;
+        }
+
+    private:
+        cpp_dependent_type(std::string name, std::unique_ptr<cpp_type> dependee)
+        : name_(std::move(name)), dependee_(std::move(dependee))
+        {
+        }
+
+        cpp_type_kind do_get_kind() const noexcept override
+        {
+            return cpp_type_kind::dependent;
+        }
+
+        std::string               name_;
+        std::unique_ptr<cpp_type> dependee_;
+    };
+
     /// The kinds of C++ cv qualifiers.
     enum cpp_cv
     {

src/cpp_type.cpp

@@ -8,6 +8,7 @@
 #include <cppast/cpp_entity.hpp>
 #include <cppast/cpp_entity_kind.hpp>
 #include <cppast/cpp_function_type.hpp>
+#include <cppast/cpp_template.hpp>
 
 using namespace cppast;
 
@@ -16,6 +17,20 @@ bool detail::cpp_type_ref_predicate::operator()(const cpp_entity& e)
     return is_type(e.kind());
 }
 
+std::unique_ptr<cpp_dependent_type> cpp_dependent_type::build(
+    std::string name, std::unique_ptr<cpp_template_parameter_type> dependee)
+{
+    return std::unique_ptr<cpp_dependent_type>(
+        new cpp_dependent_type(std::move(name), std::move(dependee)));
+}
+
+std::unique_ptr<cpp_dependent_type> cpp_dependent_type::build(
+    std::string name, std::unique_ptr<cpp_template_instantiation_type> dependee)
+{
+    return std::unique_ptr<cpp_dependent_type>(
+        new cpp_dependent_type(std::move(name), std::move(dependee)));
+}
+
 namespace
 {
     bool can_compose(const cpp_type& type)
@@ -99,6 +114,12 @@ bool cppast::is_valid(const cpp_type& type) noexcept
         return is_valid(obj.object_type());
     }
 
+    case cpp_type_kind::dependent:
+    {
+        auto& dep = static_cast<const cpp_dependent_type&>(type);
+        return is_valid(dep.dependee());
+    }
+
     case cpp_type_kind::builtin:
     case cpp_type_kind::user_defined:
     case cpp_type_kind::template_parameter: