From 865d447ac6a4721ab58e898d014a21f2eff74b06 Mon Sep 17 00:00:00 2001 From: John McCall Date: Thu, 19 Nov 2009 22:55:06 +0000 Subject: [PATCH] Draw a brighter line between "unresolved" expressions, where we have done the appropriate lookup and simply can't resolve the referrent yet, and "dependent scope" expressions, where we can't do the lookup yet because the entity we need to look into is a dependent type. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@89402 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/ExprCXX.h | 38 ++++++++++++++++----------------- include/clang/AST/StmtNodes.def | 4 ++-- lib/AST/Expr.cpp | 4 ++-- lib/AST/ExprCXX.cpp | 26 +++++++++++----------- lib/AST/StmtPrinter.cpp | 6 ++++-- lib/AST/StmtProfile.cpp | 6 ++++-- lib/CodeGen/Mangle.cpp | 4 ++-- lib/Sema/SemaExpr.cpp | 8 +++---- lib/Sema/SemaTemplate.cpp | 2 +- lib/Sema/TreeTransform.h | 20 ++++++++--------- 10 files changed, 61 insertions(+), 57 deletions(-) diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h index 9e6fd4fd06..2e43c5fec9 100644 --- a/include/clang/AST/ExprCXX.h +++ b/include/clang/AST/ExprCXX.h @@ -1066,18 +1066,18 @@ public: /// \brief A qualified reference to a name whose declaration cannot /// yet be resolved. /// -/// UnresolvedDeclRefExpr is similar to eclRefExpr in that +/// DependentScopeDeclRefExpr is similar to eclRefExpr in that /// it expresses a reference to a declaration such as /// X::value. The difference, however, is that an -/// UnresolvedDeclRefExpr node is used only within C++ templates when +/// DependentScopeDeclRefExpr node is used only within C++ templates when /// the qualification (e.g., X::) refers to a dependent type. In /// this case, X::value cannot resolve to a declaration because the /// declaration will differ from on instantiation of X to the -/// next. Therefore, UnresolvedDeclRefExpr keeps track of the +/// next. Therefore, DependentScopeDeclRefExpr keeps track of the /// qualifier (X::) and the name of the entity being referenced /// ("value"). Such expressions will instantiate to a DeclRefExpr once the /// declaration can be found. -class UnresolvedDeclRefExpr : public Expr { +class DependentScopeDeclRefExpr : public Expr { /// The name of the entity we will be referencing. DeclarationName Name; @@ -1097,10 +1097,10 @@ class UnresolvedDeclRefExpr : public Expr { bool IsAddressOfOperand; public: - UnresolvedDeclRefExpr(DeclarationName N, QualType T, SourceLocation L, - SourceRange R, NestedNameSpecifier *NNS, - bool IsAddressOfOperand) - : Expr(UnresolvedDeclRefExprClass, T, true, true), + DependentScopeDeclRefExpr(DeclarationName N, QualType T, SourceLocation L, + SourceRange R, NestedNameSpecifier *NNS, + bool IsAddressOfOperand) + : Expr(DependentScopeDeclRefExprClass, T, true, true), Name(N), Loc(L), QualifierRange(R), NNS(NNS), IsAddressOfOperand(IsAddressOfOperand) { } @@ -1125,9 +1125,9 @@ public: } static bool classof(const Stmt *T) { - return T->getStmtClass() == UnresolvedDeclRefExprClass; + return T->getStmtClass() == DependentScopeDeclRefExprClass; } - static bool classof(const UnresolvedDeclRefExpr *) { return true; } + static bool classof(const DependentScopeDeclRefExpr *) { return true; } virtual StmtIterator child_begin(); virtual StmtIterator child_end(); @@ -1380,7 +1380,7 @@ public: /// \brief Represents a C++ member access expression where the actual member /// referenced could not be resolved, e.g., because the base expression or the /// member name was dependent. -class CXXUnresolvedMemberExpr : public Expr { +class CXXDependentScopeMemberExpr : public Expr { /// \brief The expression for the base pointer or class reference, /// e.g., the \c x in x.f. Stmt *Base; @@ -1408,7 +1408,7 @@ class CXXUnresolvedMemberExpr : public Expr { /// /// FIXME: This member, along with the Qualifier and QualifierRange, could /// be stuck into a structure that is optionally allocated at the end of - /// the CXXUnresolvedMemberExpr, to save space in the common case. + /// the CXXDependentScopeMemberExpr, to save space in the common case. NamedDecl *FirstQualifierFoundInScope; /// \brief The member to which this member expression refers, which @@ -1431,11 +1431,11 @@ class CXXUnresolvedMemberExpr : public Expr { /// \brief Retrieve the explicit template argument list that followed the /// member template name, if any. const ExplicitTemplateArgumentList *getExplicitTemplateArgumentList() const { - return const_cast(this) + return const_cast(this) ->getExplicitTemplateArgumentList(); } - CXXUnresolvedMemberExpr(ASTContext &C, + CXXDependentScopeMemberExpr(ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -1450,7 +1450,7 @@ class CXXUnresolvedMemberExpr : public Expr { SourceLocation RAngleLoc); public: - CXXUnresolvedMemberExpr(ASTContext &C, + CXXDependentScopeMemberExpr(ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -1458,14 +1458,14 @@ public: NamedDecl *FirstQualifierFoundInScope, DeclarationName Member, SourceLocation MemberLoc) - : Expr(CXXUnresolvedMemberExprClass, C.DependentTy, true, true), + : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, true, true), Base(Base), IsArrow(IsArrow), HasExplicitTemplateArgumentList(false), OperatorLoc(OperatorLoc), Qualifier(Qualifier), QualifierRange(QualifierRange), FirstQualifierFoundInScope(FirstQualifierFoundInScope), Member(Member), MemberLoc(MemberLoc) { } - static CXXUnresolvedMemberExpr * + static CXXDependentScopeMemberExpr * Create(ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, @@ -1579,9 +1579,9 @@ public: } static bool classof(const Stmt *T) { - return T->getStmtClass() == CXXUnresolvedMemberExprClass; + return T->getStmtClass() == CXXDependentScopeMemberExprClass; } - static bool classof(const CXXUnresolvedMemberExpr *) { return true; } + static bool classof(const CXXDependentScopeMemberExpr *) { return true; } // Iterators virtual child_iterator child_begin(); diff --git a/include/clang/AST/StmtNodes.def b/include/clang/AST/StmtNodes.def index 034029a169..2001fed87c 100644 --- a/include/clang/AST/StmtNodes.def +++ b/include/clang/AST/StmtNodes.def @@ -127,14 +127,14 @@ EXPR(CXXDeleteExpr , Expr) EXPR(CXXPseudoDestructorExpr, Expr) EXPR(UnresolvedFunctionNameExpr , Expr) EXPR(UnaryTypeTraitExpr , Expr) -EXPR(UnresolvedDeclRefExpr , Expr) +EXPR(DependentScopeDeclRefExpr , Expr) EXPR(TemplateIdRefExpr , Expr) EXPR(CXXConstructExpr , Expr) EXPR(CXXBindTemporaryExpr , Expr) EXPR(CXXExprWithTemporaries , Expr) EXPR(CXXTemporaryObjectExpr , CXXConstructExpr) EXPR(CXXUnresolvedConstructExpr, Expr) -EXPR(CXXUnresolvedMemberExpr, Expr) +EXPR(CXXDependentScopeMemberExpr, Expr) // Obj-C Expressions. EXPR(ObjCStringLiteral , Expr) diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 90b50c61f9..91b89e7dde 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -1496,14 +1496,14 @@ static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { case Expr::CXXDeleteExprClass: case Expr::CXXPseudoDestructorExprClass: case Expr::UnresolvedFunctionNameExprClass: - case Expr::UnresolvedDeclRefExprClass: + case Expr::DependentScopeDeclRefExprClass: case Expr::TemplateIdRefExprClass: case Expr::CXXConstructExprClass: case Expr::CXXBindTemporaryExprClass: case Expr::CXXExprWithTemporariesClass: case Expr::CXXTemporaryObjectExprClass: case Expr::CXXUnresolvedConstructExprClass: - case Expr::CXXUnresolvedMemberExprClass: + case Expr::CXXDependentScopeMemberExprClass: case Expr::ObjCStringLiteralClass: case Expr::ObjCEncodeExprClass: case Expr::ObjCMessageExprClass: diff --git a/lib/AST/ExprCXX.cpp b/lib/AST/ExprCXX.cpp index 0ba4608ee1..06f2a29b2d 100644 --- a/lib/AST/ExprCXX.cpp +++ b/lib/AST/ExprCXX.cpp @@ -136,12 +136,12 @@ Stmt::child_iterator UnaryTypeTraitExpr::child_end() { return child_iterator(); } -// UnresolvedDeclRefExpr -StmtIterator UnresolvedDeclRefExpr::child_begin() { +// DependentScopeDeclRefExpr +StmtIterator DependentScopeDeclRefExpr::child_begin() { return child_iterator(); } -StmtIterator UnresolvedDeclRefExpr::child_end() { +StmtIterator DependentScopeDeclRefExpr::child_end() { return child_iterator(); } @@ -526,7 +526,7 @@ Stmt::child_iterator CXXUnresolvedConstructExpr::child_end() { return child_iterator(reinterpret_cast(this + 1) + NumArgs); } -CXXUnresolvedMemberExpr::CXXUnresolvedMemberExpr(ASTContext &C, +CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -539,7 +539,7 @@ CXXUnresolvedMemberExpr::CXXUnresolvedMemberExpr(ASTContext &C, const TemplateArgumentLoc *TemplateArgs, unsigned NumTemplateArgs, SourceLocation RAngleLoc) - : Expr(CXXUnresolvedMemberExprClass, C.DependentTy, true, true), + : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, true, true), Base(Base), IsArrow(IsArrow), HasExplicitTemplateArgumentList(HasExplicitTemplateArgs), OperatorLoc(OperatorLoc), @@ -559,8 +559,8 @@ CXXUnresolvedMemberExpr::CXXUnresolvedMemberExpr(ASTContext &C, } } -CXXUnresolvedMemberExpr * -CXXUnresolvedMemberExpr::Create(ASTContext &C, +CXXDependentScopeMemberExpr * +CXXDependentScopeMemberExpr::Create(ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -574,16 +574,16 @@ CXXUnresolvedMemberExpr::Create(ASTContext &C, unsigned NumTemplateArgs, SourceLocation RAngleLoc) { if (!HasExplicitTemplateArgs) - return new (C) CXXUnresolvedMemberExpr(C, Base, IsArrow, OperatorLoc, + return new (C) CXXDependentScopeMemberExpr(C, Base, IsArrow, OperatorLoc, Qualifier, QualifierRange, FirstQualifierFoundInScope, Member, MemberLoc); - void *Mem = C.Allocate(sizeof(CXXUnresolvedMemberExpr) + + void *Mem = C.Allocate(sizeof(CXXDependentScopeMemberExpr) + sizeof(ExplicitTemplateArgumentList) + sizeof(TemplateArgumentLoc) * NumTemplateArgs, - llvm::alignof()); - return new (Mem) CXXUnresolvedMemberExpr(C, Base, IsArrow, OperatorLoc, + llvm::alignof()); + return new (Mem) CXXDependentScopeMemberExpr(C, Base, IsArrow, OperatorLoc, Qualifier, QualifierRange, FirstQualifierFoundInScope, Member, @@ -595,10 +595,10 @@ CXXUnresolvedMemberExpr::Create(ASTContext &C, RAngleLoc); } -Stmt::child_iterator CXXUnresolvedMemberExpr::child_begin() { +Stmt::child_iterator CXXDependentScopeMemberExpr::child_begin() { return child_iterator(&Base); } -Stmt::child_iterator CXXUnresolvedMemberExpr::child_end() { +Stmt::child_iterator CXXDependentScopeMemberExpr::child_end() { return child_iterator(&Base + 1); } diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index 4bd7f964be..0bf6b32564 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -483,7 +483,8 @@ void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) { Policy); } -void StmtPrinter::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *Node) { +void StmtPrinter::VisitDependentScopeDeclRefExpr( + DependentScopeDeclRefExpr *Node) { Node->getQualifier()->print(OS, Policy); OS << Node->getDeclName().getAsString(); } @@ -1146,7 +1147,8 @@ StmtPrinter::VisitCXXUnresolvedConstructExpr( OS << ")"; } -void StmtPrinter::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *Node) { +void StmtPrinter::VisitCXXDependentScopeMemberExpr( + CXXDependentScopeMemberExpr *Node) { PrintExpr(Node->getBase()); OS << (Node->isArrow() ? "->" : "."); if (NestedNameSpecifier *Qualifier = Node->getQualifier()) diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index 4458c2b9cd..e9f6cee115 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -526,7 +526,8 @@ void StmtProfiler::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *S) { VisitType(S->getQueriedType()); } -void StmtProfiler::VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *S) { +void +StmtProfiler::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) { VisitExpr(S); VisitName(S->getDeclName()); VisitNestedNameSpecifier(S->getQualifier()); @@ -554,7 +555,8 @@ StmtProfiler::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S) { VisitType(S->getTypeAsWritten()); } -void StmtProfiler::VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *S) { +void +StmtProfiler::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S) { VisitExpr(S); ID.AddBoolean(S->isArrow()); VisitNestedNameSpecifier(S->getQualifier()); diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp index 0a7124de36..1d2f2e6454 100644 --- a/lib/CodeGen/Mangle.cpp +++ b/lib/CodeGen/Mangle.cpp @@ -1061,8 +1061,8 @@ void CXXNameMangler::mangleExpression(const Expr *E) { break; } - case Expr::UnresolvedDeclRefExprClass: { - const UnresolvedDeclRefExpr *DRE = cast(E); + case Expr::DependentScopeDeclRefExprClass: { + const DependentScopeDeclRefExpr *DRE = cast(E); const Type *QTy = DRE->getQualifier()->getAsType(); assert(QTy && "Qualifier was not type!"); diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp index 4f08ffe9db..789519368b 100644 --- a/lib/Sema/SemaExpr.cpp +++ b/lib/Sema/SemaExpr.cpp @@ -676,7 +676,7 @@ Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc, // names a dependent type. // FIXME: Member of the current instantiation. if (SS && isDependentScopeSpecifier(*SS)) { - return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy, + return Owned(new (Context) DependentScopeDeclRefExpr(Name, Context.DependentTy, Loc, SS->getRange(), static_cast(SS->getScopeRep()), isAddressOfOperand)); @@ -1868,7 +1868,7 @@ Sema::BuildMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, FirstQualifierInScope = FindFirstQualifierInScope(S, Qualifier); } - return Owned(CXXUnresolvedMemberExpr::Create(Context, BaseExpr, true, + return Owned(CXXDependentScopeMemberExpr::Create(Context, BaseExpr, true, OpLoc, Qualifier, SS? SS->getRange() : SourceRange(), FirstQualifierInScope, @@ -1908,7 +1908,7 @@ Sema::BuildMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, FirstQualifierInScope = FindFirstQualifierInScope(S, Qualifier); } - return Owned(CXXUnresolvedMemberExpr::Create(Context, + return Owned(CXXDependentScopeMemberExpr::Create(Context, BaseExpr, false, OpLoc, Qualifier, @@ -1946,7 +1946,7 @@ Sema::BuildMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, } // FIXME: If DC is not computable, we should build a - // CXXUnresolvedMemberExpr. + // CXXDependentScopeMemberExpr. assert(DC && "Cannot handle non-computable dependent contexts in lookup"); } diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 31cd30083e..8d77b1ff9b 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -1679,7 +1679,7 @@ bool Sema::CheckTemplateArgument(NamedDecl *Param, // parsed as a template template argument. However, since we now // know that we need a non-type template argument, convert this // template name into an expression. - Expr *E = new (Context) UnresolvedDeclRefExpr(DTN->getIdentifier(), + Expr *E = new (Context) DependentScopeDeclRefExpr(DTN->getIdentifier(), Context.DependentTy, Arg.getTemplateNameLoc(), Arg.getTemplateQualifierRange(), diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index ca680c279b..579937ead7 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -1456,7 +1456,7 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildUnresolvedDeclRefExpr(NestedNameSpecifier *NNS, + OwningExprResult RebuildDependentScopeDeclRefExpr(NestedNameSpecifier *NNS, SourceRange QualifierRange, DeclarationName Name, SourceLocation Location, @@ -1546,7 +1546,7 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, + OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -1575,7 +1575,7 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, + OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifier *Qualifier, @@ -4592,8 +4592,8 @@ TreeTransform::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E, template Sema::OwningExprResult -TreeTransform::TransformUnresolvedDeclRefExpr( - UnresolvedDeclRefExpr *E, +TreeTransform::TransformDependentScopeDeclRefExpr( + DependentScopeDeclRefExpr *E, bool isAddressOfOperand) { NestedNameSpecifier *NNS = getDerived().TransformNestedNameSpecifier(E->getQualifier(), @@ -4611,7 +4611,7 @@ TreeTransform::TransformUnresolvedDeclRefExpr( Name == E->getDeclName()) return SemaRef.Owned(E->Retain()); - return getDerived().RebuildUnresolvedDeclRefExpr(NNS, + return getDerived().RebuildDependentScopeDeclRefExpr(NNS, E->getQualifierRange(), Name, E->getLocation(), @@ -4828,8 +4828,8 @@ TreeTransform::TransformCXXUnresolvedConstructExpr( template Sema::OwningExprResult -TreeTransform::TransformCXXUnresolvedMemberExpr( - CXXUnresolvedMemberExpr *E, +TreeTransform::TransformCXXDependentScopeMemberExpr( + CXXDependentScopeMemberExpr *E, bool isAddressOfOperand) { // Transform the base of the expression. OwningExprResult Base = getDerived().TransformExpr(E->getBase()); @@ -4878,7 +4878,7 @@ TreeTransform::TransformCXXUnresolvedMemberExpr( FirstQualifierInScope == E->getFirstQualifierFoundInScope()) return SemaRef.Owned(E->Retain()); - return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), + return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), E->isArrow(), E->getOperatorLoc(), Qualifier, @@ -4912,7 +4912,7 @@ TreeTransform::TransformCXXUnresolvedMemberExpr( return SemaRef.ExprError(); } - return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), + return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), E->isArrow(), E->getOperatorLoc(), Qualifier, -- 2.40.0