Compute types of address expressions

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

src/parser/cxx/parser.cc

@@ -307,7 +307,29 @@ struct Parser::GetDeclaratorType {
     }
   }
 
-  void operator()(PtrToMemberOperatorAST* ast) {}
+  void operator()(PtrToMemberOperatorAST* ast) {
+    if (!type_) return;
+
+    auto symbol = ast->nestedNameSpecifier->symbol;
+    if (!symbol) return;
+
+    auto classType = type_cast<ClassType>(symbol->type());
+    if (!classType) return;
+
+    if (auto functionType = type_cast<FunctionType>(type_)) {
+      type_ = control()->getMemberFunctionPointerType(classType, functionType);
+    } else {
+      type_ = control()->getMemberObjectPointerType(classType, type_);
+    }
+
+    for (auto it = ast->cvQualifierList; it; it = it->next) {
+      if (ast_cast<ConstQualifierAST>(it->value)) {
+        type_ = control()->getConstType(type_);
+      } else if (ast_cast<VolatileQualifierAST>(it->value)) {
+        type_ = control()->getVolatileType(type_);
+      }
+    }
+  }
 
   void operator()(BitfieldDeclaratorAST* ast) {}
 
@@ -2932,6 +2954,55 @@ auto Parser::parse_unop_expression(ExpressionAST*& yyast,
       break;
     }
 
+    case TokenKind::T_AMP: {
+      if (!ast->expression->type) {
+        break;
+      }
+
+      if (!is_glvalue(ast->expression)) {
+        break;
+      }
+
+      // TODO xvalue to lvalue
+
+      auto expr = strip_parentheses(ast->expression);
+
+      if (auto idExpr = ast_cast<IdExpressionAST>(expr);
+          idExpr && idExpr->nestedNameSpecifier) {
+        auto symbol = idExpr->symbol;
+        if (auto field = symbol_cast<FieldSymbol>(symbol);
+            field && !field->isStatic()) {
+          auto parentClass = field->enclosingSymbol();
+          auto classType = type_cast<ClassType>(parentClass->type());
+
+          ast->type =
+              control_->getMemberObjectPointerType(classType, field->type());
+
+          ast->valueCategory = ValueCategory::kPrValue;
+
+          break;
+        }
+
+        if (auto function = symbol_cast<FunctionSymbol>(symbol);
+            function && !function->isStatic()) {
+          auto functionType = type_cast<FunctionType>(function->type());
+          auto parentClass = function->enclosingSymbol();
+          auto classType = type_cast<ClassType>(parentClass->type());
+
+          ast->type =
+              control_->getMemberFunctionPointerType(classType, functionType);
+
+          ast->valueCategory = ValueCategory::kPrValue;
+
+          break;
+        }
+      }  // id expression
+
+      ast->type = control_->getPointerType(ast->expression->type);
+      ast->valueCategory = ValueCategory::kPrValue;
+      break;
+    }
+
     case TokenKind::T_PLUS: {
       ExpressionAST* expr = ast->expression;
       ensure_prvalue(expr);
@@ -5985,6 +6056,13 @@ void Parser::check_type_traits() {
   rewind(typeTraitLoc);
 }
 
+auto Parser::strip_parentheses(ExpressionAST* ast) -> ExpressionAST* {
+  while (auto paren = ast_cast<NestedExpressionAST>(ast)) {
+    ast = paren->expression;
+  }
+  return ast;
+}
+
 auto Parser::lvalue_to_rvalue_conversion(ExpressionAST*& expr) -> bool {
   if (!is_glvalue(expr)) return false;
 

src/parser/cxx/parser.h

@@ -827,6 +827,8 @@ class Parser final {
 
   void check_type_traits();
 
+  [[nodiscard]] auto strip_parentheses(ExpressionAST* ast) -> ExpressionAST*;
+
   // standard conversions
   [[nodiscard]] auto lvalue_to_rvalue_conversion(ExpressionAST*& expr) -> bool;
   [[nodiscard]] auto array_to_pointer_conversion(ExpressionAST*& expr) -> bool;

tests/unit_tests/sema/address_op_01.cc

@@ -0,0 +1,41 @@
+// RUN: %cxx -verify -fcheck %s
+
+struct X {
+  int m{};
+  const int ci{};
+  const volatile int cvi{};
+
+  void f();
+  void g(int a, const void* ptr) const;
+};
+
+auto main() -> int {
+  static_assert(__is_same(decltype(&X::m), int X::*));
+  static_assert(__is_same(decltype(&X::ci), const int X::*));
+  static_assert(__is_same(decltype(&X::cvi), const volatile int X::*));
+  static_assert(__is_same(decltype(&X::f), void (X::*)()));
+  static_assert(
+      __is_same(decltype(&X::g), void (X::*)(int, const void*) const));
+
+  char ch{};
+  static_assert(__is_same(decltype(&ch), char*));
+
+  int i{};
+  static_assert(__is_same(decltype(&i), int*));
+
+  const void* p = nullptr;
+  static_assert(__is_same(decltype(&p), const void**));
+
+  int a[2];
+  static_assert(__is_same(decltype(&a), int(*)[2]));
+
+  X x;
+  static_assert(__is_same(decltype(&x), X*));
+  static_assert(__is_same(decltype(*&x), X&));
+
+  const X cx;
+  static_assert(__is_same(decltype(&cx), const X*));
+  static_assert(__is_same(decltype(*&cx), const X&));
+
+  return 0;
+}