attributes on data members are supported.

Author: klemens-morgenstern

include/mrdox/Metadata/FieldType.hpp

@@ -14,12 +14,22 @@
 
 #include <mrdox/Platform.hpp>
 #include <mrdox/Metadata/Type.hpp>
+#include <mrdox/Metadata/BitField.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <utility>
 
 namespace clang {
 namespace mrdox {
 
+union FieldFlags
+{
+    BitFieldFullValue raw{.value=0u};
+
+    BitFlag<0> isNodiscard;
+    BitFlag<1> isDeprecated;
+    BitFlag<2> hasNoUniqueAddress;
+};
+
 // Info for field types.
 struct FieldTypeInfo
     : public TypeInfo
@@ -31,31 +41,23 @@ struct FieldTypeInfo
     // or the variable initializer if any.
     llvm::SmallString<16> DefaultValue;
 
+    // attributes (nodiscard, no_unique_address, deprecated)
+    FieldFlags Flags;
     //--------------------------------------------
 
     FieldTypeInfo() = default;
 
     FieldTypeInfo(
-        TypeInfo const& TI,
-        llvm::StringRef Name = llvm::StringRef(),
-        llvm::StringRef DefaultValue = llvm::StringRef())
+            TypeInfo const& TI,
+            llvm::StringRef Name = llvm::StringRef(),
+            llvm::StringRef DefaultValue = llvm::StringRef(),
+            FieldFlags Flags = {})
         : TypeInfo(TI)
         , Name(Name)
         , DefaultValue(DefaultValue)
+        , Flags(Flags)
     {
     }
-
-#if 0
-    // VFALCO What was this for?
-    bool
-    operator==(
-        FieldTypeInfo const& Other) const
-    {
-        return
-            std::tie(Type, Name, DefaultValue) ==
-            std::tie(Other.Type, Other.Name, Other.DefaultValue);
-    }
-#endif
 };
 
 } // mrdox

mrdox.rnc

@@ -73,7 +73,8 @@ grammar
             attribute type { text },
             attribute value { text } ?,
             Access,
-            ID ?
+            ID ?,
+            Attr *
         }
 
     #---------------------------------------------

mrdox.rng

@@ -96,6 +96,9 @@
       <optional>
         <ref name="ID"/>
       </optional>
+      <zeroOrMore>
+        <ref name="Attr"/>
+      </zeroOrMore>
     </element>
   </define>
   <!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

source/api/AST/ASTVisitor.cpp

@@ -334,8 +334,27 @@ getMemberTypeInfo(
 {
     Assert(D && "Expect non-null FieldDecl in getMemberTypeInfo");
     parseJavadoc(I.javadoc, D);
+
+    for (auto attr : D->attrs())
+    {
+        switch (attr->getKind())
+        {
+            case clang::attr::Kind::NoUniqueAddress:
+                I.Flags.hasNoUniqueAddress = true;
+                break;
+            case clang::attr::Kind::Deprecated:
+                I.Flags.isDeprecated = true;
+                break;
+            case clang::attr::Kind::Unused:
+                I.Flags.isNodiscard = true;
+                break;
+            default:
+                break;
+        }
+    }
 }
 
+
 //------------------------------------------------
 
 template<class Parent, class Child>

source/api/AST/AnyBlock.hpp

@@ -464,6 +464,8 @@ class FieldTypeBlock
             return decodeRecord(R, I_.Name, Blob);
         case FIELD_DEFAULT_VALUE:
             return decodeRecord(R, I_.DefaultValue, Blob);
+        case FIELD_ATTRIBUTES:
+            return decodeRecord(R, {&I_.Flags.raw}, Blob);
         default:
             return AnyBlock::parseRecord(R, ID, Blob);
         }
@@ -538,6 +540,11 @@ class MemberTypeBlock
             I_.Type = std::move(B.I);
             return llvm::Error::success();
         }
