1 // Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE.
20
21 #include "Control.h"
22 #include "CoreTypes.h"
23 #include "Literals.h"
24 #include "Matcher.h"
25 #include "Names.h"
26 #include "Scope.h"
27 #include "Symbols.h"
28 #include "SymbolVisitor.h"
29 #include "Templates.h"
30 #include "TypeVisitor.h"
31
32 #include <cstring>
33
34 using namespace CPlusPlus;
35
UsingNamespaceDirective(TranslationUnit * translationUnit,int sourceLocation,const Name * name)36 UsingNamespaceDirective::UsingNamespaceDirective(TranslationUnit *translationUnit,
37 int sourceLocation, const Name *name)
38 : Symbol(translationUnit, sourceLocation, name)
39 { }
40
UsingNamespaceDirective(Clone * clone,Subst * subst,UsingNamespaceDirective * original)41 UsingNamespaceDirective::UsingNamespaceDirective(Clone *clone, Subst *subst, UsingNamespaceDirective *original)
42 : Symbol(clone, subst, original)
43 { }
44
~UsingNamespaceDirective()45 UsingNamespaceDirective::~UsingNamespaceDirective()
46 { }
47
type() const48 FullySpecifiedType UsingNamespaceDirective::type() const
49 { return FullySpecifiedType(); }
50
visitSymbol0(SymbolVisitor * visitor)51 void UsingNamespaceDirective::visitSymbol0(SymbolVisitor *visitor)
52 { visitor->visit(this); }
53
NamespaceAlias(TranslationUnit * translationUnit,int sourceLocation,const Name * name)54 NamespaceAlias::NamespaceAlias(TranslationUnit *translationUnit,
55 int sourceLocation, const Name *name)
56 : Symbol(translationUnit, sourceLocation, name), _namespaceName(nullptr)
57 { }
58
NamespaceAlias(Clone * clone,Subst * subst,NamespaceAlias * original)59 NamespaceAlias::NamespaceAlias(Clone *clone, Subst *subst, NamespaceAlias *original)
60 : Symbol(clone, subst, original)
61 , _namespaceName(clone->name(original->_namespaceName, subst))
62 { }
63
~NamespaceAlias()64 NamespaceAlias::~NamespaceAlias()
65 { }
66
namespaceName() const67 const Name *NamespaceAlias::namespaceName() const
68 { return _namespaceName; }
69
setNamespaceName(const Name * namespaceName)70 void NamespaceAlias::setNamespaceName(const Name *namespaceName)
71 { _namespaceName = namespaceName; }
72
type() const73 FullySpecifiedType NamespaceAlias::type() const
74 { return FullySpecifiedType(); }
75
visitSymbol0(SymbolVisitor * visitor)76 void NamespaceAlias::visitSymbol0(SymbolVisitor *visitor)
77 { visitor->visit(this); }
78
79
UsingDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)80 UsingDeclaration::UsingDeclaration(TranslationUnit *translationUnit,
81 int sourceLocation, const Name *name)
82 : Symbol(translationUnit, sourceLocation, name)
83 { }
84
UsingDeclaration(Clone * clone,Subst * subst,UsingDeclaration * original)85 UsingDeclaration::UsingDeclaration(Clone *clone, Subst *subst, UsingDeclaration *original)
86 : Symbol(clone, subst, original)
87 { }
88
~UsingDeclaration()89 UsingDeclaration::~UsingDeclaration()
90 { }
91
type() const92 FullySpecifiedType UsingDeclaration::type() const
93 { return FullySpecifiedType(); }
94
visitSymbol0(SymbolVisitor * visitor)95 void UsingDeclaration::visitSymbol0(SymbolVisitor *visitor)
96 { visitor->visit(this); }
97
Declaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)98 Declaration::Declaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
99 : Symbol(translationUnit, sourceLocation, name)
100 , _initializer(nullptr)
101 { }
102
Declaration(Clone * clone,Subst * subst,Declaration * original)103 Declaration::Declaration(Clone *clone, Subst *subst, Declaration *original)
104 : Symbol(clone, subst, original)
105 , _type(clone->type(original->_type, subst))
106 , _initializer(clone->stringLiteral(original->_initializer))
107 {
108 const char* nameId = nullptr;
109 const Name *theName = name();
110 if (!theName)
111 return;
112
113 if (const Identifier* identifier = theName->identifier())
114 nameId = identifier->chars();
115 else
116 return;
117
118 Class *enClass = original->enclosingClass();
119 const char* enClassNameId = nullptr;
120 if (enClass && enClass->name() && enClass->name()->identifier()) {
121 enClassNameId = enClass->name()->identifier()->chars();
122 } else {
123 return;
124 }
125
126 if (!enClassNameId)
127 return;
128
129 Template *templSpec = enClass->enclosingTemplate();
130 const char* enNamespaceNameId = nullptr;
131 if (templSpec) {
132 if (Namespace* ns = templSpec->enclosingNamespace()) {
133 if (ns->isInline())
134 ns = ns->enclosingNamespace();
135
136 if (ns->name() && ns->name()->identifier())
137 enNamespaceNameId =ns->name()->identifier()->chars();
138 }
139 }
140
141 if (!enNamespaceNameId || templSpec->templateParameterCount() < 1)
142 return;
143
144 const Name *firstTemplParamName = nullptr;
145 if (const TypenameArgument *templParam =
146 templSpec->templateParameterAt(0)->asTypenameArgument()) {
147 firstTemplParamName = templParam->name();
148 }
149
150 if (!firstTemplParamName)
151 return;
152
153 if (!subst)
154 return;
155
156 FullySpecifiedType newType;
157 if (std::strcmp(enNamespaceNameId, "std") == 0 ||
158 std::strcmp(enNamespaceNameId, "__cxx11") == 0) {
159 if (std::strcmp(enClassNameId, "unique_ptr") == 0) {
160 if (std::strcmp(nameId, "pointer") == 0) {
161 newType = clone->type(subst->apply(firstTemplParamName), nullptr);
162 newType = FullySpecifiedType(clone->control()->pointerType(newType));
163 }
164 } else if (std::strcmp(enClassNameId, "list") == 0 ||
165 std::strcmp(enClassNameId, "forward_list") == 0 ||
166 std::strcmp(enClassNameId, "vector") == 0 ||
167 std::strcmp(enClassNameId, "queue") == 0 ||
168 std::strcmp(enClassNameId, "deque") == 0 ||
169 std::strcmp(enClassNameId, "set") == 0 ||
170 std::strcmp(enClassNameId, "unordered_set") == 0 ||
171 std::strcmp(enClassNameId, "multiset") == 0 ||
172 std::strcmp(enClassNameId, "array") == 0) {
173 if (std::strcmp(nameId, "reference") == 0 ||
174 std::strcmp(nameId, "const_reference") == 0) {
175 newType = clone->type(subst->apply(firstTemplParamName), nullptr);
176 } else if (std::strcmp(nameId, "iterator") == 0 ||
177 std::strcmp(nameId, "reverse_iterator") == 0 ||
178 std::strcmp(nameId, "const_reverse_iterator") == 0 ||
179 std::strcmp(nameId, "const_iterator") == 0) {
180 newType = clone->type(subst->apply(firstTemplParamName), nullptr);
181 newType = FullySpecifiedType(clone->control()->pointerType(newType));
182 }
183 } else if (std::strcmp(enClassNameId, "_Hash") == 0 ||
184 std::strcmp(enClassNameId, "_Tree") == 0 ) {
185 if (std::strcmp(nameId, "iterator") == 0 ||
186 std::strcmp(nameId, "reverse_iterator") == 0 ||
187 std::strcmp(nameId, "const_reverse_iterator") == 0 ||
188 std::strcmp(nameId, "const_iterator") == 0) {
189 FullySpecifiedType clonedType = clone->type(subst->apply(firstTemplParamName), nullptr);
190 if (NamedType *namedType = clonedType.type()->asNamedType()) {
191 if (const TemplateNameId * templateNameId =
192 namedType->name()->asTemplateNameId()) {
193 if (templateNameId->templateArgumentCount()) {
194 newType = clone->type(templateNameId->templateArgumentAt(0).type(), nullptr);
195 newType = FullySpecifiedType(clone->control()->pointerType(newType));
196 }
197 }
198 }
199 }
200 }
201 }
202
203 if (newType.isValid())
204 _type = newType;
205 }
206
~Declaration()207 Declaration::~Declaration()
208 { }
209
setType(const FullySpecifiedType & type)210 void Declaration::setType(const FullySpecifiedType &type)
211 { _type = type; }
212
setInitializer(const StringLiteral * initializer)213 void Declaration::setInitializer(const StringLiteral *initializer)
214 {
215 _initializer = initializer;
216 }
217
type() const218 FullySpecifiedType Declaration::type() const
219 { return _type; }
220
getInitializer() const221 const StringLiteral *Declaration::getInitializer() const
222 {
223 return _initializer;
224 }
225
visitSymbol0(SymbolVisitor * visitor)226 void Declaration::visitSymbol0(SymbolVisitor *visitor)
227 { visitor->visit(this); }
228
EnumeratorDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)229 EnumeratorDeclaration::EnumeratorDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
230 : Declaration(translationUnit, sourceLocation, name)
231 , _constantValue(nullptr)
232 {}
233
~EnumeratorDeclaration()234 EnumeratorDeclaration::~EnumeratorDeclaration()
235 {}
236
constantValue() const237 const StringLiteral *EnumeratorDeclaration::constantValue() const
238 { return _constantValue; }
239
setConstantValue(const StringLiteral * constantValue)240 void EnumeratorDeclaration::setConstantValue(const StringLiteral *constantValue)
241 { _constantValue = constantValue; }
242
Argument(TranslationUnit * translationUnit,int sourceLocation,const Name * name)243 Argument::Argument(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
244 : Symbol(translationUnit, sourceLocation, name),
245 _initializer(nullptr)
246 { }
247
Argument(Clone * clone,Subst * subst,Argument * original)248 Argument::Argument(Clone *clone, Subst *subst, Argument *original)
249 : Symbol(clone, subst, original)
250 , _initializer(clone->stringLiteral(original->_initializer))
251 , _type(clone->type(original->_type, subst))
252 { }
253
~Argument()254 Argument::~Argument()
255 { }
256
hasInitializer() const257 bool Argument::hasInitializer() const
258 { return _initializer != nullptr; }
259
initializer() const260 const StringLiteral *Argument::initializer() const
261 { return _initializer; }
262
setInitializer(const StringLiteral * initializer)263 void Argument::setInitializer(const StringLiteral *initializer)
264 { _initializer = initializer; }
265
setType(const FullySpecifiedType & type)266 void Argument::setType(const FullySpecifiedType &type)
267 { _type = type; }
268
type() const269 FullySpecifiedType Argument::type() const
270 { return _type; }
271
visitSymbol0(SymbolVisitor * visitor)272 void Argument::visitSymbol0(SymbolVisitor *visitor)
273 { visitor->visit(this); }
274
TypenameArgument(TranslationUnit * translationUnit,int sourceLocation,const Name * name)275 TypenameArgument::TypenameArgument(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
276 : Symbol(translationUnit, sourceLocation, name)
277 , _isClassDeclarator(false)
278 { }
279
TypenameArgument(Clone * clone,Subst * subst,TypenameArgument * original)280 TypenameArgument::TypenameArgument(Clone *clone, Subst *subst, TypenameArgument *original)
281 : Symbol(clone, subst, original)
282 , _type(clone->type(original->_type, subst))
283 , _isClassDeclarator(original->_isClassDeclarator)
284 { }
285
~TypenameArgument()286 TypenameArgument::~TypenameArgument()
287 { }
288
setType(const FullySpecifiedType & type)289 void TypenameArgument::setType(const FullySpecifiedType &type)
290 { _type = type; }
291
type() const292 FullySpecifiedType TypenameArgument::type() const
293 { return _type; }
294
visitSymbol0(SymbolVisitor * visitor)295 void TypenameArgument::visitSymbol0(SymbolVisitor *visitor)
296 { visitor->visit(this); }
297
Function(TranslationUnit * translationUnit,int sourceLocation,const Name * name)298 Function::Function(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
299 : Scope(translationUnit, sourceLocation, name),
300 _flags(0)
301 { }
302
Function(Clone * clone,Subst * subst,Function * original)303 Function::Function(Clone *clone, Subst *subst, Function *original)
304 : Scope(clone, subst, original)
305 , _returnType(clone->type(original->_returnType, subst))
306 , _exceptionSpecification(original->_exceptionSpecification)
307 , _flags(original->_flags)
308 { }
309
~Function()310 Function::~Function()
311 { }
312
isNormal() const313 bool Function::isNormal() const
314 { return f._methodKey == NormalMethod; }
315
isSignal() const316 bool Function::isSignal() const
317 { return f._methodKey == SignalMethod; }
318
isSlot() const319 bool Function::isSlot() const
320 { return f._methodKey == SlotMethod; }
321
isInvokable() const322 bool Function::isInvokable() const
323 { return f._methodKey == InvokableMethod; }
324
methodKey() const325 int Function::methodKey() const
326 { return f._methodKey; }
327
setMethodKey(int key)328 void Function::setMethodKey(int key)
329 { f._methodKey = key; }
330
isSignatureEqualTo(const Function * other,Matcher * matcher) const331 bool Function::isSignatureEqualTo(const Function *other, Matcher *matcher) const
332 {
333 if (! other)
334 return false;
335 else if (isConst() != other->isConst())
336 return false;
337 else if (isVolatile() != other->isVolatile())
338 return false;
339 else if (! Matcher::match(unqualifiedName(), other->unqualifiedName(), matcher))
340 return false;
341
342 class FallbackMatcher : public Matcher
343 {
344 public:
345 explicit FallbackMatcher(Matcher *baseMatcher) : m_baseMatcher(baseMatcher) {}
346
347 private:
348 bool match(const NamedType *type, const NamedType *otherType) override
349 {
350 if (type == otherType)
351 return true;
352 const Name *name = type->name();
353 if (const QualifiedNameId *q = name->asQualifiedNameId())
354 name = q->name();
355 const Name *otherName = otherType->name();
356 if (const QualifiedNameId *q = otherName->asQualifiedNameId())
357 otherName = q->name();
358 return Matcher::match(name, otherName, m_baseMatcher);
359 }
360
361 Matcher * const m_baseMatcher;
362 } fallbackMatcher(matcher);
363
364 const int argc = argumentCount();
365 if (argc != other->argumentCount())
366 return false;
367 for (int i = 0; i < argc; ++i) {
368 Symbol *l = argumentAt(i);
369 Symbol *r = other->argumentAt(i);
370 if (! l->type().match(r->type(), matcher)) {
371 if (!l->type()->isReferenceType() && !l->type()->isPointerType()
372 && !l->type()->isPointerToMemberType()
373 && !r->type()->isReferenceType() && !r->type()->isPointerType()
374 && !r->type()->isPointerToMemberType()) {
375 FullySpecifiedType lType = l->type();
376 FullySpecifiedType rType = r->type();
377 lType.setConst(false);
378 lType.setVolatile(false);
379 rType.setConst(false);
380 rType.setVolatile(false);
381 if (lType.match(rType))
382 continue;
383 }
384 if (l->type().match(r->type(), &fallbackMatcher))
385 continue;
386 return false;
387 }
388 }
389 return true;
390 }
391
accept0(TypeVisitor * visitor)392 void Function::accept0(TypeVisitor *visitor)
393 { visitor->visit(this); }
394
match0(const Type * otherType,Matcher * matcher) const395 bool Function::match0(const Type *otherType, Matcher *matcher) const
396 {
397 if (const Function *otherTy = otherType->asFunctionType())
398 return matcher->match(this, otherTy);
399
400 return false;
401 }
402
type() const403 FullySpecifiedType Function::type() const
404 {
405 FullySpecifiedType ty(const_cast<Function *>(this));
406 ty.setConst(isConst());
407 ty.setVolatile(isVolatile());
408 ty.setStatic(isStatic());
409 return ty;
410 }
411
returnType() const412 FullySpecifiedType Function::returnType() const
413 { return _returnType; }
414
setReturnType(const FullySpecifiedType & returnType)415 void Function::setReturnType(const FullySpecifiedType &returnType)
416 { _returnType = returnType; }
417
hasReturnType() const418 bool Function::hasReturnType() const
419 {
420 const FullySpecifiedType ty = returnType();
421 return ty.isValid() || ty.isSigned() || ty.isUnsigned();
422 }
423
argumentCount() const424 int Function::argumentCount() const
425 {
426 const int memCnt = memberCount();
427 if (memCnt > 0 && memberAt(0)->type()->isVoidType())
428 return 0;
429
430 // Definitions with function-try-blocks will have more than a block, and
431 // arguments with a lambda as default argument will also have more blocks.
432 int argc = 0;
433 for (int it = 0; it < memCnt; ++it)
434 if (memberAt(it)->isArgument())
435 ++argc;
436 return argc;
437 }
438
argumentAt(int index) const439 Symbol *Function::argumentAt(int index) const
440 {
441 for (int it = 0, eit = memberCount(); it < eit; ++it) {
442 if (Argument *arg = memberAt(it)->asArgument()) {
443 if (index == 0)
444 return arg;
445 else
446 --index;
447 }
448 }
449
450 return nullptr;
451 }
452
hasArguments() const453 bool Function::hasArguments() const
454 {
455 int argc = argumentCount();
456 return ! (argc == 0 || (argc == 1 && argumentAt(0)->type()->isVoidType()));
457 }
458
minimumArgumentCount() const459 int Function::minimumArgumentCount() const
460 {
461 int index = 0;
462
463 for (int ei = argumentCount(); index < ei; ++index) {
464 if (Argument *arg = argumentAt(index)->asArgument()) {
465 if (arg->hasInitializer())
466 break;
467 }
468 }
469
470 return index;
471 }
472
isVirtual() const473 bool Function::isVirtual() const
474 { return f._isVirtual; }
475
setVirtual(bool isVirtual)476 void Function::setVirtual(bool isVirtual)
477 { f._isVirtual = isVirtual; }
478
isOverride() const479 bool Function::isOverride() const
480 { return f._isOverride; }
481
setOverride(bool isOverride)482 void Function::setOverride(bool isOverride)
483 { f._isOverride = isOverride; }
484
isFinal() const485 bool Function::isFinal() const
486 { return f._isFinal; }
487
setFinal(bool isFinal)488 void Function::setFinal(bool isFinal)
489 { f._isFinal = isFinal; }
490
isVariadic() const491 bool Function::isVariadic() const
492 { return f._isVariadic; }
493
setVariadic(bool isVariadic)494 void Function::setVariadic(bool isVariadic)
495 { f._isVariadic = isVariadic; }
496
isVariadicTemplate() const497 bool Function::isVariadicTemplate() const
498 { return f._isVariadicTemplate; }
499
setVariadicTemplate(bool isVariadicTemplate)500 void Function::setVariadicTemplate(bool isVariadicTemplate)
501 { f._isVariadicTemplate = isVariadicTemplate; }
502
isConst() const503 bool Function::isConst() const
504 { return f._isConst; }
505
setConst(bool isConst)506 void Function::setConst(bool isConst)
507 { f._isConst = isConst; }
508
isVolatile() const509 bool Function::isVolatile() const
510 { return f._isVolatile; }
511
setVolatile(bool isVolatile)512 void Function::setVolatile(bool isVolatile)
513 { f._isVolatile = isVolatile; }
514
isPureVirtual() const515 bool Function::isPureVirtual() const
516 { return f._isPureVirtual; }
517
setPureVirtual(bool isPureVirtual)518 void Function::setPureVirtual(bool isPureVirtual)
519 { f._isPureVirtual = isPureVirtual; }
520
refQualifier() const521 Function::RefQualifier Function::refQualifier() const
522 { return static_cast<RefQualifier>(f._refQualifier); }
523
setRefQualifier(Function::RefQualifier refQualifier)524 void Function::setRefQualifier(Function::RefQualifier refQualifier)
525 { f._refQualifier = refQualifier; }
526
isAmbiguous() const527 bool Function::isAmbiguous() const
528 { return f._isAmbiguous; }
529
setAmbiguous(bool isAmbiguous)530 void Function::setAmbiguous(bool isAmbiguous)
531 { f._isAmbiguous = isAmbiguous; }
532
visitSymbol0(SymbolVisitor * visitor)533 void Function::visitSymbol0(SymbolVisitor *visitor)
534 {
535 if (visitor->visit(this)) {
536 for (int i = 0; i < memberCount(); ++i) {
537 visitSymbol(memberAt(i), visitor);
538 }
539 }
540 }
541
maybeValidPrototype(int actualArgumentCount) const542 bool Function::maybeValidPrototype(int actualArgumentCount) const
543 {
544 const int argc = argumentCount();
545 int minNumberArguments = 0;
546
547 for (; minNumberArguments < argc; ++minNumberArguments) {
548 Argument *arg = argumentAt(minNumberArguments)->asArgument();
549
550 if (! arg)
551 return false;
552
553 if (arg->hasInitializer())
554 break;
555 }
556
557 if (isVariadicTemplate())
558 --minNumberArguments;
559
560 if (actualArgumentCount < minNumberArguments) {
561 // not enough arguments.
562 return false;
563
564 } else if (!isVariadic() && actualArgumentCount > argc) {
565 // too many arguments.
566 return false;
567 }
568
569 return true;
570 }
571
exceptionSpecification()572 const StringLiteral *Function::exceptionSpecification()
573 { return _exceptionSpecification; }
574
setExceptionSpecification(const StringLiteral * spec)575 void Function::setExceptionSpecification(const StringLiteral *spec)
576 { _exceptionSpecification = spec; }
577
Block(TranslationUnit * translationUnit,int sourceLocation)578 Block::Block(TranslationUnit *translationUnit, int sourceLocation)
579 : Scope(translationUnit, sourceLocation, /*name = */ nullptr)
580 { }
581
Block(Clone * clone,Subst * subst,Block * original)582 Block::Block(Clone *clone, Subst *subst, Block *original)
583 : Scope(clone, subst, original)
584 { }
585
~Block()586 Block::~Block()
587 { }
588
type() const589 FullySpecifiedType Block::type() const
590 { return FullySpecifiedType(); }
591
visitSymbol0(SymbolVisitor * visitor)592 void Block::visitSymbol0(SymbolVisitor *visitor)
593 {
594 if (visitor->visit(this)) {
595 for (int i = 0; i < memberCount(); ++i) {
596 visitSymbol(memberAt(i), visitor);
597 }
598 }
599 }
600
Enum(TranslationUnit * translationUnit,int sourceLocation,const Name * name)601 Enum::Enum(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
602 : Scope(translationUnit, sourceLocation, name)
603 , _isScoped(false)
604 { }
605
Enum(Clone * clone,Subst * subst,Enum * original)606 Enum::Enum(Clone *clone, Subst *subst, Enum *original)
607 : Scope(clone, subst, original)
608 , _isScoped(original->isScoped())
609 { }
610
~Enum()611 Enum::~Enum()
612 { }
613
type() const614 FullySpecifiedType Enum::type() const
615 { return FullySpecifiedType(const_cast<Enum *>(this)); }
616
isScoped() const617 bool Enum::isScoped() const
618 {
619 return _isScoped;
620 }
621
setScoped(bool scoped)622 void Enum::setScoped(bool scoped)
623 {
624 _isScoped = scoped;
625 }
626
accept0(TypeVisitor * visitor)627 void Enum::accept0(TypeVisitor *visitor)
628 { visitor->visit(this); }
629
match0(const Type * otherType,Matcher * matcher) const630 bool Enum::match0(const Type *otherType, Matcher *matcher) const
631 {
632 if (const Enum *otherTy = otherType->asEnumType())
633 return matcher->match(this, otherTy);
634
635 return false;
636 }
637
visitSymbol0(SymbolVisitor * visitor)638 void Enum::visitSymbol0(SymbolVisitor *visitor)
639 {
640 if (visitor->visit(this)) {
641 for (int i = 0; i < memberCount(); ++i) {
642 visitSymbol(memberAt(i), visitor);
643 }
644 }
645 }
646
Template(TranslationUnit * translationUnit,int sourceLocation,const Name * name)647 Template::Template(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
648 : Scope(translationUnit, sourceLocation, name)
649 { }
650
Template(Clone * clone,Subst * subst,Template * original)651 Template::Template(Clone *clone, Subst *subst, Template *original)
652 : Scope(clone, subst, original)
653 { }
654
~Template()655 Template::~Template()
656 { }
657
templateParameterCount() const658 int Template::templateParameterCount() const
659 {
660 if (declaration() != nullptr)
661 return memberCount() - 1;
662
663 return 0;
664 }
665
templateParameterAt(int index) const666 Symbol *Template::templateParameterAt(int index) const
667 { return memberAt(index); }
668
declaration() const669 Symbol *Template::declaration() const
670 {
671 if (isEmpty())
672 return nullptr;
673
674 if (Symbol *s = memberAt(memberCount() - 1)) {
675 if (s->isClass() || s->isForwardClassDeclaration() ||
676 s->isTemplate() || s->isFunction() || s->isDeclaration())
677 return s;
678 }
679
680 return nullptr;
681 }
682
type() const683 FullySpecifiedType Template::type() const
684 { return FullySpecifiedType(const_cast<Template *>(this)); }
685
visitSymbol0(SymbolVisitor * visitor)686 void Template::visitSymbol0(SymbolVisitor *visitor)
687 {
688 if (visitor->visit(this)) {
689 for (int i = 0; i < memberCount(); ++i) {
690 visitSymbol(memberAt(i), visitor);
691 }
692 }
693 }
694
accept0(TypeVisitor * visitor)695 void Template::accept0(TypeVisitor *visitor)
696 { visitor->visit(this); }
697
match0(const Type * otherType,Matcher * matcher) const698 bool Template::match0(const Type *otherType, Matcher *matcher) const
699 {
700 if (const Template *otherTy = otherType->asTemplateType())
701 return matcher->match(this, otherTy);
702 return false;
703 }
704
Namespace(TranslationUnit * translationUnit,int sourceLocation,const Name * name)705 Namespace::Namespace(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
706 : Scope(translationUnit, sourceLocation, name)
707 , _isInline(false)
708 { }
709
Namespace(Clone * clone,Subst * subst,Namespace * original)710 Namespace::Namespace(Clone *clone, Subst *subst, Namespace *original)
711 : Scope(clone, subst, original)
712 , _isInline(original->_isInline)
713 { }
714
~Namespace()715 Namespace::~Namespace()
716 { }
717
accept0(TypeVisitor * visitor)718 void Namespace::accept0(TypeVisitor *visitor)
719 { visitor->visit(this); }
720
match0(const Type * otherType,Matcher * matcher) const721 bool Namespace::match0(const Type *otherType, Matcher *matcher) const
722 {
723 if (const Namespace *otherTy = otherType->asNamespaceType())
724 return matcher->match(this, otherTy);
725
726 return false;
727 }
728
visitSymbol0(SymbolVisitor * visitor)729 void Namespace::visitSymbol0(SymbolVisitor *visitor)
730 {
731 if (visitor->visit(this)) {
732 for (int i = 0; i < memberCount(); ++i) {
733 visitSymbol(memberAt(i), visitor);
734 }
735 }
736 }
737
type() const738 FullySpecifiedType Namespace::type() const
739 { return FullySpecifiedType(const_cast<Namespace *>(this)); }
740
BaseClass(TranslationUnit * translationUnit,int sourceLocation,const Name * name)741 BaseClass::BaseClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
742 : Symbol(translationUnit, sourceLocation, name),
743 _isVirtual(false)
744 { }
745
BaseClass(Clone * clone,Subst * subst,BaseClass * original)746 BaseClass::BaseClass(Clone *clone, Subst *subst, BaseClass *original)
747 : Symbol(clone, subst, original)
748 , _isVirtual(original->_isVirtual)
749 , _type(clone->type(original->_type, subst))
750 { }
751
~BaseClass()752 BaseClass::~BaseClass()
753 { }
754
type() const755 FullySpecifiedType BaseClass::type() const
756 { return _type; }
757
setType(const FullySpecifiedType & type)758 void BaseClass::setType(const FullySpecifiedType &type)
759 { _type = type; }
760
isVirtual() const761 bool BaseClass::isVirtual() const
762 { return _isVirtual; }
763
setVirtual(bool isVirtual)764 void BaseClass::setVirtual(bool isVirtual)
765 { _isVirtual = isVirtual; }
766
isVariadic() const767 bool BaseClass::isVariadic() const
768 { return _isVariadic; }
769
setVariadic(bool isVariadic)770 void BaseClass::setVariadic(bool isVariadic)
771 { _isVariadic = isVariadic; }
772
visitSymbol0(SymbolVisitor * visitor)773 void BaseClass::visitSymbol0(SymbolVisitor *visitor)
774 { visitor->visit(this); }
775
ForwardClassDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)776 ForwardClassDeclaration::ForwardClassDeclaration(TranslationUnit *translationUnit,
777 int sourceLocation, const Name *name)
778 : Symbol(translationUnit, sourceLocation, name)
779 { }
780
ForwardClassDeclaration(Clone * clone,Subst * subst,ForwardClassDeclaration * original)781 ForwardClassDeclaration::ForwardClassDeclaration(Clone *clone, Subst *subst, ForwardClassDeclaration *original)
782 : Symbol(clone, subst, original)
783 { }
784
~ForwardClassDeclaration()785 ForwardClassDeclaration::~ForwardClassDeclaration()
786 { }
787
type() const788 FullySpecifiedType ForwardClassDeclaration::type() const
789 { return FullySpecifiedType(const_cast<ForwardClassDeclaration *>(this)); }
790
visitSymbol0(SymbolVisitor * visitor)791 void ForwardClassDeclaration::visitSymbol0(SymbolVisitor *visitor)
792 { visitor->visit(this); }
793
accept0(TypeVisitor * visitor)794 void ForwardClassDeclaration::accept0(TypeVisitor *visitor)
795 { visitor->visit(this); }
796
match0(const Type * otherType,Matcher * matcher) const797 bool ForwardClassDeclaration::match0(const Type *otherType, Matcher *matcher) const
798 {
799 if (const ForwardClassDeclaration *otherTy = otherType->asForwardClassDeclarationType())
800 return matcher->match(this, otherTy);
801
802 return false;
803 }
804
Class(TranslationUnit * translationUnit,int sourceLocation,const Name * name)805 Class::Class(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
806 : Scope(translationUnit, sourceLocation, name),
807 _key(ClassKey)
808 { }
809
Class(Clone * clone,Subst * subst,Class * original)810 Class::Class(Clone *clone, Subst *subst, Class *original)
811 : Scope(clone, subst, original)
812 , _key(original->_key)
813 {
814 for (size_t i = 0; i < original->_baseClasses.size(); ++i)
815 addBaseClass(clone->symbol(original->_baseClasses.at(i), subst)->asBaseClass());
816 }
817
~Class()818 Class::~Class()
819 { }
820
isClass() const821 bool Class::isClass() const
822 { return _key == ClassKey; }
823
isStruct() const824 bool Class::isStruct() const
825 { return _key == StructKey; }
826
isUnion() const827 bool Class::isUnion() const
828 { return _key == UnionKey; }
829
classKey() const830 Class::Key Class::classKey() const
831 { return _key; }
832
setClassKey(Key key)833 void Class::setClassKey(Key key)
834 { _key = key; }
835
accept0(TypeVisitor * visitor)836 void Class::accept0(TypeVisitor *visitor)
837 { visitor->visit(this); }
838
match0(const Type * otherType,Matcher * matcher) const839 bool Class::match0(const Type *otherType, Matcher *matcher) const
840 {
841 if (const Class *otherTy = otherType->asClassType())
842 return matcher->match(this, otherTy);
843
844 return false;
845 }
846
baseClassCount() const847 int Class::baseClassCount() const
848 { return int(_baseClasses.size()); }
849
baseClassAt(int index) const850 BaseClass *Class::baseClassAt(int index) const
851 { return _baseClasses.at(index); }
852
addBaseClass(BaseClass * baseClass)853 void Class::addBaseClass(BaseClass *baseClass)
854 { _baseClasses.push_back(baseClass); }
855
type() const856 FullySpecifiedType Class::type() const
857 { return FullySpecifiedType(const_cast<Class *>(this)); }
858
visitSymbol0(SymbolVisitor * visitor)859 void Class::visitSymbol0(SymbolVisitor *visitor)
860 {
861 if (visitor->visit(this)) {
862 for (int i = 0; i < int(_baseClasses.size()); ++i) {
863 visitSymbol(_baseClasses.at(i), visitor);
864 }
865 for (int i = 0; i < memberCount(); ++i) {
866 visitSymbol(memberAt(i), visitor);
867 }
868 }
869 }
870
871
QtPropertyDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)872 QtPropertyDeclaration::QtPropertyDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
873 : Symbol(translationUnit, sourceLocation, name)
874 , _flags(NoFlags)
875 { }
876
QtPropertyDeclaration(Clone * clone,Subst * subst,QtPropertyDeclaration * original)877 QtPropertyDeclaration::QtPropertyDeclaration(Clone *clone, Subst *subst, QtPropertyDeclaration *original)
878 : Symbol(clone, subst, original)
879 , _type(clone->type(original->_type, subst))
880 , _flags(original->_flags)
881 { }
882
~QtPropertyDeclaration()883 QtPropertyDeclaration::~QtPropertyDeclaration()
884 { }
885
setType(const FullySpecifiedType & type)886 void QtPropertyDeclaration::setType(const FullySpecifiedType &type)
887 { _type = type; }
888
setFlags(int flags)889 void QtPropertyDeclaration::setFlags(int flags)
890 { _flags = flags; }
891
flags() const892 int QtPropertyDeclaration::flags() const
893 { return _flags; }
894
type() const895 FullySpecifiedType QtPropertyDeclaration::type() const
896 { return _type; }
897
visitSymbol0(SymbolVisitor * visitor)898 void QtPropertyDeclaration::visitSymbol0(SymbolVisitor *visitor)
899 { visitor->visit(this); }
900
901
QtEnum(TranslationUnit * translationUnit,int sourceLocation,const Name * name)902 QtEnum::QtEnum(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
903 : Symbol(translationUnit, sourceLocation, name)
904 { }
905
QtEnum(Clone * clone,Subst * subst,QtEnum * original)906 QtEnum::QtEnum(Clone *clone, Subst *subst, QtEnum *original)
907 : Symbol(clone, subst, original)
908 { }
909
~QtEnum()910 QtEnum::~QtEnum()
911 { }
912
type() const913 FullySpecifiedType QtEnum::type() const
914 { return FullySpecifiedType(); }
915
visitSymbol0(SymbolVisitor * visitor)916 void QtEnum::visitSymbol0(SymbolVisitor *visitor)
917 { visitor->visit(this); }
918
919
ObjCBaseClass(TranslationUnit * translationUnit,int sourceLocation,const Name * name)920 ObjCBaseClass::ObjCBaseClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
921 : Symbol(translationUnit, sourceLocation, name)
922 { }
923
ObjCBaseClass(Clone * clone,Subst * subst,ObjCBaseClass * original)924 ObjCBaseClass::ObjCBaseClass(Clone *clone, Subst *subst, ObjCBaseClass *original)
925 : Symbol(clone, subst, original)
926 { }
927
~ObjCBaseClass()928 ObjCBaseClass::~ObjCBaseClass()
929 { }
930
type() const931 FullySpecifiedType ObjCBaseClass::type() const
932 { return FullySpecifiedType(); }
933
visitSymbol0(SymbolVisitor * visitor)934 void ObjCBaseClass::visitSymbol0(SymbolVisitor *visitor)
935 { visitor->visit(this); }
936
ObjCBaseProtocol(TranslationUnit * translationUnit,int sourceLocation,const Name * name)937 ObjCBaseProtocol::ObjCBaseProtocol(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
938 : Symbol(translationUnit, sourceLocation, name)
939 { }
940
ObjCBaseProtocol(Clone * clone,Subst * subst,ObjCBaseProtocol * original)941 ObjCBaseProtocol::ObjCBaseProtocol(Clone *clone, Subst *subst, ObjCBaseProtocol *original)
942 : Symbol(clone, subst, original)
943 { }
944
~ObjCBaseProtocol()945 ObjCBaseProtocol::~ObjCBaseProtocol()
946 { }
947
type() const948 FullySpecifiedType ObjCBaseProtocol::type() const
949 { return FullySpecifiedType(); }
950
visitSymbol0(SymbolVisitor * visitor)951 void ObjCBaseProtocol::visitSymbol0(SymbolVisitor *visitor)
952 { visitor->visit(this); }
953
ObjCClass(TranslationUnit * translationUnit,int sourceLocation,const Name * name)954 ObjCClass::ObjCClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name):
955 Scope(translationUnit, sourceLocation, name),
956 _categoryName(nullptr),
957 _baseClass(nullptr),
958 _isInterface(false)
959 { }
960
ObjCClass(Clone * clone,Subst * subst,ObjCClass * original)961 ObjCClass::ObjCClass(Clone *clone, Subst *subst, ObjCClass *original)
962 : Scope(clone, subst, original)
963 , _categoryName(clone->name(original->_categoryName, subst))
964 , _baseClass(nullptr)
965 , _isInterface(original->_isInterface)
966 {
967 if (original->_baseClass)
968 _baseClass = clone->symbol(original->_baseClass, subst)->asObjCBaseClass();
969 for (size_t i = 0; i < original->_protocols.size(); ++i)
970 addProtocol(clone->symbol(original->_protocols.at(i), subst)->asObjCBaseProtocol());
971 }
972
~ObjCClass()973 ObjCClass::~ObjCClass()
974 {}
975
isInterface() const976 bool ObjCClass::isInterface() const
977 { return _isInterface; }
978
setInterface(bool isInterface)979 void ObjCClass::setInterface(bool isInterface)
980 { _isInterface = isInterface; }
981
isCategory() const982 bool ObjCClass::isCategory() const
983 { return _categoryName != nullptr; }
984
categoryName() const985 const Name *ObjCClass::categoryName() const
986 { return _categoryName; }
987
setCategoryName(const Name * categoryName)988 void ObjCClass::setCategoryName(const Name *categoryName)
989 { _categoryName = categoryName; }
990
baseClass() const991 ObjCBaseClass *ObjCClass::baseClass() const
992 { return _baseClass; }
993
setBaseClass(ObjCBaseClass * baseClass)994 void ObjCClass::setBaseClass(ObjCBaseClass *baseClass)
995 { _baseClass = baseClass; }
996
protocolCount() const997 int ObjCClass::protocolCount() const
998 { return int(_protocols.size()); }
999
protocolAt(int index) const1000 ObjCBaseProtocol *ObjCClass::protocolAt(int index) const
1001 { return _protocols.at(index); }
1002
addProtocol(ObjCBaseProtocol * protocol)1003 void ObjCClass::addProtocol(ObjCBaseProtocol *protocol)
1004 { _protocols.push_back(protocol); }
1005
type() const1006 FullySpecifiedType ObjCClass::type() const
1007 { return FullySpecifiedType(const_cast<ObjCClass *>(this)); }
1008
visitSymbol0(SymbolVisitor * visitor)1009 void ObjCClass::visitSymbol0(SymbolVisitor *visitor)
1010 {
1011 if (visitor->visit(this)) {
1012 if (_baseClass)
1013 visitSymbol(_baseClass, visitor);
1014
1015 for (int i = 0; i < int(_protocols.size()); ++i)
1016 visitSymbol(_protocols.at(i), visitor);
1017
1018 for (int i = 0; i < memberCount(); ++i)
1019 visitSymbol(memberAt(i), visitor);
1020 }
1021 }
1022
accept0(TypeVisitor * visitor)1023 void ObjCClass::accept0(TypeVisitor *visitor)
1024 { visitor->visit(this); }
1025
match0(const Type * otherType,Matcher * matcher) const1026 bool ObjCClass::match0(const Type *otherType, Matcher *matcher) const
1027 {
1028 if (const ObjCClass *otherTy = otherType->asObjCClassType())
1029 return matcher->match(this, otherTy);
1030
1031 return false;
1032 }
1033
ObjCProtocol(TranslationUnit * translationUnit,int sourceLocation,const Name * name)1034 ObjCProtocol::ObjCProtocol(TranslationUnit *translationUnit, int sourceLocation, const Name *name):
1035 Scope(translationUnit, sourceLocation, name)
1036 {
1037 }
1038
ObjCProtocol(Clone * clone,Subst * subst,ObjCProtocol * original)1039 ObjCProtocol::ObjCProtocol(Clone *clone, Subst *subst, ObjCProtocol *original)
1040 : Scope(clone, subst, original)
1041 {
1042 for (size_t i = 0; i < original->_protocols.size(); ++i)
1043 addProtocol(clone->symbol(original->_protocols.at(i), subst)->asObjCBaseProtocol());
1044 }
1045
~ObjCProtocol()1046 ObjCProtocol::~ObjCProtocol()
1047 {}
1048
protocolCount() const1049 int ObjCProtocol::protocolCount() const
1050 { return int(_protocols.size()); }
1051
protocolAt(int index) const1052 ObjCBaseProtocol *ObjCProtocol::protocolAt(int index) const
1053 { return _protocols.at(index); }
1054
addProtocol(ObjCBaseProtocol * protocol)1055 void ObjCProtocol::addProtocol(ObjCBaseProtocol *protocol)
1056 { _protocols.push_back(protocol); }
1057
type() const1058 FullySpecifiedType ObjCProtocol::type() const
1059 { return FullySpecifiedType(const_cast<ObjCProtocol *>(this)); }
1060
visitSymbol0(SymbolVisitor * visitor)1061 void ObjCProtocol::visitSymbol0(SymbolVisitor *visitor)
1062 {
1063 if (visitor->visit(this)) {
1064 for (int i = 0; i < int(_protocols.size()); ++i)
1065 visitSymbol(_protocols.at(i), visitor);
1066 }
1067 }
1068
accept0(TypeVisitor * visitor)1069 void ObjCProtocol::accept0(TypeVisitor *visitor)
1070 { visitor->visit(this); }
1071
match0(const Type * otherType,Matcher * matcher) const1072 bool ObjCProtocol::match0(const Type *otherType, Matcher *matcher) const
1073 {
1074 if (const ObjCProtocol *otherTy = otherType->asObjCProtocolType())
1075 return matcher->match(this, otherTy);
1076
1077 return false;
1078 }
1079
ObjCForwardClassDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)1080 ObjCForwardClassDeclaration::ObjCForwardClassDeclaration(TranslationUnit *translationUnit, int sourceLocation,
1081 const Name *name):
1082 Symbol(translationUnit, sourceLocation, name)
1083 {
1084 }
1085
ObjCForwardClassDeclaration(Clone * clone,Subst * subst,ObjCForwardClassDeclaration * original)1086 ObjCForwardClassDeclaration::ObjCForwardClassDeclaration(Clone *clone, Subst *subst, ObjCForwardClassDeclaration *original)
1087 : Symbol(clone, subst, original)
1088 { }
1089
~ObjCForwardClassDeclaration()1090 ObjCForwardClassDeclaration::~ObjCForwardClassDeclaration()
1091 {}
1092
type() const1093 FullySpecifiedType ObjCForwardClassDeclaration::type() const
1094 { return FullySpecifiedType(); }
1095
visitSymbol0(SymbolVisitor * visitor)1096 void ObjCForwardClassDeclaration::visitSymbol0(SymbolVisitor *visitor)
1097 { visitor->visit(this); }
1098
accept0(TypeVisitor * visitor)1099 void ObjCForwardClassDeclaration::accept0(TypeVisitor *visitor)
1100 { visitor->visit(this); }
1101
match0(const Type * otherType,Matcher * matcher) const1102 bool ObjCForwardClassDeclaration::match0(const Type *otherType, Matcher *matcher) const
1103 {
1104 if (const ObjCForwardClassDeclaration *otherTy = otherType->asObjCForwardClassDeclarationType())
1105 return matcher->match(this, otherTy);
1106
1107 return false;
1108 }
1109
ObjCForwardProtocolDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)1110 ObjCForwardProtocolDeclaration::ObjCForwardProtocolDeclaration(TranslationUnit *translationUnit, int sourceLocation,
1111 const Name *name):
1112 Symbol(translationUnit, sourceLocation, name)
1113 {
1114 }
1115
ObjCForwardProtocolDeclaration(Clone * clone,Subst * subst,ObjCForwardProtocolDeclaration * original)1116 ObjCForwardProtocolDeclaration::ObjCForwardProtocolDeclaration(Clone *clone, Subst *subst, ObjCForwardProtocolDeclaration *original)
1117 : Symbol(clone, subst, original)
1118 { }
1119
~ObjCForwardProtocolDeclaration()1120 ObjCForwardProtocolDeclaration::~ObjCForwardProtocolDeclaration()
1121 {}
1122
type() const1123 FullySpecifiedType ObjCForwardProtocolDeclaration::type() const
1124 { return FullySpecifiedType(); }
1125
visitSymbol0(SymbolVisitor * visitor)1126 void ObjCForwardProtocolDeclaration::visitSymbol0(SymbolVisitor *visitor)
1127 { visitor->visit(this); }
1128
accept0(TypeVisitor * visitor)1129 void ObjCForwardProtocolDeclaration::accept0(TypeVisitor *visitor)
1130 { visitor->visit(this); }
1131
match0(const Type * otherType,Matcher * matcher) const1132 bool ObjCForwardProtocolDeclaration::match0(const Type *otherType, Matcher *matcher) const
1133 {
1134 if (const ObjCForwardProtocolDeclaration *otherTy = otherType->asObjCForwardProtocolDeclarationType())
1135 return matcher->match(this, otherTy);
1136
1137 return false;
1138 }
1139
ObjCMethod(TranslationUnit * translationUnit,int sourceLocation,const Name * name)1140 ObjCMethod::ObjCMethod(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
1141 : Scope(translationUnit, sourceLocation, name),
1142 _flags(0)
1143 { }
1144
ObjCMethod(Clone * clone,Subst * subst,ObjCMethod * original)1145 ObjCMethod::ObjCMethod(Clone *clone, Subst *subst, ObjCMethod *original)
1146 : Scope(clone, subst, original)
1147 , _returnType(clone->type(original->_returnType, subst))
1148 , _flags(original->_flags)
1149 { }
1150
~ObjCMethod()1151 ObjCMethod::~ObjCMethod()
1152 { }
1153
accept0(TypeVisitor * visitor)1154 void ObjCMethod::accept0(TypeVisitor *visitor)
1155 { visitor->visit(this); }
1156
match0(const Type * otherType,Matcher * matcher) const1157 bool ObjCMethod::match0(const Type *otherType, Matcher *matcher) const
1158 {
1159 if (const ObjCMethod *otherTy = otherType->asObjCMethodType())
1160 return matcher->match(this, otherTy);
1161
1162 return false;
1163 }
1164
type() const1165 FullySpecifiedType ObjCMethod::type() const
1166 { return FullySpecifiedType(const_cast<ObjCMethod *>(this)); }
1167
returnType() const1168 FullySpecifiedType ObjCMethod::returnType() const
1169 { return _returnType; }
1170
setReturnType(const FullySpecifiedType & returnType)1171 void ObjCMethod::setReturnType(const FullySpecifiedType &returnType)
1172 { _returnType = returnType; }
1173
hasReturnType() const1174 bool ObjCMethod::hasReturnType() const
1175 {
1176 const FullySpecifiedType ty = returnType();
1177 return ty.isValid() || ty.isSigned() || ty.isUnsigned();
1178 }
1179
argumentCount() const1180 int ObjCMethod::argumentCount() const
1181 {
1182 const int c = memberCount();
1183 if (c > 0 && memberAt(c - 1)->isBlock())
1184 return c - 1;
1185 return c;
1186 }
1187
argumentAt(int index) const1188 Symbol *ObjCMethod::argumentAt(int index) const
1189 {
1190 return memberAt(index);
1191 }
1192
hasArguments() const1193 bool ObjCMethod::hasArguments() const
1194 {
1195 return ! (argumentCount() == 0 ||
1196 (argumentCount() == 1 && argumentAt(0)->type()->isVoidType()));
1197 }
1198
isVariadic() const1199 bool ObjCMethod::isVariadic() const
1200 { return f._isVariadic; }
1201
setVariadic(bool isVariadic)1202 void ObjCMethod::setVariadic(bool isVariadic)
1203 { f._isVariadic = isVariadic; }
1204
visitSymbol0(SymbolVisitor * visitor)1205 void ObjCMethod::visitSymbol0(SymbolVisitor *visitor)
1206 {
1207 if (visitor->visit(this)) {
1208 for (int i = 0; i < memberCount(); ++i) {
1209 visitSymbol(memberAt(i), visitor);
1210 }
1211 }
1212 }
1213
ObjCPropertyDeclaration(TranslationUnit * translationUnit,int sourceLocation,const Name * name)1214 ObjCPropertyDeclaration::ObjCPropertyDeclaration(TranslationUnit *translationUnit,
1215 int sourceLocation,
1216 const Name *name):
1217 Symbol(translationUnit, sourceLocation, name),
1218 _getterName(nullptr),
1219 _setterName(nullptr),
1220 _propertyAttributes(None)
1221 {}
1222
ObjCPropertyDeclaration(Clone * clone,Subst * subst,ObjCPropertyDeclaration * original)1223 ObjCPropertyDeclaration::ObjCPropertyDeclaration(Clone *clone, Subst *subst, ObjCPropertyDeclaration *original)
1224 : Symbol(clone, subst, original)
1225 , _getterName(clone->name(original->_getterName, subst))
1226 , _setterName(clone->name(original->_setterName, subst))
1227 , _type(clone->type(original->_type, subst))
1228 , _propertyAttributes(original->_propertyAttributes)
1229 { }
1230
~ObjCPropertyDeclaration()1231 ObjCPropertyDeclaration::~ObjCPropertyDeclaration()
1232 {}
1233
hasAttribute(int attribute) const1234 bool ObjCPropertyDeclaration::hasAttribute(int attribute) const
1235 { return _propertyAttributes & attribute; }
1236
setAttributes(int attributes)1237 void ObjCPropertyDeclaration::setAttributes(int attributes)
1238 { _propertyAttributes = attributes; }
1239
hasGetter() const1240 bool ObjCPropertyDeclaration::hasGetter() const
1241 { return hasAttribute(Getter); }
1242
hasSetter() const1243 bool ObjCPropertyDeclaration::hasSetter() const
1244 { return hasAttribute(Setter); }
1245
getterName() const1246 const Name *ObjCPropertyDeclaration::getterName() const
1247 { return _getterName; }
1248
setGetterName(const Name * getterName)1249 void ObjCPropertyDeclaration::setGetterName(const Name *getterName)
1250 { _getterName = getterName; }
1251
setterName() const1252 const Name *ObjCPropertyDeclaration::setterName() const
1253 { return _setterName; }
1254
setSetterName(const Name * setterName)1255 void ObjCPropertyDeclaration::setSetterName(const Name *setterName)
1256 { _setterName = setterName; }
1257
setType(const FullySpecifiedType & type)1258 void ObjCPropertyDeclaration::setType(const FullySpecifiedType &type)
1259 { _type = type; }
1260
type() const1261 FullySpecifiedType ObjCPropertyDeclaration::type() const
1262 { return _type; }
1263
visitSymbol0(SymbolVisitor * visitor)1264 void ObjCPropertyDeclaration::visitSymbol0(SymbolVisitor *visitor)
1265 {
1266 if (visitor->visit(this)) {
1267 }
1268 }
1269