SemaCXXScopeSpec.cpp revision 81c85c421197a602523781a6ef730639c4c6ea51 
1//===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements C++ semantic analysis for scope specifiers.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/NestedNameSpecifier.h"
17#include "clang/Parse/DeclSpec.h"
18#include "llvm/ADT/STLExtras.h"
19using namespace clang;
20
21/// \brief Compute the DeclContext that is associated with the given
22/// scope specifier.
23DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS) {
24  if (!SS.isSet() || SS.isInvalid())
25    return 0;
26
27  NestedNameSpecifier *NNS
28    = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
29  if (NNS->isDependent())
30    return 0;
31
32  switch (NNS->getKind()) {
33  case NestedNameSpecifier::Identifier:
34    assert(false && "Dependent nested-name-specifier has no DeclContext");
35    break;
36
37  case NestedNameSpecifier::Namespace:
38    return NNS->getAsNamespace();
39
40  case NestedNameSpecifier::TypeSpec:
41  case NestedNameSpecifier::TypeSpecWithTemplate: {
42    const TagType *Tag = NNS->getAsType()->getAsTagType();
43    assert(Tag && "Non-tag type in nested-name-specifier");
44    return Tag->getDecl();
45  } break;
46
47  case NestedNameSpecifier::Global:
48    return Context.getTranslationUnitDecl();
49  }
50
51  // Required to silence a GCC warning.
52  return 0;
53}
54
55bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
56  if (!SS.isSet() || SS.isInvalid())
57    return false;
58
59  NestedNameSpecifier *NNS
60    = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
61  return NNS->isDependent();
62}
63
64/// \brief Require that the context specified by SS be complete.
65///
66/// If SS refers to a type, this routine checks whether the type is
67/// complete enough (or can be made complete enough) for name lookup
68/// into the DeclContext. A type that is not yet completed can be
69/// considered "complete enough" if it is a class/struct/union/enum
70/// that is currently being defined. Or, if we have a type that names
71/// a class template specialization that is not a complete type, we
72/// will attempt to instantiate that class template.
73bool Sema::RequireCompleteDeclContext(const CXXScopeSpec &SS) {
74  if (!SS.isSet() || SS.isInvalid())
75    return false;
76
77  DeclContext *DC = computeDeclContext(SS);
78  if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
79    // If we're currently defining this type, then lookup into the
80    // type is okay: don't complain that it isn't complete yet.
81    const TagType *TagT = Context.getTypeDeclType(Tag)->getAsTagType();
82    if (TagT->isBeingDefined())
83      return false;
84
85    // The type must be complete.
86    return RequireCompleteType(SS.getRange().getBegin(),
87                               Context.getTypeDeclType(Tag),
88                               diag::err_incomplete_nested_name_spec,
89                               SS.getRange());
90  }
91
92  return false;
93}
94
95/// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
96/// global scope ('::').
97Sema::CXXScopeTy *Sema::ActOnCXXGlobalScopeSpecifier(Scope *S,
98                                                     SourceLocation CCLoc) {
99  return NestedNameSpecifier::GlobalSpecifier(Context);
100}
101
102/// ActOnCXXNestedNameSpecifier - Called during parsing of a
103/// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
104/// we want to resolve "bar::". 'SS' is empty or the previously parsed
105/// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
106/// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
107/// Returns a CXXScopeTy* object representing the C++ scope.
108Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S,
109                                                    const CXXScopeSpec &SS,
110                                                    SourceLocation IdLoc,
111                                                    SourceLocation CCLoc,
112                                                    IdentifierInfo &II) {
113  NestedNameSpecifier *Prefix
114    = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
115
116  // If the prefix is already dependent, there is no name lookup to
117  // perform. Just build the resulting nested-name-specifier.
118  if (Prefix && Prefix->isDependent())
119    return NestedNameSpecifier::Create(Context, Prefix, &II);
120
121  NamedDecl *SD = LookupParsedName(S, &SS, &II, LookupNestedNameSpecifierName);
122
123  if (SD) {
124    if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD))
125      return NestedNameSpecifier::Create(Context, Prefix, Namespace);
126
127    if (TypeDecl *Type = dyn_cast<TypeDecl>(SD)) {
128      // Determine whether we have a class (or, in C++0x, an enum) or
129      // a typedef thereof. If so, build the nested-name-specifier.
130      QualType T = Context.getTypeDeclType(Type);
131      bool AcceptableType = false;
132      if (T->isDependentType())
133        AcceptableType = true;
134      else if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) {
135        if (TD->getUnderlyingType()->isRecordType() ||
136            (getLangOptions().CPlusPlus0x &&
137             TD->getUnderlyingType()->isEnumeralType()))
138          AcceptableType = true;
139      } else if (isa<RecordDecl>(Type) ||
140                 (getLangOptions().CPlusPlus0x && isa<EnumDecl>(Type)))
141        AcceptableType = true;
142
143      if (AcceptableType)
144        return NestedNameSpecifier::Create(Context, Prefix, false,
145                                           T.getTypePtr());
146    }
147
148    if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD))
149      return NestedNameSpecifier::Create(Context, Prefix,
150                                         Alias->getNamespace());
151
152    // Fall through to produce an error: we found something that isn't
153    // a class or a namespace.
154  }
155
156  // If we didn't find anything during our lookup, try again with
157  // ordinary name lookup, which can help us produce better error
158  // messages.
159  if (!SD)
160    SD = LookupParsedName(S, &SS, &II, LookupOrdinaryName);
161  unsigned DiagID;
162  if (SD)
163    DiagID = diag::err_expected_class_or_namespace;
164  else if (SS.isSet())
165    DiagID = diag::err_typecheck_no_member;
166  else
167    DiagID = diag::err_undeclared_var_use;
168
169  if (SS.isSet())
170    Diag(IdLoc, DiagID) << &II << SS.getRange();
171  else
172    Diag(IdLoc, DiagID) << &II;
173
174  return 0;
175}
176
177Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S,
178                                                    const CXXScopeSpec &SS,
179                                                    TypeTy *Ty,
180                                                    SourceRange TypeRange,
181                                                    SourceLocation CCLoc) {
182  NestedNameSpecifier *Prefix
183    = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
184  return NestedNameSpecifier::Create(Context, Prefix, /*FIXME:*/false,
185                                QualType::getFromOpaquePtr(Ty).getTypePtr());
186}
187
188/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
189/// scope or nested-name-specifier) is parsed, part of a declarator-id.
190/// After this method is called, according to [C++ 3.4.3p3], names should be
191/// looked up in the declarator-id's scope, until the declarator is parsed and
192/// ActOnCXXExitDeclaratorScope is called.
193/// The 'SS' should be a non-empty valid CXXScopeSpec.
194void Sema::ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
195  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
196  assert(PreDeclaratorDC == 0 && "Previous declarator context not popped?");
197  PreDeclaratorDC = static_cast<DeclContext*>(S->getEntity());
198  CurContext = computeDeclContext(SS);
199  assert(CurContext && "No context?");
200  S->setEntity(CurContext);
201}
202
203/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
204/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
205/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
206/// Used to indicate that names should revert to being looked up in the
207/// defining scope.
208void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
209  assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
210  assert(S->getEntity() == computeDeclContext(SS) && "Context imbalance!");
211  S->setEntity(PreDeclaratorDC);
212  PreDeclaratorDC = 0;
213
214  // Reset CurContext to the nearest enclosing context.
215  while (!S->getEntity() && S->getParent())
216    S = S->getParent();
217  CurContext = static_cast<DeclContext*>(S->getEntity());
218  assert(CurContext && "No context?");
219}
220