From 4a9f481db92ad8c8758fe913d7641df8b9a30792 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Fri, 22 May 2009 23:47:06 +0000 Subject: Template instantiation for qualified declaration reference expressions. We are now missing template instantiation logic for only three classes of expressions: - Blocks-related expressions (BlockExpr, BlockDeclRefExpr) - C++ default argument expressions - Objective-C expressions Additionally, our handling of DeclRefExpr is still quite poor, since it cannot handle references to many kinds of declarations. As part of this change, converted the TemplateExprInstantiator to use iteration through all of the expressions via clang/AST/StmtNodes.def, ensuring that we don't forget to add template instantiation logic for any new expression node kinds. llvm-svn: 72303 --- clang/lib/Sema/SemaTemplateInstantiateExpr.cpp | 182 +++++++++++++++---------- 1 file changed, 112 insertions(+), 70 deletions(-) (limited to 'clang/lib/Sema/SemaTemplateInstantiateExpr.cpp') diff --git a/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp b/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp index 1e57e1b5a37..0c298393308 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateExpr.cpp @@ -34,74 +34,12 @@ namespace { const TemplateArgumentList &TemplateArgs) : SemaRef(SemaRef), TemplateArgs(TemplateArgs) { } - // FIXME: Once we get closer to completion, replace these manually-written - // declarations with automatically-generated ones from - // clang/AST/StmtNodes.def. - OwningExprResult VisitPredefinedExpr(PredefinedExpr *E); - OwningExprResult VisitIntegerLiteral(IntegerLiteral *E); - OwningExprResult VisitFloatingLiteral(FloatingLiteral *E); - OwningExprResult VisitStringLiteral(StringLiteral *E); - OwningExprResult VisitCharacterLiteral(CharacterLiteral *E); - OwningExprResult VisitImaginaryLiteral(ImaginaryLiteral *E); - OwningExprResult VisitDeclRefExpr(DeclRefExpr *E); - OwningExprResult VisitParenExpr(ParenExpr *E); - OwningExprResult VisitUnaryOperator(UnaryOperator *E); - OwningExprResult VisitArraySubscriptExpr(ArraySubscriptExpr *E); - OwningExprResult VisitCallExpr(CallExpr *E); - OwningExprResult VisitMemberExpr(MemberExpr *E); - OwningExprResult VisitCompoundLiteralExpr(CompoundLiteralExpr *E); - OwningExprResult VisitBinaryOperator(BinaryOperator *E); - OwningExprResult VisitCompoundAssignOperator(CompoundAssignOperator *E); - OwningExprResult VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); - OwningExprResult VisitCXXConditionDeclExpr(CXXConditionDeclExpr *E); - OwningExprResult VisitConditionalOperator(ConditionalOperator *E); - OwningExprResult VisitAddrLabelExpr(AddrLabelExpr *E); - OwningExprResult VisitStmtExpr(StmtExpr *E); - OwningExprResult VisitTypesCompatibleExpr(TypesCompatibleExpr *E); - OwningExprResult VisitShuffleVectorExpr(ShuffleVectorExpr *E); - OwningExprResult VisitChooseExpr(ChooseExpr *E); - OwningExprResult VisitVAArgExpr(VAArgExpr *E); - OwningExprResult VisitInitListExpr(InitListExpr *E); - OwningExprResult VisitDesignatedInitExpr(DesignatedInitExpr *E); - OwningExprResult VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); - OwningExprResult VisitExtVectorElementExpr(ExtVectorElementExpr *E); - // FIXME: BlockExpr - // FIXME: BlockDeclRefExpr - OwningExprResult VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E); - OwningExprResult VisitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E); - OwningExprResult VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); - OwningExprResult VisitCastExpr(CastExpr *E); - OwningExprResult VisitImplicitCastExpr(ImplicitCastExpr *E); - OwningExprResult VisitExplicitCastExpr(ExplicitCastExpr *E); - OwningExprResult VisitCStyleCastExpr(CStyleCastExpr *E); - OwningExprResult VisitCXXMemberCallExpr(CXXMemberCallExpr *E); - OwningExprResult VisitCXXNamedCastExpr(CXXNamedCastExpr *E); - OwningExprResult VisitCXXStaticCastExpr(CXXStaticCastExpr *E); - OwningExprResult VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E); - OwningExprResult VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E); - OwningExprResult VisitCXXConstCastExpr(CXXConstCastExpr *E); - OwningExprResult VisitCXXThisExpr(CXXThisExpr *E); - OwningExprResult VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); - OwningExprResult VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); - OwningExprResult VisitCXXTypeidExpr(CXXTypeidExpr *E); - OwningExprResult VisitCXXThrowExpr(CXXThrowExpr *E); - // FIXME: CXXDefaultArgExpr - OwningExprResult VisitCXXConstructExpr(CXXConstructExpr *E); - OwningExprResult VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E); - OwningExprResult VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E); - OwningExprResult VisitCXXNewExpr(CXXNewExpr *E); - OwningExprResult VisitCXXDeleteExpr(CXXDeleteExpr *E); - OwningExprResult VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E); - // FIXME: QualifiedDeclRefExpr - OwningExprResult VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E); - OwningExprResult VisitCXXUnresolvedConstructExpr( - CXXUnresolvedConstructExpr *E); - OwningExprResult VisitCXXUnresolvedMemberExpr(CXXUnresolvedMemberExpr *E); - OwningExprResult VisitGNUNullExpr(GNUNullExpr *E); - OwningExprResult VisitUnresolvedFunctionNameExpr( - UnresolvedFunctionNameExpr *E); - - // Base case. I'm supposed to ignore this. + // Declare VisitXXXStmt nodes for all of the expression kinds. +#define EXPR(Type, Base) OwningExprResult Visit##Type(Type *S); +#define STMT(Type, Base) +#include "clang/AST/StmtNodes.def" + + // Base case. We can't get here. Sema::OwningExprResult VisitStmt(Stmt *S) { S->dump(); assert(false && "Cannot instantiate this kind of expression"); @@ -110,6 +48,13 @@ namespace { }; } +// Base case. We can't get here. +Sema::OwningExprResult TemplateExprInstantiator::VisitExpr(Expr *E) { + E->dump(); + assert(false && "Cannot instantiate this kind of expression"); + return SemaRef.ExprError(); +} + Sema::OwningExprResult TemplateExprInstantiator::VisitPredefinedExpr(PredefinedExpr *E) { return SemaRef.Clone(E); @@ -191,12 +136,13 @@ TemplateExprInstantiator::VisitDeclRefExpr(DeclRefExpr *E) { if (Var->hasLocalStorage()) NewD = SemaRef.CurrentInstantiationScope->getInstantiationOf(Var); else - assert(false && "Cannot instantiation non-local variable declarations"); + assert(false && + "FIXME: instantiation of non-local variable declarations"); } else if (isa(D) || isa(D)) { // FIXME: Instantiate decl! NewD = cast(D); } else - assert(false && "Unhandled declaratrion reference kind"); + assert(false && "FIXME: unhandled declaration reference kind"); if (!NewD) return SemaRef.ExprError(); @@ -731,6 +677,18 @@ TemplateExprInstantiator::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); } +Sema::OwningExprResult +TemplateExprInstantiator::VisitBlockExpr(BlockExpr *E) { + assert(false && "FIXME:Template instantiation for blocks is unimplemented"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { + assert(false && "FIXME:Template instantiation for blocks is unimplemented"); + return SemaRef.ExprError(); +} + Sema::OwningExprResult TemplateExprInstantiator::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { bool isSizeOf = E->isSizeOf(); @@ -1012,6 +970,13 @@ TemplateExprInstantiator::VisitCXXThrowExpr(CXXThrowExpr *E) { return SemaRef.ActOnCXXThrow(E->getThrowLoc(), move(SubExpr)); } +Sema::OwningExprResult +TemplateExprInstantiator::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { + assert(false && + "FIXME: Instantiation for default arguments is unimplemented"); + return SemaRef.ExprError(); +} + Sema::OwningExprResult TemplateExprInstantiator::VisitCXXConstructExpr(CXXConstructExpr *E) { assert(!cast(E->getConstructor()->getDeclContext()) @@ -1164,6 +1129,26 @@ TemplateExprInstantiator::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { E->getSourceRange().getEnd()); } +Sema::OwningExprResult +TemplateExprInstantiator::VisitQualifiedDeclRefExpr(QualifiedDeclRefExpr *E) { + NestedNameSpecifier *NNS + = SemaRef.InstantiateNestedNameSpecifier(E->getQualifier(), + E->getQualifierRange(), + TemplateArgs); + if (!NNS) + return SemaRef.ExprError(); + + CXXScopeSpec SS; + SS.setRange(E->getQualifierRange()); + SS.setScopeRep(NNS); + return SemaRef.ActOnDeclarationNameExpr(/*Scope=*/0, + E->getLocation(), + E->getDecl()->getDeclName(), + /*Trailing lparen=*/false, + &SS, + /*FIXME:*/false); +} + Sema::OwningExprResult TemplateExprInstantiator::VisitCXXExprWithTemporaries( CXXExprWithTemporaries *E) { @@ -1226,6 +1211,63 @@ TemplateExprInstantiator::VisitCXXUnresolvedMemberExpr( /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); } +//---------------------------------------------------------------------------- +// Objective-C Expressions +//---------------------------------------------------------------------------- +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCStringLiteral(ObjCStringLiteral *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCMessageExpr(ObjCMessageExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCKVCRefExpr(ObjCKVCRefExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + +Sema::OwningExprResult +TemplateExprInstantiator::VisitObjCSuperExpr(ObjCSuperExpr *E) { + assert(false && "FIXME: Template instantiations for ObjC expressions"); + return SemaRef.ExprError(); +} + Sema::OwningExprResult Sema::InstantiateExpr(Expr *E, const TemplateArgumentList &TemplateArgs) { if (!E) -- cgit v1.2.3