From 9cfbe48a7a20a217fdb2920b29b67ae7941cb116 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Sat, 20 Jun 2009 00:51:54 +0000 Subject: [PATCH] Parsing and AST support for using declarations, from John Thompson! git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@73812 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/DeclBase.h | 4 +- include/clang/AST/DeclCXX.h | 55 +++++++++++++++ include/clang/AST/DeclNodes.def | 1 + include/clang/Basic/DiagnosticParseKinds.td | 8 ++- include/clang/Basic/DiagnosticSemaKinds.td | 4 ++ include/clang/Parse/Action.h | 9 +++ lib/AST/DeclBase.cpp | 1 + lib/AST/DeclCXX.cpp | 8 +++ lib/CodeGen/CodeGenModule.cpp | 3 + lib/Parse/MinimalAction.cpp | 16 +++++ lib/Parse/ParseDeclCXX.cpp | 75 +++++++++++++++++++-- lib/Sema/Sema.h | 8 +++ lib/Sema/SemaDecl.cpp | 5 +- lib/Sema/SemaDeclCXX.cpp | 37 ++++++++++ lib/Sema/SemaLookup.cpp | 6 +- test/Parser/cxx-using-declaration.cpp | 45 +++++++++++++ test/Parser/cxx-using-directive.cpp | 3 +- test/SemaCXX/using-directive.cpp | 2 +- 18 files changed, 275 insertions(+), 15 deletions(-) create mode 100644 test/Parser/cxx-using-declaration.cpp diff --git a/include/clang/AST/DeclBase.h b/include/clang/AST/DeclBase.h index e2ca1a3298..a2ee895256 100644 --- a/include/clang/AST/DeclBase.h +++ b/include/clang/AST/DeclBase.h @@ -159,10 +159,12 @@ private: /// \brief Whether this declaration was "used", meaning that a definition is /// required. bool Used : 1; - + +protected: /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in. unsigned IdentifierNamespace : 8; +private: #ifndef NDEBUG void CheckAccessDeclContext() const; #else diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h index 1216eb09ee..9ca1823f38 100644 --- a/include/clang/AST/DeclCXX.h +++ b/include/clang/AST/DeclCXX.h @@ -1049,6 +1049,61 @@ public: } static bool classof(const NamespaceAliasDecl *D) { return true; } }; + +/// UsingDecl - Represents a C++ using-declaration. For example: +/// using someNameSpace::someIdentifier; +class UsingDecl : public NamedDecl { + + /// \brief The source range that covers the nested-name-specifier + /// preceding the declaration name. + SourceRange NestedNameRange; + /// \brief The source location of the target declaration name. + SourceLocation TargetNameLocation; + /// \brief The source location of the "using" location itself. + SourceLocation UsingLocation; + /// \brief Target declaration. + NamedDecl* TargetDecl; + /// \brief Target declaration. + NestedNameSpecifier* TargetNestedNameDecl; + + // Had 'typename' keyword. + bool IsTypeName; + + UsingDecl(DeclContext *DC, SourceLocation L, SourceRange NNR, + SourceLocation TargetNL, SourceLocation UL, NamedDecl* Target, + NestedNameSpecifier* TargetNNS, bool IsTypeNameArg) + : NamedDecl(Decl::Using, DC, L, Target->getDeclName()), + NestedNameRange(NNR), TargetNameLocation(TargetNL), + UsingLocation(UL), TargetDecl(Target), + TargetNestedNameDecl(TargetNNS), IsTypeName(IsTypeNameArg) { + this->IdentifierNamespace = TargetDecl->getIdentifierNamespace(); + } + +public: + /// \brief Returns the source range that covers the nested-name-specifier + /// preceding the namespace name. + SourceRange getNestedNameRange() { return(NestedNameRange); } + /// \brief Returns the source location of the target declaration name. + SourceLocation getTargetNameLocation() { return(TargetNameLocation); } + /// \brief Returns the source location of the "using" location itself. + SourceLocation getUsingLocation() { return(UsingLocation); } + /// \brief getTargetDecl - Returns target specified by using-decl. + NamedDecl *getTargetDecl() { return(TargetDecl); } + /// \brief Get target nested name declaration. + NestedNameSpecifier* getTargetNestedNameDecl() { return(TargetNestedNameDecl); } + /// isTypeName - Return true if using decl had 'typename'. + bool isTypeName() const { return(IsTypeName); } + + static UsingDecl *Create(ASTContext &C, DeclContext *DC, + SourceLocation L, SourceRange NNR, SourceLocation TargetNL, + SourceLocation UL, NamedDecl* Target, + NestedNameSpecifier* TargetNNS, bool IsTypeNameArg); + + static bool classof(const Decl *D) { + return D->getKind() == Decl::Using; + } + static bool classof(const UsingDecl *D) { return true; } +}; /// StaticAssertDecl - Represents a C++0x static_assert declaration. class StaticAssertDecl : public Decl { diff --git a/include/clang/AST/DeclNodes.def b/include/clang/AST/DeclNodes.def index d1b921a4cb..1e4440357b 100644 --- a/include/clang/AST/DeclNodes.def +++ b/include/clang/AST/DeclNodes.def @@ -108,6 +108,7 @@ ABSTRACT_DECL(Named, Decl) DECL(FunctionTemplate, TemplateDecl) DECL(ClassTemplate, TemplateDecl) DECL(TemplateTemplateParm, TemplateDecl) + DECL(Using, NamedDecl) DECL(ObjCMethod, NamedDecl) DECL(ObjCContainer, NamedDecl) DECL(ObjCCategory, ObjCContainerDecl) diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index ccb59eb51c..d65a97eb70 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -154,6 +154,10 @@ def err_unknown_typename : Error< "unknown type name %0">; def err_use_of_tag_name_without_tag : Error< "use of tagged type %0 without '%1' tag">; +def err_expected_ident_in_using : Error< + "expected an identifier in using directive">; +def err_unexpected_template_spec_in_using : Error< + "use of template specialization in using directive not allowed">; /// Objective-C parser diagnostics @@ -214,6 +218,8 @@ def ext_ellipsis_exception_spec : Extension< "exception specification of '...' is a Microsoft extension">; def err_expected_catch : Error<"expected catch">; def err_expected_lbrace_or_comma : Error<"expected '{' or ','">; +def err_using_namespace_in_class : Error< + "'using namespace' in class not allowed">; // C++ derived classes def err_dup_virtual : Error<"duplicate 'virtual' in base specifier">; @@ -289,5 +295,5 @@ def warn_pragma_unused_expected_var : Warning< "expected '#pragma unused' argument to be a variable name">; def warn_pragma_unused_expected_punc : Warning< "expected ')' or ',' in '#pragma unused'">; - + } // end of Parser diagnostics diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 855b7b9d29..6bd925797a 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -92,6 +92,10 @@ def warn_use_out_of_scope_declaration : Warning< "use of out-of-scope declaration of %0">; def err_inline_non_function : Error< "'inline' can only appear on functions">; +def err_using_requires_qualname : Error< + "using declaration requires a qualified name">; +def err_using_typename_non_type : Error< + "'typename' keyword used on a non-type">; def err_invalid_thread : Error< "'__thread' is only allowed on variable declarations">; diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h index 47583993bc..5b57521f67 100644 --- a/include/clang/Parse/Action.h +++ b/include/clang/Parse/Action.h @@ -932,6 +932,15 @@ public: IdentifierInfo *Ident) { return DeclPtrTy(); } + + /// ActOnUsingDirective - This is called when using-directive is parsed. + virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope, + SourceLocation UsingLoc, + const CXXScopeSpec &SS, + SourceLocation IdentLoc, + IdentifierInfo *TargetName, + AttributeList *AttrList, + bool IsTypeName); /// ActOnParamDefaultArgument - Parse default argument for function parameter virtual void ActOnParamDefaultArgument(DeclPtrTy param, diff --git a/lib/AST/DeclBase.cpp b/lib/AST/DeclBase.cpp index b83a503dbb..02e71d7a86 100644 --- a/lib/AST/DeclBase.cpp +++ b/lib/AST/DeclBase.cpp @@ -164,6 +164,7 @@ unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { case ParmVar: case OriginalParmVar: case NonTypeTemplateParm: + case Using: case ObjCMethod: case ObjCContainer: case ObjCCategory: diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp index 2fa5ed7919..7a930d78c1 100644 --- a/lib/AST/DeclCXX.cpp +++ b/lib/AST/DeclCXX.cpp @@ -443,6 +443,14 @@ NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC, Qualifier, IdentLoc, Namespace); } +UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, + SourceLocation L, SourceRange NNR, SourceLocation TargetNL, + SourceLocation UL, NamedDecl* Target, + NestedNameSpecifier* TargetNNS, bool IsTypeNameArg) { + return new (C) UsingDecl(DC, L, NNR, TargetNL, UL, Target, + TargetNNS, IsTypeNameArg); +} + StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, Expr *AssertExpr, StringLiteral *Message) { diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index f8dfbfb532..f926c05a99 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -1481,6 +1481,9 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { case Decl::Namespace: EmitNamespace(cast(D)); break; + // No code generation needed. + case Decl::Using: + break; case Decl::CXXConstructor: EmitCXXConstructors(cast(D)); break; diff --git a/lib/Parse/MinimalAction.cpp b/lib/Parse/MinimalAction.cpp index b018e36519..9ded366b29 100644 --- a/lib/Parse/MinimalAction.cpp +++ b/lib/Parse/MinimalAction.cpp @@ -42,6 +42,22 @@ Action::DeclPtrTy Action::ActOnUsingDirective(Scope *CurScope, return DeclPtrTy(); } +// Defined out-of-line here because of dependecy on AttributeList +Action::DeclPtrTy Action::ActOnUsingDeclaration(Scope *CurScope, + SourceLocation UsingLoc, + const CXXScopeSpec &SS, + SourceLocation IdentLoc, + IdentifierInfo *TargetName, + AttributeList *AttrList, + bool IsTypeName) { + + // FIXME: Parser seems to assume that Action::ActOn* takes ownership over + // passed AttributeList, however other actions don't free it, is it + // temporary state or bug? + delete AttrList; + return DeclPtrTy(); +} + void PrettyStackTraceActionsDecl::print(llvm::raw_ostream &OS) const { if (Loc.isValid()) { diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index 1427814c93..44f231a667 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -253,15 +253,62 @@ Parser::DeclPtrTy Parser::ParseUsingDirective(unsigned Context, /// /// using-declaration: [C++ 7.3.p3: namespace.udecl] /// 'using' 'typename'[opt] ::[opt] nested-name-specifier -/// unqualified-id [TODO] -/// 'using' :: unqualified-id [TODO] +/// unqualified-id +/// 'using' :: unqualified-id /// Parser::DeclPtrTy Parser::ParseUsingDeclaration(unsigned Context, SourceLocation UsingLoc, SourceLocation &DeclEnd) { - assert(false && "Not implemented"); - // FIXME: Implement parsing. - return DeclPtrTy(); + CXXScopeSpec SS; + bool IsTypeName; + + // Ignore optional 'typename'. + if (Tok.is(tok::kw_typename)) { + ConsumeToken(); + IsTypeName = true; + } + else + IsTypeName = false; + + // Parse nested-name-specifier. + ParseOptionalCXXScopeSpecifier(SS); + + AttributeList *AttrList = 0; + IdentifierInfo *TargetName = 0; + SourceLocation IdentLoc = SourceLocation(); + + // Check nested-name specifier. + if (SS.isInvalid()) { + SkipUntil(tok::semi); + return DeclPtrTy(); + } + if (Tok.is(tok::annot_template_id)) { + Diag(Tok, diag::err_unexpected_template_spec_in_using); + SkipUntil(tok::semi); + return DeclPtrTy(); + } + if (Tok.isNot(tok::identifier)) { + Diag(Tok, diag::err_expected_ident_in_using); + // If there was invalid identifier, skip to end of decl, and eat ';'. + SkipUntil(tok::semi); + return DeclPtrTy(); + } + + // Parse identifier. + TargetName = Tok.getIdentifierInfo(); + IdentLoc = ConsumeToken(); + + // Parse (optional) attributes (most likely GNU strong-using extension). + if (Tok.is(tok::kw___attribute)) + AttrList = ParseAttributes(); + + // Eat ';'. + DeclEnd = Tok.getLocation(); + ExpectAndConsume(tok::semi, diag::err_expected_semi_after, + AttrList ? "attributes list" : "namespace name", tok::semi); + + return Actions.ActOnUsingDeclaration(CurScope, UsingLoc, SS, + IdentLoc, TargetName, AttrList, IsTypeName); } /// ParseStaticAssertDeclaration - Parse C++0x static_assert-declaratoion. @@ -790,7 +837,23 @@ void Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS) { ConsumeToken(); return ParseCXXClassMemberDeclaration(AS); } - + + if (Tok.is(tok::kw_using)) { + // Eat 'using'. + SourceLocation UsingLoc = ConsumeToken(); + + if (Tok.is(tok::kw_namespace)) { + Diag(UsingLoc, diag::err_using_namespace_in_class); + SkipUntil(tok::semi, true, true); + } + else { + SourceLocation DeclEnd; + // Otherwise, it must be using-declaration. + ParseUsingDeclaration(Declarator::MemberContext, UsingLoc, DeclEnd); + } + return; + } + SourceLocation DSStart = Tok.getLocation(); // decl-specifier-seq: // Parse the common declaration-specifiers piece. diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h index 230bcffa72..560f952bff 100644 --- a/lib/Sema/Sema.h +++ b/lib/Sema/Sema.h @@ -1547,6 +1547,14 @@ public: const CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident); + + virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope, + SourceLocation UsingLoc, + const CXXScopeSpec &SS, + SourceLocation IdentLoc, + IdentifierInfo *TargetName, + AttributeList *AttrList, + bool IsTypeName); /// AddCXXDirectInitializerToDecl - This action is called immediately after /// ActOnDeclarator, when a C++ direct initializer is present. diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index 2dd02af7b9..06fd1a1736 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -2284,7 +2284,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, Diag(NewFD->getLocation(), diag::err_out_of_line_declaration) << D.getCXXScopeSpec().getRange(); NewFD->setInvalidDecl(); - } else if (!Redeclaration) { + } else if (!Redeclaration && (!PrevDecl || !isa(PrevDecl))) { // The user tried to provide an out-of-line definition for a // function that is a member of a class or namespace, but there // was no such member function declared (C++ [class.mfct]p2, @@ -2455,7 +2455,8 @@ void Sema::CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl, if (PrevDecl && (!AllowOverloadingOfFunction(PrevDecl, Context) || - !IsOverload(NewFD, PrevDecl, MatchedDecl))) { + !IsOverload(NewFD, PrevDecl, MatchedDecl)) && + !isa(PrevDecl)) { Redeclaration = true; Decl *OldDecl = PrevDecl; diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp index 8c547cd1cc..7524cbf500 100644 --- a/lib/Sema/SemaDeclCXX.cpp +++ b/lib/Sema/SemaDeclCXX.cpp @@ -1748,6 +1748,43 @@ void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) { S->PushUsingDirective(DeclPtrTy::make(UDir)); } + +Sema::DeclPtrTy Sema::ActOnUsingDeclaration(Scope *S, + SourceLocation UsingLoc, + const CXXScopeSpec &SS, + SourceLocation IdentLoc, + IdentifierInfo *TargetName, + AttributeList *AttrList, + bool IsTypeName) { + assert(!SS.isInvalid() && "Invalid CXXScopeSpec."); + assert(TargetName && "Invalid TargetName."); + assert(IdentLoc.isValid() && "Invalid TargetName location."); + assert(S->getFlags() & Scope::DeclScope && "Invalid Scope."); + + UsingDecl *UsingAlias = 0; + + // Lookup target name. + LookupResult R = LookupParsedName(S, &SS, TargetName, + LookupOrdinaryName, false); + + if (NamedDecl *NS = R) { + if (IsTypeName && !isa(NS)) { + Diag(IdentLoc, diag::err_using_typename_non_type); + } + UsingAlias = UsingDecl::Create(Context, CurContext, IdentLoc, SS.getRange(), + NS->getLocation(), UsingLoc, NS, + static_cast(SS.getScopeRep()), + IsTypeName); + PushOnScopeChains(UsingAlias, S); + } else { + Diag(IdentLoc, diag::err_using_requires_qualname) << SS.getRange(); + } + + // FIXME: We ignore attributes for now. + delete AttrList; + return DeclPtrTy::make(UsingAlias); +} + /// getNamespaceDecl - Returns the namespace a decl represents. If the decl /// is a namespace alias, returns the namespace it points to. static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) { diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp index 52de4e6f4c..37e1df3a19 100644 --- a/lib/Sema/SemaLookup.cpp +++ b/lib/Sema/SemaLookup.cpp @@ -1151,8 +1151,10 @@ Sema::LookupParsedName(Scope *S, const CXXScopeSpec *SS, Name, NameKind, RedeclarationOnly); } - return LookupName(S, Name, NameKind, RedeclarationOnly, - AllowBuiltinCreation, Loc); + LookupResult result(LookupName(S, Name, NameKind, RedeclarationOnly, + AllowBuiltinCreation, Loc)); + + return(result); } diff --git a/test/Parser/cxx-using-declaration.cpp b/test/Parser/cxx-using-declaration.cpp new file mode 100644 index 0000000000..de0e6f162a --- /dev/null +++ b/test/Parser/cxx-using-declaration.cpp @@ -0,0 +1,45 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +namespace A { + int VA; + void FA() {} + struct SA { int V; }; +} + +using A::VA; +using A::FA; +using typename A::SA; + +void main() +{ + VA = 1; + FA(); + SA x; //Still needs handling. +} + +struct B { + void f(char){}; + void g(char){}; +}; +struct D : B { + using B::f; + void f(int); + void g(int); +}; +void D::f(int) { f('c'); } // calls B::f(char) +void D::g(int) { g('c'); } // recursively calls D::g(int) + +namespace E { + template int funcE(TYPE arg) { return(arg); } +} + +using E::funcE; // expected-error{{use of template specialization in using directive not allowed}} + +namespace F { + struct X; +} + +using F::X; +// Should have some errors here. Waiting for implementation. +void X(int); +struct X *x; diff --git a/test/Parser/cxx-using-directive.cpp b/test/Parser/cxx-using-directive.cpp index 676f4e6c5a..504d026b43 100644 --- a/test/Parser/cxx-using-directive.cpp +++ b/test/Parser/cxx-using-directive.cpp @@ -13,8 +13,7 @@ namespace D { class C { - using namespace B ; // expected-error{{expected member name or ';' after declaration specifiers}} - //FIXME: this needs better error message + using namespace B ; // expected-error{{not allowed}} }; namespace B {} diff --git a/test/SemaCXX/using-directive.cpp b/test/SemaCXX/using-directive.cpp index 924cf077b6..78ad04293b 100644 --- a/test/SemaCXX/using-directive.cpp +++ b/test/SemaCXX/using-directive.cpp @@ -64,7 +64,7 @@ struct K2 k2; // expected-error{{reference to 'K2' is ambiguous}} \ class X { // expected-note{{candidate found by name lookup is 'X'}} // FIXME: produce a suitable error message for this - using namespace A; // expected-error{{expected member name or}} + using namespace A; // expected-error{{not allowed}} }; namespace N { -- 2.40.0