Add attribute node

include/verilogAST.hpp

@@ -110,6 +110,30 @@ class Identifier : public Expression {
   ~Identifier(){};
 };
 
+class Attribute : public Expression {
+ protected:
+  virtual Attribute* clone_impl() const override {
+    return new Attribute(*this);
+  };
+
+ public:
+  std::unique_ptr<Expression> value;
+  std::string attr;
+
+  Attribute(std::unique_ptr<Expression> value, std::string attr)
+      : value(std::move(value)), attr(attr){};
+  Attribute(const Attribute& rhs)
+      : value(rhs.value->clone()), attr(rhs.attr){};
+  auto clone() const { return std::unique_ptr<Attribute>(clone_impl()); }
+
+  bool operator==(const Attribute& rhs) {
+    return (this->value == rhs.value && this->attr == rhs.attr);
+  }
+
+  std::string toString() override;
+  ~Attribute(){};
+};
+
 class String : public Expression {
  protected:
   virtual String* clone_impl() const override { return new String(*this); };
@@ -128,17 +152,17 @@ class String : public Expression {
 class Index : public Expression {
  protected:
   virtual Index* clone_impl() const override {
-    return new Index(this->id->clone(), this->index->clone());
+    return new Index(this->value->clone(), this->index->clone());
   };
 
  public:
-  std::unique_ptr<Identifier> id;
+  std::unique_ptr<Expression> value;
   std::unique_ptr<Expression> index;
 
-  Index(std::unique_ptr<Identifier> id, std::unique_ptr<Expression> index)
-      : id(std::move(id)), index(std::move(index)){};
+  Index(std::unique_ptr<Expression> value, std::unique_ptr<Expression> index)
+      : value(std::move(value)), index(std::move(index)){};
 
-  Index(const Index& rhs) : id(rhs.id->clone()), index(rhs.index->clone()){};
+  Index(const Index& rhs) : value(rhs.value->clone()), index(rhs.index->clone()){};
 
   std::string toString() override;
   ~Index(){};

include/verilogAST/transformer.hpp

@@ -20,6 +20,8 @@ class Transformer {
 
   virtual std::unique_ptr<Identifier> visit(std::unique_ptr<Identifier> node);
 
+  virtual std::unique_ptr<Attribute> visit(std::unique_ptr<Attribute> node);
+
   virtual std::unique_ptr<String> visit(std::unique_ptr<String> node);
 
   virtual std::unique_ptr<Index> visit(std::unique_ptr<Index> node);

src/concat_coalescer.cpp

@@ -69,7 +69,9 @@ RunOrExpr makeRunOrExpr(const Expression* arg) {
   if (not index) return RunOrExpr(arg);
   auto as_int = expr_to_int(index->index.get());
   if (not as_int.first) return RunOrExpr(arg);
-  return RunOrExpr(index->id->value, as_int.second, as_int.second);
+  auto index_id = dynamic_cast<const Identifier*>(index->value.get());
+  if (not index_id) return RunOrExpr(arg);
+  return RunOrExpr(index_id->value, as_int.second, as_int.second);
 }
 
 }  // namespace

src/transformer.cpp

@@ -13,6 +13,10 @@ std::unique_ptr<Expression> Transformer::visit(
     node.release();
     return this->visit(std::unique_ptr<Identifier>(ptr));
   }
+  if (auto ptr = dynamic_cast<Attribute*>(node.get())) {
+    node.release();
+    return this->visit(std::unique_ptr<Attribute>(ptr));
+  }
   if (auto ptr = dynamic_cast<String*>(node.get())) {
     node.release();
     return this->visit(std::unique_ptr<String>(ptr));
@@ -63,12 +67,18 @@ std::unique_ptr<Identifier> Transformer::visit(
   return node;
 }
 
+std::unique_ptr<Attribute> Transformer::visit(
+    std::unique_ptr<Attribute> node) {
+  node->value = this->visit(std::move(node->value));
+  return node;
+}
+
 std::unique_ptr<String> Transformer::visit(std::unique_ptr<String> node) {
   return node;
 }
 
 std::unique_ptr<Index> Transformer::visit(std::unique_ptr<Index> node) {
-  node->id = this->visit(std::move(node->id));
+  node->value = this->visit(std::move(node->value));
   node->index = this->visit(std::move(node->index));
   return node;
 }

src/verilogAST.cpp

@@ -101,10 +101,21 @@ std::string Identifier::toString() {
     return value;
 }
 
+std::string Attribute::toString() {
+  return this->value->toString() + "." + this->attr;
+}
+
 std::string String::toString() { return "\"" + value + "\""; }
 
 std::string Index::toString() {
-  return id->toString() + '[' + index->toString() + ']';
+  std::string expr_str = value->toString();
+  if (dynamic_cast<Identifier *>(value.get())) {
+  } else if (dynamic_cast<Index *>(value.get())) {
+  } else if (dynamic_cast<Slice *>(value.get())) {
+  } else {
+    expr_str = "(" + expr_str + ")";
+  }
+  return expr_str + '[' + index->toString() + ']';
 }
 
 std::string Slice::toString() {

tests/basic.cpp

@@ -40,6 +40,14 @@ TEST(BasicTests, TestIdentifier) {
   EXPECT_EQ(id.toString(), "x");
 }
 
+TEST(BasicTests, TestAttribute) {
+  vAST::Attribute attr(vAST::make_id("x"), "y");
+  EXPECT_EQ(attr.toString(), "x.y");
+  vAST::Attribute attr2(
+      std::make_unique<vAST::Attribute>(vAST::make_id("a"), "b"), "c");
+  EXPECT_EQ(attr2.toString(), "a.b.c");
+}
+
 TEST(BasicTests, TestIdentifierEscaped) {
   vAST::Identifier id("instance[5]");
   EXPECT_EQ(id.toString(), "\\instance[5] ");
@@ -58,6 +66,11 @@ TEST(BasicTests, TestString) {
 TEST(BasicTests, TestIndex) {
   vAST::Index index(vAST::make_id("x"), vAST::make_num("0"));
   EXPECT_EQ(index.toString(), "x[0]");
+
+  std::unique_ptr<vAST::BinaryOp> binop = std::make_unique<vAST::BinaryOp>(
+      vAST::make_id("x"), vAST::BinOp::ADD, vAST::make_id("y"));
+  vAST::Index index_expr(std::move(binop), vAST::make_num("0"));
+  EXPECT_EQ(index_expr.toString(), "(x + y)[0]");
 }
 
 TEST(BasicTests, TestSlice) {
@@ -561,7 +574,7 @@ TEST(BasicTests, TestIndexCopy) {
   std::unique_ptr<vAST::Index> x1 = std::make_unique<vAST::Index>(*x);
   EXPECT_EQ(x->toString(), "x[y]");
   EXPECT_EQ(x1->toString(), "x[y]");
-  x1->id->value = "z";
+  x1->value = vAST::make_id("z");
   x1->index = std::make_unique<vAST::Identifier>("a");
   EXPECT_EQ(x->toString(), "x[y]");
   EXPECT_EQ(x1->toString(), "z[a]");