+        case BI_FIELD_TYPE_BLOCK_ID:
+        {
+            FieldTypeBlock B(I_, br_);
+            return br_.readBlock(B, ID);
+        }
         case BI_JAVADOC_BLOCK_ID:
         {
             JavadocBlock B(I_.javadoc, br_);

source/api/AST/BitcodeIDs.hpp

@@ -99,6 +99,7 @@ enum RecordId
     JAVADOC_NODE_ADMONISH,
     FIELD_TYPE_NAME,
     FIELD_DEFAULT_VALUE,
+    FIELD_ATTRIBUTES,
     MEMBER_TYPE_NAME,
     MEMBER_TYPE_ACCESS,
     ENUM_SCOPED,

source/api/AST/BitcodeWriter.cpp

@@ -247,6 +247,7 @@ RecordIdNameMap = []()
         {JAVADOC_NODE_ADMONISH, {"JavadocNodeAdmonish", &Integer32Abbrev}},
         {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
         {FIELD_DEFAULT_VALUE, {"DefaultValue", &StringAbbrev}},
+        {FIELD_ATTRIBUTES, {"FieldAttributes", &Integer32ArrayAbbrev}},
         {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
         {MEMBER_TYPE_ACCESS, {"Access", &Integer32Abbrev}},
         {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
@@ -302,7 +303,7 @@ RecordsByBlock{
     {BI_ENUM_VALUE_BLOCK_ID,
         {ENUM_VALUE_NAME, ENUM_VALUE_VALUE, ENUM_VALUE_EXPR}},
     // FieldTypeInfo
-    {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME, FIELD_DEFAULT_VALUE}},
+    {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME, FIELD_DEFAULT_VALUE, FIELD_ATTRIBUTES}},
     // FunctionInfo
     {BI_FUNCTION_BLOCK_ID,
         {FUNCTION_ACCESS, FUNCTION_IS_METHOD, FUNCTION_BITS}},
@@ -760,6 +761,7 @@ emitBlock(
     emitBlock(T.Type, FieldId::F_type);
     emitRecord(T.Name, FIELD_TYPE_NAME);
     emitRecord(T.DefaultValue, FIELD_DEFAULT_VALUE);
+    emitRecord({T.Flags.raw}, FIELD_ATTRIBUTES);
 }
 
 void
@@ -871,7 +873,8 @@ emitBlock(
     MemberTypeInfo const& T)
 {
     StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID);
-    emitBlock(T.Type, FieldId::F_type);
+//    emitBlock(T.Type, FieldId::F_type);
+    emitBlock(static_cast<const FieldTypeInfo &>(T));
     emitRecord(T.Name, MEMBER_TYPE_NAME);
     emitRecord(T.Access, MEMBER_TYPE_ACCESS);
     if(T.javadoc)

source/api/_XML/CXXTags.hpp

@@ -214,6 +214,17 @@ inline void write(FnFlags1 const& bits, XMLTags& tags)
     fw.write(&FnFlags1::isExplicit,        "is-explicit");
 }
 
+
+inline void write(FieldFlags const& bits, XMLTags& tags)
+{
+    BitFieldWriter<FieldFlags> fw(bits, tags);
+
+    fw.write(&FieldFlags::isNodiscard, "nodiscard");
+    fw.write(&FieldFlags::isDeprecated, "deprecated");
+    fw.write(&FieldFlags::hasNoUniqueAddress, "no-unique-address");
+}
+
+
 inline void write(VarFlags0 const& bits, XMLTags& tags)
 {
     BitFieldWriter<VarFlags0> fw(bits, tags);

source/api/_XML/XMLWriter.cpp

@@ -434,12 +434,15 @@ XMLWriter::
 writeMemberType(
     MemberTypeInfo const& I)
 {
-    tags_.write(dataMemberTagName, {}, {
+    tags_.open(dataMemberTagName, {
         { "name", I.Name },
         { "type", I.Type.Name },
         { "value", I.DefaultValue, ! I.DefaultValue.empty() },
         { I.Access },
         { I.Type.id } });
+
+    write(I.Flags, tags_);
+    tags_.close("data");
 }
 
 //------------------------------------------------

test-files/old-tests/no_unique_address.cpp

@@ -0,0 +1,10 @@
+// data members
+
+struct Empty {};
+
+struct T
+{
+    int i;
+    [[/*no_unique_address, */deprecated, maybe_unused]] Empty e = Empty{};
+};
+// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/