Add APis to compute the qualification combined type

Signed-off-by: GitHub <[email protected]>

Author: robertoraggi

src/parser/cxx/type_checker.cc

@@ -109,6 +109,14 @@ struct TypeChecker::Visitor {
                                                  ExpressionAST*& other)
       -> const Type*;
 
+  [[nodiscard]] auto get_qualification_combined_type(const Type* left,
+                                                     const Type* right)
+      -> const Type*;
+
+  [[nodiscard]] auto get_qualification_combined_type(
+      const Type* left, const Type* right, bool& didChangeTypeOrQualifiers)
+      -> const Type*;
+
   [[nodiscard]] auto composite_pointer_type(ExpressionAST*& expr,
                                             ExpressionAST*& other)
       -> const Type*;
@@ -1736,6 +1744,98 @@ auto TypeChecker::Visitor::usual_arithmetic_conversion(ExpressionAST*& expr,
   return control()->getIntType();
 }
 
+auto TypeChecker::Visitor::get_qualification_combined_type(const Type* left,
+                                                           const Type* right)
+    -> const Type* {
+  bool didChangeTypeOrQualifiers = false;
+
+  auto type =
+      get_qualification_combined_type(left, right, didChangeTypeOrQualifiers);
+
+  return type;
+}
+
+auto TypeChecker::Visitor::get_qualification_combined_type(
+    const Type* left, const Type* right, bool& didChangeTypeOrQualifiers)
+    -> const Type* {
+  auto check_inputs = [&] {
+    if (control()->is_pointer(left) && control()->is_pointer(right)) {
+      return true;
+    }
+
+    if (control()->is_array(left) && control()->is_array(right)) {
+      return true;
+    }
+
+    return false;
+  };
+
+  auto cv1 = strip_cv(left);
+  auto cv2 = strip_cv(right);
+
+  if (!check_inputs()) {
+    const auto cv3 = merge_cv(cv1, cv2);
+
+    if (control()->is_same(left, right)) {
+      return control()->add_cv(left, cv3);
+    }
+
+    if (control()->is_base_of(left, right)) {
+      return control()->add_cv(left, cv1);
+    }
+
+    if (control()->is_base_of(right, left)) {
+      return control()->add_cv(right, cv2);
+    }
+
+    return nullptr;
+  }
+
+  auto leftElementType = control()->get_element_type(left);
+  if (control()->is_array(leftElementType)) {
+    cv1 = merge_cv(cv1, control()->get_cv_qualifiers(leftElementType));
+  }
+
+  auto rightElementType = control()->get_element_type(right);
+  if (control()->is_array(rightElementType)) {
+    cv2 = merge_cv(cv2, control()->get_cv_qualifiers(rightElementType));
+  }
+
+  auto elementType = get_qualification_combined_type(
+      leftElementType, rightElementType, didChangeTypeOrQualifiers);
+
+  if (!elementType) {
+    return nullptr;
+  }
+
+  auto cv3 = merge_cv(cv1, cv2);
+
+  if (didChangeTypeOrQualifiers) cv3 = cv3 | CvQualifiers::kConst;
+
+  if (cv1 != cv3 || cv2 != cv3) didChangeTypeOrQualifiers = true;
+
+  elementType = control()->add_cv(elementType, cv3);
+
+  if (control()->is_array(left) && control()->is_array(right)) {
+    auto leftArrayType = type_cast<BoundedArrayType>(left);
+    auto rightArrayType = type_cast<BoundedArrayType>(right);
+
+    if (leftArrayType && rightArrayType) {
+      if (leftArrayType->size() != rightArrayType->size()) return nullptr;
+      return control()->getBoundedArrayType(elementType, leftArrayType->size());
+    }
+
+    if (leftArrayType || rightArrayType) {
+      // one of arrays is unbounded
+      didChangeTypeOrQualifiers = true;
+    }
+
+    return control()->getUnboundedArrayType(elementType);
+  }
+
+  return control()->getPointerType(elementType);
+}
+
 auto TypeChecker::Visitor::composite_pointer_type(ExpressionAST*& expr,
                                                   ExpressionAST*& other)
     -> const Type* {
@@ -1767,9 +1867,11 @@ auto TypeChecker::Visitor::composite_pointer_type(ExpressionAST*& expr,
       return control()->getPointerType(control()->add_cv(t2, cv1));
     }
 
-    // TODO: check for noexcept function pointers
+    if (auto type = get_qualification_combined_type(expr->type, other->type)) {
+      return type;
+    }
 
-    // TODO: check for reference related
+    // TODO: check for noexcept function pointers
   }
 
   return nullptr;

tests/unit_tests/sema/conditional_expr_01.cc

@@ -1,5 +1,8 @@
 // RUN: %cxx -verify -fcheck %s
 
+struct Base {};
+struct Derived : Base {};
+
 void returns_void();
 int returns_int();
 int& returns_int_ref();
@@ -44,8 +47,40 @@ void test_conditional(bool x) {
   static_assert(__is_same(unsigned, decltype(x ? 0 : 1u)));
   static_assert(__is_same(long, decltype(x ? 0 : 1l)));
 
+  const char cs[] = "";
   char s[10];
-  char* cp;
+  char* p;
+  const char* cp = p;
+  const char* const cpc = p;
+
+  static_assert(__is_same(char*, decltype(x ? s : p)));
+
+  static_assert(__is_same(const char*, decltype(true ? p : cp)));
+
+  static_assert(__is_same(const char*, decltype(true ? p : "")));
+  static_assert(__is_same(const char*, decltype(true ? "" : cp)));
+
+  static_assert(__is_same(const char*, decltype(x ? cs : cp)));
+  static_assert(__is_same(const char*, decltype(x ? cs : p)));
+  static_assert(__is_same(const char*, decltype(x ? cs : cpc)));
+
+  Base* b;
+  Derived* d;
+
+  static_assert(__is_same(Base*, decltype(true ? b : d)));
+
+  char (*a10)[10];
+  char (*a100)[100];
+  char (*a)[];
+  const char (*ca)[];
+
+  // clang-format off
+  // expected-error@1 {{left operand to ? is 'char (*)[10]', but right operand is of type 'char (*)[100]'}}
+  x ? a10 : a100;
+  // clang-format on
 
-  static_assert(__is_same(char*, decltype(x ? s : cp)));
+  static_assert(__is_same(char (*&)[10], decltype(x ? a10 : a10)));
+  static_assert(__is_same(const char (*)[], decltype(x ? a10 : a)));
+  static_assert(__is_same(char (*&)[], decltype(x ? a : a)));
+  static_assert(__is_same(const char (*)[], decltype(x ? a : ca)));
 }