1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements C++ semantic analysis for scope specifiers.
//
//===----------------------------------------------------------------------===//
#include "Sema.h"
#include "clang/AST/ASTContext.h"
#include "clang/Parse/DeclSpec.h"
#include "clang/Basic/Diagnostic.h"
using namespace clang;
namespace {
Decl *LookupNestedName(DeclContext *LookupCtx, bool LookInParentCtx,
DeclarationName Name, bool &IdIsUndeclared) {
IdentifierResolver::iterator
I = IdentifierResolver::begin(Name, LookupCtx, LookInParentCtx),
E = IdentifierResolver::end();
if (I == E) {
IdIsUndeclared = true;
return 0;
}
IdIsUndeclared = false;
// C++ 3.4.3p1 :
// During the lookup for a name preceding the :: scope resolution operator,
// object, function, and enumerator names are ignored. If the name found is
// not a class-name or namespace-name, the program is ill-formed.
for (; I != E; ++I) {
if (TypedefDecl *TD = dyn_cast<TypedefDecl>(*I)) {
if (TD->getUnderlyingType()->isRecordType())
break;
continue;
}
if (((*I)->getIdentifierNamespace()&Decl::IDNS_Tag) && !isa<EnumDecl>(*I))
break;
}
return (I != E ? *I : 0);
}
} // anonymous namespace
/// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
/// global scope ('::').
Sema::CXXScopeTy *Sema::ActOnCXXGlobalScopeSpecifier(Scope *S,
SourceLocation CCLoc) {
return cast<DeclContext>(Context.getTranslationUnitDecl());
}
/// ActOnCXXNestedNameSpecifier - Called during parsing of a
/// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
/// we want to resolve "bar::". 'SS' is empty or the previously parsed
/// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
/// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
/// Returns a CXXScopeTy* object representing the C++ scope.
Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S,
const CXXScopeSpec &SS,
SourceLocation IdLoc,
SourceLocation CCLoc,
IdentifierInfo &II) {
DeclContext *DC = static_cast<DeclContext*>(SS.getScopeRep());
Decl *SD;
bool IdIsUndeclared;
if (DC)
SD = LookupNestedName(DC, false/*LookInParentCtx*/, &II, IdIsUndeclared);
else
SD = LookupNestedName(CurContext, true/*LookInParent*/, &II,
IdIsUndeclared);
if (SD) {
if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) {
assert(TD->getUnderlyingType()->isRecordType() &&"Invalid Scope Decl!");
SD = TD->getUnderlyingType()->getAsRecordType()->getDecl();
}
assert((isa<NamespaceDecl>(SD) || isa<RecordDecl>(SD)) &&
"Invalid Scope Decl!");
return cast<DeclContext>(SD);
}
unsigned DiagID;
if (!IdIsUndeclared)
DiagID = diag::err_expected_class_or_namespace;
else if (DC)
DiagID = diag::err_typecheck_no_member;
else
DiagID = diag::err_undeclared_var_use;
if (DC)
Diag(IdLoc, DiagID) << &II << SS.getRange();
else
Diag(IdLoc, DiagID) << &II;
return 0;
}
/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
/// scope or nested-name-specifier) is parsed, part of a declarator-id.
/// After this method is called, according to [C++ 3.4.3p3], names should be
/// looked up in the declarator-id's scope, until the declarator is parsed and
/// ActOnCXXExitDeclaratorScope is called.
/// The 'SS' should be a non-empty valid CXXScopeSpec.
void Sema::ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
assert(PreDeclaratorDC == 0 && "Previous declarator context not popped?");
PreDeclaratorDC = CurContext;
CurContext = static_cast<DeclContext*>(SS.getScopeRep());
}
/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
/// Used to indicate that names should revert to being looked up in the
/// defining scope.
void Sema::ActOnCXXExitDeclaratorScope(const CXXScopeSpec &SS) {
assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
assert(CurContext == static_cast<DeclContext*>(SS.getScopeRep()) &&
"Context imbalance!");
CurContext = PreDeclaratorDC;
PreDeclaratorDC = 0;
}
|
