[AST] Preserve the incomplete-type member expr.

[sammccall]

clang/lib/Sema/SemaExprCXX.cpp

7223

Sorry, I don't get what's going on here at all - is the idea that if you've already diagnosed an error here, don't fail further based on likely-bad recovery?

In that case:
a) we need a comment
b) how sure are you that this isn't establishing a "complete type" invariant that code later in this function relies on
c) can we avoid producing the extra diag that we don't think is reliable?

(maybe I misunderstood what's going on here)

clang/test/AST/ast-dump-recovery.cpp

107

This test doesn't seem to relate to member expressions, and passes for me without this patch applied.

[hokein]

clang/test/AST/ast-dump-recovery.cpp

107

oops, sorry, you are right, it works at head (I only verified the test after the patch is applied).

I was confused by a local modification (which preserves type), the recovery-expr make_incomplete().a will be dropped because we'll hit the above if statement. I'dd address this change in preserving-type patch.

clang/lib/Sema/SemaExprCXX.cpp

 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
 
   // The object type must be complete (or dependent), or
   // C++11 [expr.prim.general]p3:
   //   Unlike the object expression in other contexts, *this is not required to
   //   be of complete type for purposes of class member access (5.2.5) outside
   //   the member function body.
   if (!BaseType->isDependentType() &&
       !isThisOutsideMemberFunctionBody(BaseType) &&
-      RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access))
+      RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access)) {
+    if (Base->containsErrors())
+      return Base;
     return ExprError();
+  }
 
   // C++ [basic.lookup.classref]p2:
   //   If the id-expression in a class member access (5.2.5) is an
   //   unqualified-id, and the type of the object expression is of a class
   //   type C (or of pointer to a class type C), the unqualified-id is looked
   //   up in the scope of class C. [...]
   ObjectType = ParsedType::make(BaseType);
   return Base;

clang/test/AST/ast-dump-recovery.cpp

void test(int x) {
   foo->func(x);
 }
 
 // CHECK:     |-AlignedAttr {{.*}} alignas
 // CHECK-NEXT:| `-RecoveryExpr {{.*}} contains-errors
 // CHECK-NEXT:|   `-UnresolvedLookupExpr {{.*}} 'invalid'
 struct alignas(invalid()) Aligned {};
 
+struct Incomplete;
+Incomplete make_incomplete();
+// CHECK: FunctionDecl {{.*}} test2
+// CHECK-NEXT: `-CompoundStmt
+// CHECK-NEXT:  `-RecoveryExpr {{.*}} contains-errors
+// CHECK-NEXT:   `-UnresolvedLookupExpr {{.*}} 'make_incomplete'
+void test2() {
+  make_incomplete();
+}
+
 void InvalidInitalizer(int x) {
   struct Bar { Bar(); };
   // CHECK:     `-VarDecl {{.*}} a1 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-IntegerLiteral {{.*}} 'int' 1
   Bar a1(1);
   // CHECK:     `-VarDecl {{.*}} a2 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors