1 //===--- NestedNameSpecifier.cpp - C++ nested name specifiers -----*- C++ -*-=//
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 defines the NestedNameSpecifier class, which represents
11 //  a C++ nested-name-specifier.
12 //
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/NestedNameSpecifier.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/PrettyPrinter.h"
18 #include "clang/AST/Type.h"
19 #include "llvm/Support/raw_ostream.h"
20 #include <cassert>
21 
22 using namespace clang;
23 
24 NestedNameSpecifier *
25 NestedNameSpecifier::FindOrInsert(ASTContext &Context,
26                                   const NestedNameSpecifier &Mockup) {
27   llvm::FoldingSetNodeID ID;
28   Mockup.Profile(ID);
29 
30   void *InsertPos = 0;
31   NestedNameSpecifier *NNS
32     = Context.NestedNameSpecifiers.FindNodeOrInsertPos(ID, InsertPos);
33   if (!NNS) {
34     NNS = new (Context, 4) NestedNameSpecifier(Mockup);
35     Context.NestedNameSpecifiers.InsertNode(NNS, InsertPos);
36   }
37 
38   return NNS;
39 }
40 
41 NestedNameSpecifier *
42 NestedNameSpecifier::Create(ASTContext &Context, NestedNameSpecifier *Prefix,
43                             IdentifierInfo *II) {
44   assert(II && "Identifier cannot be NULL");
45   assert(Prefix && Prefix->isDependent() && "Prefix must be dependent");
46 
47   NestedNameSpecifier Mockup;
48   Mockup.Prefix.setPointer(Prefix);
49   Mockup.Prefix.setInt(Identifier);
50   Mockup.Specifier = II;
51   return FindOrInsert(Context, Mockup);
52 }
53 
54 NestedNameSpecifier *
55 NestedNameSpecifier::Create(ASTContext &Context, NestedNameSpecifier *Prefix,
56                             NamespaceDecl *NS) {
57   assert(NS && "Namespace cannot be NULL");
58   assert((!Prefix ||
59           (Prefix->getAsType() == 0 && Prefix->getAsIdentifier() == 0)) &&
60          "Broken nested name specifier");
61   NestedNameSpecifier Mockup;
62   Mockup.Prefix.setPointer(Prefix);
63   Mockup.Prefix.setInt(Namespace);
64   Mockup.Specifier = NS;
65   return FindOrInsert(Context, Mockup);
66 }
67 
68 NestedNameSpecifier *
69 NestedNameSpecifier::Create(ASTContext &Context, NestedNameSpecifier *Prefix,
70                             bool Template, Type *T) {
71   assert(T && "Type cannot be NULL");
72   NestedNameSpecifier Mockup;
73   Mockup.Prefix.setPointer(Prefix);
74   Mockup.Prefix.setInt(Template? TypeSpecWithTemplate : TypeSpec);
75   Mockup.Specifier = T;
76   return FindOrInsert(Context, Mockup);
77 }
78 
79 NestedNameSpecifier *NestedNameSpecifier::GlobalSpecifier(ASTContext &Context) {
80   if (!Context.GlobalNestedNameSpecifier)
81     Context.GlobalNestedNameSpecifier = new (Context, 4) NestedNameSpecifier();
82   return Context.GlobalNestedNameSpecifier;
83 }
84 
85 /// \brief Whether this nested name specifier refers to a dependent
86 /// type or not.
87 bool NestedNameSpecifier::isDependent() const {
88   switch (getKind()) {
89   case Identifier:
90     // Identifier specifiers always represent dependent types
91     return true;
92 
93   case Namespace:
94   case Global:
95     return false;
96 
97   case TypeSpec:
98   case TypeSpecWithTemplate:
99     return getAsType()->isDependentType();
100   }
101 
102   // Necessary to suppress a GCC warning.
103   return false;
104 }
105 
106 /// \brief Print this nested name specifier to the given output
107 /// stream.
108 void
109 NestedNameSpecifier::print(llvm::raw_ostream &OS,
110                            const PrintingPolicy &Policy) const {
111   if (getPrefix())
112     getPrefix()->print(OS, Policy);
113 
114   switch (getKind()) {
115   case Identifier:
116     OS << getAsIdentifier()->getName();
117     break;
118 
119   case Namespace:
120     OS << getAsNamespace()->getIdentifier()->getName();
121     break;
122 
123   case Global:
124     break;
125 
126   case TypeSpecWithTemplate:
127     OS << "template ";
128     // Fall through to print the type.
129 
130   case TypeSpec: {
131     std::string TypeStr;
132     Type *T = getAsType();
133 
134     // If this is a qualified name type, suppress the qualification:
135     // it's part of our nested-name-specifier sequence anyway.  FIXME:
136     // We should be able to assert that this doesn't happen.
137     if (const QualifiedNameType *QualT = dyn_cast<QualifiedNameType>(T))
138       T = QualT->getNamedType().getTypePtr();
139 
140     PrintingPolicy InnerPolicy(Policy);
141     InnerPolicy.SuppressTagKind = true;
142     T->getAsStringInternal(TypeStr, InnerPolicy);
143     OS << TypeStr;
144     break;
145   }
146   }
147 
148   OS << "::";
149 }
150 
151 void NestedNameSpecifier::Destroy(ASTContext &Context) {
152   this->~NestedNameSpecifier();
153   Context.Deallocate((void *)this);
154 }
155 
156 void NestedNameSpecifier::dump(const LangOptions &LO) {
157   print(llvm::errs(), PrintingPolicy(LO));
158 }
159