[clang] 3681d85 - Revert "[Clang][Sema] Use the correct lookup context when building overloaded 'operator->' in the current instantiation (#104458)"
Nikita Popov via cfe-commits
cfe-commits at lists.llvm.org
Mon Sep 9 12:10:46 PDT 2024
Author: Nikita Popov
Date: 2024-09-09T21:10:12+02:00
New Revision: 3681d8552fb9e6cb15e9d45849ff2e34a25c518e
URL: https://github.com/llvm/llvm-project/commit/3681d8552fb9e6cb15e9d45849ff2e34a25c518e
DIFF: https://github.com/llvm/llvm-project/commit/3681d8552fb9e6cb15e9d45849ff2e34a25c518e.diff
LOG: Revert "[Clang][Sema] Use the correct lookup context when building overloaded 'operator->' in the current instantiation (#104458)"
This reverts commit 3cdb30ebbc18fa894d3bd67aebcff76ce7c741ac.
Breaks clang bootstrap.
Added:
Modified:
clang/include/clang/Sema/Sema.h
clang/lib/Sema/SemaExprCXX.cpp
clang/lib/Sema/SemaOverload.cpp
clang/lib/Sema/TreeTransform.h
clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p4.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index c1afefd36ce0ce..68c782a15c6f1b 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -10639,9 +10639,9 @@ class Sema final : public SemaBase {
/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
/// (if one exists), where @c Base is an expression of class type and
/// @c Member is the name of the member we're trying to find.
- ExprResult BuildOverloadedArrowExpr(Expr *Base, SourceLocation OpLoc,
- bool *NoArrowOperatorFound,
- bool &IsDependent);
+ ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
+ SourceLocation OpLoc,
+ bool *NoArrowOperatorFound = nullptr);
ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
CXXConversionDecl *Method,
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 3c7eac116e5dc9..14feafd1e6b17f 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -7966,6 +7966,18 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
QualType BaseType = Base->getType();
MayBePseudoDestructor = false;
+ if (BaseType->isDependentType()) {
+ // If we have a pointer to a dependent type and are using the -> operator,
+ // the object type is the type that the pointer points to. We might still
+ // have enough information about that type to do something useful.
+ if (OpKind == tok::arrow)
+ if (const PointerType *Ptr = BaseType->getAs<PointerType>())
+ BaseType = Ptr->getPointeeType();
+
+ ObjectType = ParsedType::make(BaseType);
+ MayBePseudoDestructor = true;
+ return Base;
+ }
// C++ [over.match.oper]p8:
// [...] When operator->returns, the operator-> is applied to the value
@@ -7980,8 +7992,7 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
SmallVector<FunctionDecl*, 8> OperatorArrows;
CTypes.insert(Context.getCanonicalType(BaseType));
- while (
- isa<InjectedClassNameType, RecordType>(BaseType.getCanonicalType())) {
+ while (BaseType->isRecordType()) {
if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {
Diag(OpLoc, diag::err_operator_arrow_depth_exceeded)
<< StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();
@@ -7991,26 +8002,15 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
return ExprError();
}
- bool IsDependent;
Result = BuildOverloadedArrowExpr(
- Base, OpLoc,
+ S, Base, OpLoc,
// When in a template specialization and on the first loop iteration,
// potentially give the default diagnostic (with the fixit in a
// separate note) instead of having the error reported back to here
// and giving a diagnostic with a fixit attached to the error itself.
(FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization())
? nullptr
- : &NoArrowOperatorFound,
- IsDependent);
-
- if (IsDependent) {
- // BuildOverloadedArrowExpr sets IsDependent to indicate that we need
- // to build a dependent overloaded arrow expression.
- assert(BaseType->isDependentType());
- BaseType = Context.DependentTy;
- break;
- }
-
+ : &NoArrowOperatorFound);
if (Result.isInvalid()) {
if (NoArrowOperatorFound) {
if (FirstIteration) {
@@ -8030,7 +8030,6 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
}
return ExprError();
}
-
Base = Result.get();
if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base))
OperatorArrows.push_back(OpCall->getDirectCallee());
@@ -8068,7 +8067,7 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
// it's legal for the type to be incomplete if this is a pseudo-destructor
// call. We'll do more incomplete-type checks later in the lookup process,
// so just skip this check for ObjC types.
- if (!isa<InjectedClassNameType, RecordType>(BaseType.getCanonicalType())) {
+ if (!BaseType->isRecordType()) {
ObjectType = ParsedType::make(BaseType);
MayBePseudoDestructor = true;
return Base;
@@ -8086,10 +8085,6 @@ ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base,
return CreateRecoveryExpr(Base->getBeginLoc(), Base->getEndLoc(), {Base});
}
- // We can't implicitly declare the destructor for a templated class.
- if (BaseType->isDependentType())
- MayBePseudoDestructor = true;
-
// 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
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 6b91d4898674ec..861b0a91240b3b 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -15878,14 +15878,12 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
}
-ExprResult Sema::BuildOverloadedArrowExpr(Expr *Base, SourceLocation OpLoc,
- bool *NoArrowOperatorFound,
- bool &IsDependent) {
- assert(Base->getType()->getAsRecordDecl() &&
+ExprResult
+Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
+ bool *NoArrowOperatorFound) {
+ assert(Base->getType()->isRecordType() &&
"left-hand side must have class type");
- IsDependent = false;
-
if (checkPlaceholderForOverload(*this, Base))
return ExprError();
@@ -15906,19 +15904,7 @@ ExprResult Sema::BuildOverloadedArrowExpr(Expr *Base, SourceLocation OpLoc,
return ExprError();
LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
- LookupParsedName(R, /*S=*/nullptr, /*SS=*/nullptr, Base->getType());
-
- // If the expression is dependent and we either:
- // - found a member of the current instantiation named 'operator->', or
- // - found nothing, and the lookup context has no dependent base classes
- //
- // then we should build a dependent class member access expression.
- if (R.wasNotFoundInCurrentInstantiation() ||
- (Base->isTypeDependent() && !R.empty())) {
- IsDependent = true;
- return Base;
- }
-
+ LookupQualifiedName(R, Base->getType()->castAs<RecordType>()->getDecl());
R.suppressAccessDiagnostics();
for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 235b51a33babd5..0daf620b4123e4 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -16583,14 +16583,10 @@ ExprResult TreeTransform<Derived>::RebuildCXXOperatorCallExpr(
} else if (Op == OO_Arrow) {
// It is possible that the type refers to a RecoveryExpr created earlier
// in the tree transformation.
- if (First->containsErrors())
+ if (First->getType()->isDependentType())
return ExprError();
- bool IsDependent;
// -> is never a builtin operation.
- ExprResult Result = SemaRef.BuildOverloadedArrowExpr(
- First, OpLoc, /*NoArrowOperatorFound=*/nullptr, IsDependent);
- assert(!IsDependent);
- return Result;
+ return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
} else if (Second == nullptr || isPostIncDec) {
if (!First->getType()->isOverloadableType() ||
(Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
diff --git a/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p4.cpp b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p4.cpp
index 89c22a0bc137d9..f32f49ef4539a5 100644
--- a/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p4.cpp
+++ b/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p4.cpp
@@ -484,19 +484,16 @@ namespace N4 {
template<typename T>
struct A {
void not_instantiated(A a, A<T> b, T c) {
- a->x; // expected-error {{member reference type 'A<T>' is not a pointer; did you mean to use '.'?}}
- b->x; // expected-error {{member reference type 'A<T>' is not a pointer; did you mean to use '.'?}}
+ a->x;
+ b->x;
c->x;
}
void instantiated(A a, A<T> b, T c) {
- // FIXME: We should only emit a single diagnostic suggesting to use '.'!
- a->x; // expected-error {{member reference type 'A<T>' is not a pointer; did you mean to use '.'?}}
- // expected-error at -1 {{member reference type 'A<int>' is not a pointer; did you mean to use '.'?}}
- // expected-error at -2 {{no member named 'x' in 'N4::A<int>'}}
- b->x; // expected-error {{member reference type 'A<T>' is not a pointer; did you mean to use '.'?}}
- // expected-error at -1 {{member reference type 'A<int>' is not a pointer; did you mean to use '.'?}}
- // expected-error at -2 {{no member named 'x' in 'N4::A<int>'}}
+ a->x; // expected-error {{member reference type 'A<int>' is not a pointer; did you mean to use '.'?}}
+ // expected-error at -1 {{no member named 'x' in 'N4::A<int>'}}
+ b->x; // expected-error {{member reference type 'A<int>' is not a pointer; did you mean to use '.'?}}
+ // expected-error at -1 {{no member named 'x' in 'N4::A<int>'}}
c->x; // expected-error {{member reference type 'int' is not a pointer}}
}
};
@@ -543,10 +540,11 @@ namespace N4 {
a->T::f();
a->T::g();
- a->U::x;
- a->U::y;
- a->U::f();
- a->U::g();
+ // FIXME: 'U' should be a dependent name, and its lookup context should be 'a.operator->()'!
+ a->U::x; // expected-error {{use of undeclared identifier 'U'}}
+ a->U::y; // expected-error {{use of undeclared identifier 'U'}}
+ a->U::f(); // expected-error {{use of undeclared identifier 'U'}}
+ a->U::g(); // expected-error {{use of undeclared identifier 'U'}}
}
void instantiated(D a) {
More information about the cfe-commits
mailing list