chore: xml generator support for new types + cleanup

Author: sdkrystian

source/-XML/CXXTags.hpp

@@ -185,43 +185,138 @@ inline void write(VariableFlags0 const& bits, XMLTags& tags)
     fw.write(&VariableFlags0::storageClass, "storage-class");
 }
 
-inline void writeReturnType(TypeInfo const& I, XMLTags& tags)
+inline
+void
+writeTemplateArg(const TArg& I, XMLTags& tags);
+
+inline
+void
+writeType(
+    TypeInfo const& I,
+    XMLTags& tags,
+    std::string_view type_tag = "type")
 {
-#if 0
-    if(I.Name == "void")
-        return;
-    tags.write(returnTagName, {}, {
-        { "type", I.Name },
-        { I.id }
+    visit(I, [&]<typename T>(
+        const T& t)
+        {
+            Attributes attrs = {
+                { "class", toString(T::kind_id),
+                    T::kind_id != TypeKind::Builtin }
+            };
+
+            if constexpr(requires { t.id; })
+            {
+                attrs.push({t.id});
+            }
+
+            // KRYSTIAN FIXME: parent should is a type itself
+            if constexpr(requires { t.ParentType; })
+            {
+                if(t.ParentType)
+                    attrs.push({"parent", toString(*t.ParentType)});
+            }
+
+            if constexpr(requires { t.Name; })
+            {
+                attrs.push({"name", t.Name});
+            }
+
+            if constexpr(requires { t.CVQualifiers; })
+            {
+                if(t.CVQualifiers != QualifierKind::None)
+                    attrs.push({"cv-qualifiers", toString(t.CVQualifiers)});
+            }
+
+            if constexpr(T::isArray())
+            {
+                if(! t.BoundsValue.empty())
+                    attrs.push({"bounds-value", t.BoundsValue});
+                if(t.BoundsValue != t.BoundsExpr &&
+                    ! t.BoundsExpr.empty())
+                    attrs.push({"bounds-expr", t.BoundsExpr});
+            }
+
+            if constexpr(T::isFunction())
+            {
+                if(t.RefQualifier != ReferenceKind::None)
+                    attrs.push({"ref-qualifier", toString(t.RefQualifier)});
+
+                if(t.ExceptionSpec != NoexceptKind::None)
+                    attrs.push({"exception-spec", toString(t.ExceptionSpec)});
+            }
+
+            // ----------------------------------------------------------------
+
+            // no nested types; write as self closing tag
+            if constexpr(T::isBuiltin() || T::isTag())
+            {
+                tags.write(type_tag, {}, std::move(attrs));
+                return;
+            }
+
+            tags.open(type_tag, std::move(attrs));
+
+            if constexpr(T::isSpecialization())
+            {
+                for(const auto& targ : t.TemplateArgs)
+                    writeTemplateArg(targ, tags);
+            }
+
+            if constexpr(requires { t.PointeeType; })
+            {
+                writeType(*t.PointeeType, tags, "pointee-type");
+            }
+
+            if constexpr(T::isPack())
+            {
+                writeType(*t.PatternType, tags, "pattern-type");
+            }
+
+            if constexpr(T::isArray())
+            {
+                writeType(*t.ElementType, tags, "element-type");
+            }
+
+            if constexpr(T::isFunction())
+            {
+                writeType(*t.ReturnType, tags, "return-type");
+                for(const auto& p : t.ParamTypes)
+                    writeType(*p, tags, "param-type");
+            }
+
+            tags.close(type_tag);
         });
-#else
-    std::string type_str = toString(I);
-    if(type_str == "void")
+}
+
+inline
+void
+writeType(
+    const std::unique_ptr<TypeInfo>& type,
+    XMLTags& tags)
+{
+    if(! type)
         return;
-    tags.write(returnTagName, {}, {
-        { "type", type_str },
-        // { I.id }
-        });
-#endif
+    writeType(*type, tags);
+}
+
+inline void writeReturnType(TypeInfo const& I, XMLTags& tags)
+{
+    // KRYSTIAN NOTE: we don't *have* to do this...
+    if(toString(I) == "void")
+        return;
+    tags.open(returnTagName);
+    writeType(I, tags);
+    tags.close(returnTagName);
 }
 
 inline void writeParam(Param const& P, XMLTags& tags)
 {
-#if 0
-    tags.write(paramTagName, {}, {
+    tags.open(paramTagName, {
         { "name", P.Name, ! P.Name.empty() },
-        { "type", P.Type.Name },
         { "default", P.Default, ! P.Default.empty() },
-        { P.Type.id } });
-#else
-    std::string type_str = toString(*P.Type);
-    tags.write(paramTagName, {}, {
-        { "name", P.Name, ! P.Name.empty() },
-        { "type", type_str },
-        { "default", P.Default, ! P.Default.empty() },
-        // { P.Type.id }
         });
-#endif
+    writeType(*P.Type, tags);
+    tags.close(paramTagName);
 }
 
 inline void writeTemplateParam(const TParam& I, XMLTags& tags)
@@ -231,15 +326,10 @@ inline void writeTemplateParam(const TParam& I, XMLTags& tags)
     case TParamKind::Type:
     {
         const auto& t = I.get<TypeTParam>();
-#if 0
-        std::string_view default_val;
-        if(t.Default)
-            default_val = t.Default->Name;
-#else
+
         std::string default_val;
         if(t.Default)
             default_val = toString(*t.Default);
-#endif
 
         tags.write(tparamTagName, {}, {
             { "name", I.Name, ! I.Name.empty() },
@@ -258,11 +348,8 @@ inline void writeTemplateParam(const TParam& I, XMLTags& tags)
         tags.write(tparamTagName, {}, {
             { "name", I.Name, ! I.Name.empty() },
             { "class", "non-type" },
-#if 0
-            { "type", t.Type.Name },
-#else
+            // KRYSTIAN FIXME: we can use writeType if really care
             { "type", toString(*t.Type) },
-#endif
             { "default", default_val, ! default_val.empty() }
         });
         break;

source/-XML/XMLTags.cpp

@@ -101,17 +101,45 @@ toString(
 
 Attributes::
 Attributes(
-    std::initializer_list<Attribute> init)
-    : init_(init)
+    std::initializer_list<Attribute> attrs)
+    : attrs_(attrs)
 {
 }
 
+Attributes::
+Attributes(
+    const std::vector<Attribute>& attrs)
+    : attrs_(attrs)
+{
+}
+
+Attributes::
+Attributes(
+    std::vector<Attribute>&& attrs)
+    : attrs_(std::move(attrs))
+{
+}
+
+void
+Attributes::
+push(const Attribute& attr)
+{
+    attrs_.push_back(attr);
+}
+
+void
+Attributes::
+push(Attribute&& attr)
+{
+    attrs_.push_back(std::move(attr));
+}
+
 llvm::raw_ostream&
 operator<<(
     llvm::raw_ostream& os,
     Attributes const& attrs)
 {
-    for(auto const& attr : attrs.init_)
+    for(auto const& attr : attrs.attrs_)
         if(attr.pred)
             os <<
                 ' ' << attr.name << '=' <<

source/-XML/XMLTags.hpp

@@ -21,6 +21,7 @@
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/raw_ostream.h>
 #include <optional>
+#include <vector>
 
 /*
     Object for assisting with generating
@@ -127,21 +128,27 @@ struct Attribute
 
 //------------------------------------------------
 
-/** An init-list of zero or more XML attributes.
+/** An vector of zero or more XML attributes.
 */
 struct Attributes
 {
-    std::initializer_list<Attribute> init_;
+    std::vector<Attribute> attrs_;
 
     Attributes() = default;
-    Attributes(std::initializer_list<Attribute> init);
+    Attributes(std::initializer_list<Attribute> attrs);
+    Attributes(const std::vector<Attribute>& attrs);
+    Attributes(std::vector<Attribute>&& attrs);
+
+    void push(const Attribute& attr);
+    void push(Attribute&& attr);
 
     friend
     llvm::raw_ostream& operator<<(
         llvm::raw_ostream& os,
         Attributes const& attrs);
 };
 
+
 //------------------------------------------------
 
 /** A stream which indents just in time.

source/-XML/XMLWriter.cpp

@@ -293,7 +293,7 @@ writeEnum(
     if(I.BaseType)
     {
         tags_.open(baseTagName);
-        writeType(I.BaseType);
+        writeType(I.BaseType, tags_);
         tags_.close(baseTagName);
     }
 #endif
@@ -392,7 +392,7 @@ writeRecord(
             { B.Access },
             { "class", "virtual", B.IsVirtual },
         });
-        writeType(B.Type);
+        writeType(B.Type, tags_);
         tags_.close(baseTagName);
     }
 #endif
@@ -434,7 +434,7 @@ writeTypedef(
 
     writeSourceInfo(I);
 
-    writeType(I.Underlying);
+    writeType(I.Underlying, tags_);
 #if 0
     tags_.write("type", "", {
         { "name", I.Underlying.Name },
@@ -466,7 +466,7 @@ writeField(
 
     write(I.specs, tags_);
 
-    writeType(I.Type);
+    writeType(I.Type, tags_);
 #if 0
     tags_.write("type", {}, {
         { "name", I.Type.Name },
@@ -498,7 +498,7 @@ writeVar(
 
     write(I.specs, tags_);
 
-    writeType(I.Type);
+    writeType(I.Type, tags_);
 #if 0
     tags_.write("type", {}, {
         { "name", I.Type.Name },
@@ -608,18 +608,23 @@ writeSpecialization(
 
 //------------------------------------------------
 
+#if 0
 void
 XMLWriter::
 writeType(
     const std::unique_ptr<TypeInfo>& type)
 {
     if(! type)
         return;
-
+#if 0
     tags_.write("type", {}, {
         { "name", toString(*type) },
     });
+#else
+
+#endif
 }
+#endif
 
 //------------------------------------------------
 

source/-XML/XMLWriter.hpp

@@ -81,7 +81,7 @@ class XMLWriter
     void openTemplate(const std::unique_ptr<TemplateInfo>& I);
     void closeTemplate(const std::unique_ptr<TemplateInfo>& I);
 
-    void writeType(std::unique_ptr<TypeInfo> const& type);
+    // void writeType(std::unique_ptr<TypeInfo> const& type);
 
     template<class T>
     void writeNodes(doc::List<T> const& list);

source/AST/ASTVisitor.cpp

@@ -298,6 +298,8 @@ buildTypeInfoForType(
         auto I = std::make_unique<ArrayTypeInfo>();
         I->ElementType = buildTypeInfoForType(
             T->getElementType());
+        // KRYSTIAN FIXME: this is broken; cannonical
+        // constant array types never have a size expression
         if(auto* E = T->getSizeExpr())
             I->BoundsExpr = getSourceCode(E->getSourceRange());
         I->BoundsValue = toString(T->getSize(), 10, false);