fix(parser): Remove qualifiers from pointer type

Author: robertoraggi

Diff for: src/cxx/parser.cc

@@ -574,8 +574,7 @@ bool Parser::parse_primary_expression(ExpressionAST*& yyast,
     ast->thisLoc = thisLoc;
 
     if (auto classSymbol = sem->scope()->owner()->enclosingClass()) {
-      ast->type = QualifiedType{
-          types->pointerType(classSymbol->type(), Qualifiers::kNone)};
+      ast->type = QualifiedType{types->pointerType(classSymbol->type())};
     }
 
     return true;

Diff for: src/cxx/qualified_type.h

@@ -41,7 +41,7 @@ class QualifiedType {
   Qualifiers qualifiers() const { return qualifiers_; }
   void setQualifiers(Qualifiers qualifiers) { qualifiers_ = qualifiers; }
 
-  QualifiedType unqualified() { return QualifiedType(type()); }
+  QualifiedType unqualified() const { return QualifiedType(type()); }
 
   void mergeWith(const QualifiedType& other) {
     qualifiers_ |= other.qualifiers();

Diff for: src/cxx/semantics.cc

@@ -518,7 +518,7 @@ void Semantics::visit(NullptrLiteralExpressionAST* ast) {}
 void Semantics::visit(StringLiteralExpressionAST* ast) {
   QualifiedType charTy{types_->integerType(IntegerKind::kChar, false)};
   charTy.setQualifiers(Qualifiers::kConst);
-  QualifiedType charPtrTy{types_->pointerType(charTy, Qualifiers::kNone)};
+  QualifiedType charPtrTy{types_->pointerType(charTy)};
   expression_->type = charPtrTy;
 }
 
@@ -602,8 +602,7 @@ void Semantics::visit(UnaryExpressionAST* ast) {
       break;
     }
     case TokenKind::T_AMP: {
-      expression_->type = QualifiedType(
-          types_->pointerType(expression.type, Qualifiers::kNone));
+      expression_->type = QualifiedType(types_->pointerType(expression.type));
       break;
     }
     default: {
@@ -939,11 +938,10 @@ void Semantics::visit(StaticAssertDeclarationAST* ast) {
 
       error(errorLoc, "non-constant condition for static assertion");
     } else if (!constValue.value()) {
-      const auto errorLoc = ast->stringLiteralList
-                                ? ast->stringLiteralList->value
-                                : ast->expression
-                                      ? ast->expression->firstSourceLocation()
-                                      : ast->staticAssertLoc;
+      const auto errorLoc =
+          ast->stringLiteralList ? ast->stringLiteralList->value
+          : ast->expression      ? ast->expression->firstSourceLocation()
+                                 : ast->staticAssertLoc;
 
       if (ast->stringLiteralList) {
         std::string message;
@@ -1380,7 +1378,8 @@ void Semantics::visit(PointerOperatorAST* ast) {
   this->specifiers(ast->cvQualifierList, &specifiers);
   auto qualifiers = specifiers.type.qualifiers();
 
-  QualifiedType ptrTy(types_->pointerType(declarator_->type, qualifiers));
+  QualifiedType ptrTy(types_->pointerType(declarator_->type));
+  ptrTy.setQualifiers(qualifiers);
 
   declarator_->type = ptrTy;
 }

Diff for: src/cxx/type_environment.cc

@@ -100,12 +100,11 @@ struct Hash {
   }
 
   std::size_t operator()(const PointerType& type) const {
-    return hash_combine(type.elementType(), type.qualifiers());
+    return hash_value(type.elementType());
   }
 
   std::size_t operator()(const PointerToMemberType& type) const {
-    return hash_combine(type.classType(), type.elementType(),
-                        type.qualifiers());
+    return hash_combine(type.classType(), type.elementType());
   }
 
   std::size_t operator()(const ReferenceType& type) const {
@@ -208,15 +207,13 @@ struct EqualTo {
   }
 
   bool operator()(const PointerType& type, const PointerType& other) const {
-    return type.elementType() == other.elementType() &&
-           type.qualifiers() == other.qualifiers();
+    return type.elementType() == other.elementType();
   }
 
   bool operator()(const PointerToMemberType& type,
                   const PointerToMemberType& other) const {
     return type.classType() == other.classType() &&
-           type.elementType() == other.elementType() &&
-           type.qualifiers() == other.qualifiers();
+           type.elementType() == other.elementType();
   }
 
   bool operator()(const ReferenceType& type, const ReferenceType& other) const {
@@ -348,15 +345,13 @@ const ScopedEnumType* TypeEnvironment::scopedEnumType(
 }
 
 const PointerType* TypeEnvironment::pointerType(
-    const QualifiedType& elementType, Qualifiers qualifiers) {
-  return &*d->pointerTypes.emplace(elementType, qualifiers).first;
+    const QualifiedType& elementType) {
+  return &*d->pointerTypes.emplace(elementType).first;
 }
 
 const PointerToMemberType* TypeEnvironment::pointerToMemberType(
-    const ClassType* classType, const QualifiedType& elementType,
-    Qualifiers qualifiers) {
-  return &*d->pointerToMemberTypes.emplace(classType, elementType, qualifiers)
-               .first;
+    const ClassType* classType, const QualifiedType& elementType) {
+  return &*d->pointerToMemberTypes.emplace(classType, elementType).first;
 }
 
 const ReferenceType* TypeEnvironment::referenceType(

Diff for: src/cxx/type_environment.h

@@ -55,12 +55,10 @@ class TypeEnvironment {
 
   const ScopedEnumType* scopedEnumType(ScopedEnumSymbol* symbol);
 
-  const PointerType* pointerType(const QualifiedType& elementType,
-                                 Qualifiers qualifiers);
+  const PointerType* pointerType(const QualifiedType& elementType);
 
   const PointerToMemberType* pointerToMemberType(
-      const ClassType* classType, const QualifiedType& elementType,
-      Qualifiers qualifiers);
+      const ClassType* classType, const QualifiedType& elementType);
 
   const ReferenceType* referenceType(const QualifiedType& elementType);
 

Diff for: src/cxx/type_printer.cc

@@ -168,8 +168,8 @@ void TypePrinter::visit(const ScopedEnumType* type) {
 
 void TypePrinter::visit(const PointerType* type) {
   ptrOps_ += "*";
-  addQualifiers(ptrOps_, type->qualifiers());
-  accept(type->elementType());
+  addQualifiers(ptrOps_, type->elementType().qualifiers());
+  accept(type->elementType().unqualified());
 }
 
 void TypePrinter::visit(const PointerToMemberType* type) {

Diff for: src/cxx/types.h

@@ -146,34 +146,28 @@ class ScopedEnumType final : public Type, public std::tuple<ScopedEnumSymbol*> {
   void accept(TypeVisitor* visitor) const override;
 };
 
-class PointerType final : public Type,
-                          public std::tuple<QualifiedType, Qualifiers> {
+class PointerType final : public Type, public std::tuple<QualifiedType> {
  public:
-  PointerType(const QualifiedType& elementType, Qualifiers qualifiers) noexcept
-      : tuple(elementType, qualifiers) {}
+  explicit PointerType(const QualifiedType& elementType) noexcept
+      : tuple(elementType) {}
 
   const QualifiedType& elementType() const { return get<0>(*this); }
 
-  Qualifiers qualifiers() const { return get<1>(*this); }
-
   void accept(TypeVisitor* visitor) const override;
 };
 
 class PointerToMemberType final
     : public Type,
-      public std::tuple<const ClassType*, QualifiedType, Qualifiers> {
+      public std::tuple<const ClassType*, QualifiedType> {
  public:
   PointerToMemberType(const ClassType* classType,
-                      const QualifiedType& elementType,
-                      Qualifiers qualifiers) noexcept
-      : tuple(classType, elementType, qualifiers) {}
+                      const QualifiedType& elementType) noexcept
+      : tuple(classType, elementType) {}
 
   const ClassType* classType() const { return get<0>(*this); }
 
   const QualifiedType& elementType() const { return get<1>(*this); }
 
-  Qualifiers qualifiers() const { return get<2>(*this); }
-
   void accept(TypeVisitor* visitor) const override;
 };