Compute the type of this expressions

src/parser/cxx/parser.cc

@@ -2009,6 +2009,31 @@ auto Parser::parse_this_expression(ExpressionAST*& yyast) -> bool {
   auto ast = make_node<ThisExpressionAST>(pool_);
   yyast = ast;
   ast->thisLoc = thisLoc;
+  ast->valueCategory = ValueCategory::kPrValue;
+
+  for (auto current = scope_; current; current = current->parent()) {
+    if (auto classSymbol = symbol_cast<ClassSymbol>(current->owner())) {
+      // maybe a this expression in a field initializer
+      ast->type = control_->getPointerType(classSymbol->type());
+      break;
+    }
+
+    if (auto functionSymbol = symbol_cast<FunctionSymbol>(current->owner())) {
+      if (auto classSymbol =
+              symbol_cast<ClassSymbol>(functionSymbol->enclosingSymbol())) {
+        auto functionType = type_cast<FunctionType>(functionSymbol->type());
+        const auto cv = functionType->cvQualifiers();
+        if (cv != CvQualifiers::kNone) {
+          auto elementType = control_->getQualType(classSymbol->type(), cv);
+          ast->type = control_->getPointerType(elementType);
+        } else {
+          ast->type = control_->getPointerType(classSymbol->type());
+        }
+      }
+
+      break;
+    }
+  }
 
   return true;
 }

tests/unit_tests/sema/class_01.cc

@@ -0,0 +1,28 @@
+// RUN: %cxx -verify -fcheck %s
+
+struct X {
+  void f() { static_assert(__is_same(decltype(this), X*)); }
+
+  void f() const { static_assert(__is_same(decltype(this), const X*)); }
+
+  void f() volatile { static_assert(__is_same(decltype(this), volatile X*)); }
+
+  void f() const volatile {
+    static_assert(__is_same(decltype(this), const volatile X*));
+  }
+
+  void g();
+  void g() const;
+  void g() volatile;
+  void g() const volatile;
+};
+
+void X::g() { static_assert(__is_same(decltype(this), X*)); }
+
+void X::g() const { static_assert(__is_same(decltype(this), const X*)); }
+
+void X::g() volatile { static_assert(__is_same(decltype(this), volatile X*)); }
+
+void X::g() const volatile {
+  static_assert(__is_same(decltype(this), const volatile X*));
+}