/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/Comment.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/Comment.cpp
Warning:	line 384, column 14 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Comment.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/Comment.cpp

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/Comment.cpp

→

1//===--- Comment.cpp - Comment AST node implementation --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "clang/AST/Comment.h"
10#include "clang/AST/ASTContext.h"
11#include "clang/AST/Decl.h"
12#include "clang/AST/DeclObjC.h"
13#include "clang/AST/DeclTemplate.h"
14#include "clang/Basic/CharInfo.h"
15#include "llvm/Support/ErrorHandling.h"
16#include <type_traits>

18namespace clang {
19namespace comments {

21// Check that no comment class has a non-trival destructor. They are allocated
22// with a BumpPtrAllocator and therefore their destructor is not executed.
23#define ABSTRACT_COMMENT(COMMENT)
24#define COMMENT(CLASS, PARENT)                                                 \
static_assert(std::is_trivially_destructible<CLASS>::value,                  \
              #CLASS " should be trivially destructible!");
27#include "clang/AST/CommentNodes.inc"
28#undef COMMENT
29#undef ABSTRACT_COMMENT

31// DeclInfo is also allocated with a BumpPtrAllocator.
32static_assert(std::is_trivially_destructible<DeclInfo>::value,
            "DeclInfo should be trivially destructible!");

35const char *Comment::getCommentKindName() const {
switch (getCommentKind()) {
case NoCommentKind: return "NoCommentKind";
38#define ABSTRACT_COMMENT(COMMENT)
39#define COMMENT(CLASS, PARENT) \
case CLASS##Kind: \
  return #CLASS;
42#include "clang/AST/CommentNodes.inc"
43#undef COMMENT
44#undef ABSTRACT_COMMENT
}
llvm_unreachable("Unknown comment kind!")__builtin_unreachable();
47}

49namespace {
50struct good {};
51struct bad {};

53template <typename T>
54good implements_child_begin_end(Comment::child_iterator (T::*)() const) {
return good();
56}

58LLVM_ATTRIBUTE_UNUSED__attribute__((__unused__))
59static inline bad implements_child_begin_end(
                    Comment::child_iterator (Comment::*)() const) {
return bad();
62}

64#define ASSERT_IMPLEMENTS_child_begin(function) \
(void) good(implements_child_begin_end(function))

67LLVM_ATTRIBUTE_UNUSED__attribute__((__unused__))
68static inline void CheckCommentASTNodes() {
69#define ABSTRACT_COMMENT(COMMENT)
70#define COMMENT(CLASS, PARENT) \
ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin); \
ASSERT_IMPLEMENTS_child_begin(&CLASS::child_end);
73#include "clang/AST/CommentNodes.inc"
74#undef COMMENT
75#undef ABSTRACT_COMMENT
76}

78#undef ASSERT_IMPLEMENTS_child_begin

80} // end unnamed namespace

82Comment::child_iterator Comment::child_begin() const {
switch (getCommentKind()) {
case NoCommentKind: llvm_unreachable("comment without a kind")__builtin_unreachable();
85#define ABSTRACT_COMMENT(COMMENT)
86#define COMMENT(CLASS, PARENT) \
case CLASS##Kind: \
  return static_cast<const CLASS *>(this)->child_begin();
89#include "clang/AST/CommentNodes.inc"
90#undef COMMENT
91#undef ABSTRACT_COMMENT
}
llvm_unreachable("Unknown comment kind!")__builtin_unreachable();
94}

96Comment::child_iterator Comment::child_end() const {
switch (getCommentKind()) {
case NoCommentKind: llvm_unreachable("comment without a kind")__builtin_unreachable();
99#define ABSTRACT_COMMENT(COMMENT)
100#define COMMENT(CLASS, PARENT) \
case CLASS##Kind: \
  return static_cast<const CLASS *>(this)->child_end();
103#include "clang/AST/CommentNodes.inc"
104#undef COMMENT
105#undef ABSTRACT_COMMENT
}
llvm_unreachable("Unknown comment kind!")__builtin_unreachable();
108}

110bool TextComment::isWhitespaceNoCache() const {
for (StringRef::const_iterator I = Text.begin(), E = Text.end();
     I != E; ++I) {
  if (!clang::isWhitespace(*I))
    return false;
}
return true;
117}

119bool ParagraphComment::isWhitespaceNoCache() const {
for (child_iterator I = child_begin(), E = child_end(); I != E; ++I) {
  if (const TextComment *TC = dyn_cast<TextComment>(*I)) {
    if (!TC->isWhitespace())
      return false;
  } else
    return false;
}
return true;
128}

130static TypeLoc lookThroughTypedefOrTypeAliasLocs(TypeLoc &SrcTL) {
TypeLoc TL = SrcTL.IgnoreParens();

// Look through attribute types.
if (AttributedTypeLoc AttributeTL = TL.getAs<AttributedTypeLoc>())
  return AttributeTL.getModifiedLoc();
// Look through qualified types.
if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>())
  return QualifiedTL.getUnqualifiedLoc();
// Look through pointer types.
if (PointerTypeLoc PointerTL = TL.getAs<PointerTypeLoc>())
  return PointerTL.getPointeeLoc().getUnqualifiedLoc();
// Look through reference types.
if (ReferenceTypeLoc ReferenceTL = TL.getAs<ReferenceTypeLoc>())
  return ReferenceTL.getPointeeLoc().getUnqualifiedLoc();
// Look through adjusted types.
if (AdjustedTypeLoc ATL = TL.getAs<AdjustedTypeLoc>())
  return ATL.getOriginalLoc();
if (BlockPointerTypeLoc BlockPointerTL = TL.getAs<BlockPointerTypeLoc>())
  return BlockPointerTL.getPointeeLoc().getUnqualifiedLoc();
if (MemberPointerTypeLoc MemberPointerTL = TL.getAs<MemberPointerTypeLoc>())
  return MemberPointerTL.getPointeeLoc().getUnqualifiedLoc();
if (ElaboratedTypeLoc ETL = TL.getAs<ElaboratedTypeLoc>())
  return ETL.getNamedTypeLoc();

return TL;
156}

158static bool getFunctionTypeLoc(TypeLoc TL, FunctionTypeLoc &ResFTL) {
TypeLoc PrevTL;
while (PrevTL != TL) {
  PrevTL = TL;
  TL = lookThroughTypedefOrTypeAliasLocs(TL);
}

if (FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>()) {
  ResFTL = FTL;
  return true;
}

if (TemplateSpecializationTypeLoc STL =
        TL.getAs<TemplateSpecializationTypeLoc>()) {
  // If we have a typedef to a template specialization with exactly one
  // template argument of a function type, this looks like std::function,
  // boost::function, or other function wrapper.  Treat these typedefs as
  // functions.
  if (STL.getNumArgs() != 1)
    return false;
  TemplateArgumentLoc MaybeFunction = STL.getArgLoc(0);
  if (MaybeFunction.getArgument().getKind() != TemplateArgument::Type)
    return false;
  TypeSourceInfo *MaybeFunctionTSI = MaybeFunction.getTypeSourceInfo();
  TypeLoc TL = MaybeFunctionTSI->getTypeLoc().getUnqualifiedLoc();
  if (FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>()) {
    ResFTL = FTL;
    return true;
  }
}

return false;
190}

192const char *ParamCommandComment::getDirectionAsString(PassDirection D) {
switch (D) {
case ParamCommandComment::In:
  return "[in]";
case ParamCommandComment::Out:
  return "[out]";
case ParamCommandComment::InOut:
  return "[in,out]";
}
llvm_unreachable("unknown PassDirection")__builtin_unreachable();
202}

204void DeclInfo::fill() {
assert(!IsFilled)((void)0);

// Set defaults.
Kind = OtherKind;
TemplateKind = NotTemplate;
IsObjCMethod = false;
IsInstanceMethod = false;
IsClassMethod = false;
ParamVars = None;
TemplateParameters = nullptr;
5
←
Null pointer value stored to field 'TemplateParameters'→

if (!CommentDecl) {
6
←
Assuming field 'CommentDecl' is null→
7
←
Taking true branch→
  // If there is no declaration, the defaults is our only guess.
  IsFilled = true;
  return;
}
CurrentDecl = CommentDecl;

Decl::Kind K = CommentDecl->getKind();
switch (K) {
default:
  // Defaults are should be good for declarations we don't handle explicitly.
  break;
case Decl::Function:
case Decl::CXXMethod:
case Decl::CXXConstructor:
case Decl::CXXDestructor:
case Decl::CXXConversion: {
  const FunctionDecl *FD = cast<FunctionDecl>(CommentDecl);
  Kind = FunctionKind;
  ParamVars = FD->parameters();
  ReturnType = FD->getReturnType();
  unsigned NumLists = FD->getNumTemplateParameterLists();
  if (NumLists != 0) {
    TemplateKind = TemplateSpecialization;
    TemplateParameters =
        FD->getTemplateParameterList(NumLists - 1);
  }

  if (K == Decl::CXXMethod || K == Decl::CXXConstructor ||
      K == Decl::CXXDestructor || K == Decl::CXXConversion) {
    const CXXMethodDecl *MD = cast<CXXMethodDecl>(CommentDecl);
    IsInstanceMethod = MD->isInstance();
    IsClassMethod = !IsInstanceMethod;
  }
  break;
}
case Decl::ObjCMethod: {
  const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(CommentDecl);
  Kind = FunctionKind;
  ParamVars = MD->parameters();
  ReturnType = MD->getReturnType();
  IsObjCMethod = true;
  IsInstanceMethod = MD->isInstanceMethod();
  IsClassMethod = !IsInstanceMethod;
  break;
}
case Decl::FunctionTemplate: {
  const FunctionTemplateDecl *FTD = cast<FunctionTemplateDecl>(CommentDecl);
  Kind = FunctionKind;
  TemplateKind = Template;
  const FunctionDecl *FD = FTD->getTemplatedDecl();
  ParamVars = FD->parameters();
  ReturnType = FD->getReturnType();
  TemplateParameters = FTD->getTemplateParameters();
  break;
}
case Decl::ClassTemplate: {
  const ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(CommentDecl);
  Kind = ClassKind;
  TemplateKind = Template;
  TemplateParameters = CTD->getTemplateParameters();
  break;
}
case Decl::ClassTemplatePartialSpecialization: {
  const ClassTemplatePartialSpecializationDecl *CTPSD =
      cast<ClassTemplatePartialSpecializationDecl>(CommentDecl);
  Kind = ClassKind;
  TemplateKind = TemplatePartialSpecialization;
  TemplateParameters = CTPSD->getTemplateParameters();
  break;
}
case Decl::ClassTemplateSpecialization:
  Kind = ClassKind;
  TemplateKind = TemplateSpecialization;
  break;
case Decl::Record:
case Decl::CXXRecord:
  Kind = ClassKind;
  break;
case Decl::Var:
case Decl::Field:
case Decl::EnumConstant:
case Decl::ObjCIvar:
case Decl::ObjCAtDefsField:
case Decl::ObjCProperty: {
  const TypeSourceInfo *TSI;
  if (const auto *VD = dyn_cast<DeclaratorDecl>(CommentDecl))
    TSI = VD->getTypeSourceInfo();
  else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(CommentDecl))
    TSI = PD->getTypeSourceInfo();
  else
    TSI = nullptr;
  if (TSI) {
    TypeLoc TL = TSI->getTypeLoc().getUnqualifiedLoc();
    FunctionTypeLoc FTL;
    if (getFunctionTypeLoc(TL, FTL)) {
      ParamVars = FTL.getParams();
      ReturnType = FTL.getReturnLoc().getType();
    }
  }
  Kind = VariableKind;
  break;
}
case Decl::Namespace:
  Kind = NamespaceKind;
  break;
case Decl::TypeAlias:
case Decl::Typedef: {
  Kind = TypedefKind;
  // If this is a typedef / using to something we consider a function, extract
  // arguments and return type.
  const TypeSourceInfo *TSI =
      K == Decl::Typedef
          ? cast<TypedefDecl>(CommentDecl)->getTypeSourceInfo()
          : cast<TypeAliasDecl>(CommentDecl)->getTypeSourceInfo();
  if (!TSI)
    break;
  TypeLoc TL = TSI->getTypeLoc().getUnqualifiedLoc();
  FunctionTypeLoc FTL;
  if (getFunctionTypeLoc(TL, FTL)) {
    Kind = FunctionKind;
    ParamVars = FTL.getParams();
    ReturnType = FTL.getReturnLoc().getType();
  }
  break;
}
case Decl::TypeAliasTemplate: {
  const TypeAliasTemplateDecl *TAT = cast<TypeAliasTemplateDecl>(CommentDecl);
  Kind = TypedefKind;
  TemplateKind = Template;
  TemplateParameters = TAT->getTemplateParameters();
  TypeAliasDecl *TAD = TAT->getTemplatedDecl();
  if (!TAD)
    break;

  const TypeSourceInfo *TSI = TAD->getTypeSourceInfo();
  if (!TSI)
    break;
  TypeLoc TL = TSI->getTypeLoc().getUnqualifiedLoc();
  FunctionTypeLoc FTL;
  if (getFunctionTypeLoc(TL, FTL)) {
    Kind = FunctionKind;
    ParamVars = FTL.getParams();
    ReturnType = FTL.getReturnLoc().getType();
  }
  break;
}
case Decl::Enum:
  Kind = EnumKind;
  break;
}

IsFilled = true;
369}

371StringRef ParamCommandComment::getParamName(const FullComment *FC) const {
assert(isParamIndexValid())((void)0);
if (isVarArgParam())
  return "...";
return FC->getDeclInfo()->ParamVars[getParamIndex()]->getName();
376}

378StringRef TParamCommandComment::getParamName(const FullComment *FC) const {
assert(isPositionValid())((void)0);
const TemplateParameterList *TPL = FC->getDeclInfo()->TemplateParameters;
1
Calling 'FullComment::getDeclInfo'→
9
←
Returning from 'FullComment::getDeclInfo'→
10
←
'TPL' initialized to a null pointer value→
for (unsigned i = 0, e = getDepth(); i != e; ++i) {
11
←
Assuming 'i' is not equal to 'e'→
12
←
Loop condition is true.  Entering loop body→
  assert(TPL && "Unknown TemplateParameterList")((void)0);
  if (i == e - 1)
13
←
Assuming the condition is true→
14
←
Taking true branch→
    return TPL->getParam(getIndex(i))->getName();
15
←
Called C++ object pointer is null
  const NamedDecl *Param = TPL->getParam(getIndex(i));
  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param))
    TPL = TTP->getTemplateParameters();
}
return "";
390}

392} // end namespace comments
393} // end namespace clang


←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/Comment.h

1//===--- Comment.h - Comment AST nodes --------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines comment AST nodes.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_COMMENT_H
14#define LLVM_CLANG_AST_COMMENT_H

16#include "clang/AST/CommentCommandTraits.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/Type.h"
19#include "clang/Basic/SourceLocation.h"
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/StringRef.h"

23namespace clang {
24class Decl;
25class ParmVarDecl;
26class TemplateParameterList;

28namespace comments {
29class FullComment;

31/// Describes the syntax that was used in a documentation command.
32///
33/// Exact values of this enumeration are important because they used to select
34/// parts of diagnostic messages.  Audit diagnostics before changing or adding
35/// a new value.
36enum CommandMarkerKind {
/// Command started with a backslash character:
/// \code
///   \foo
/// \endcode
CMK_Backslash = 0,

/// Command started with an 'at' character:
/// \code
///   @foo
/// \endcode
CMK_At = 1
48};

50/// Any part of the comment.
51/// Abstract class.
52class Comment {
53protected:
/// Preferred location to show caret.
SourceLocation Loc;

/// Source range of this AST node.
SourceRange Range;

class CommentBitfields {
  friend class Comment;

  /// Type of this AST node.
  unsigned Kind : 8;
};
enum { NumCommentBits = 8 };

class InlineContentCommentBitfields {
  friend class InlineContentComment;

  unsigned : NumCommentBits;

  /// True if there is a newline after this inline content node.
  /// (There is no separate AST node for a newline.)
  unsigned HasTrailingNewline : 1;
};
enum { NumInlineContentCommentBits = NumCommentBits + 1 };

class TextCommentBitfields {
  friend class TextComment;

  unsigned : NumInlineContentCommentBits;

  /// True if \c IsWhitespace field contains a valid value.
  mutable unsigned IsWhitespaceValid : 1;

  /// True if this comment AST node contains only whitespace.
  mutable unsigned IsWhitespace : 1;
};
enum { NumTextCommentBits = NumInlineContentCommentBits + 2 };

class InlineCommandCommentBitfields {
  friend class InlineCommandComment;

  unsigned : NumInlineContentCommentBits;

  unsigned RenderKind : 3;

  unsigned CommandID : CommandInfo::NumCommandIDBits;
};
enum { NumInlineCommandCommentBits = NumInlineContentCommentBits + 3 +
                                     CommandInfo::NumCommandIDBits };

class HTMLTagCommentBitfields {
  friend class HTMLTagComment;

  unsigned : NumInlineContentCommentBits;

  /// True if we found that this tag is malformed in some way.
  unsigned IsMalformed : 1;
};
enum { NumHTMLTagCommentBits = NumInlineContentCommentBits + 1 };

class HTMLStartTagCommentBitfields {
  friend class HTMLStartTagComment;

  unsigned : NumHTMLTagCommentBits;

  /// True if this tag is self-closing (e. g., <br />).  This is based on tag
  /// spelling in comment (plain <br> would not set this flag).
  unsigned IsSelfClosing : 1;
};
enum { NumHTMLStartTagCommentBits = NumHTMLTagCommentBits + 1 };

class ParagraphCommentBitfields {
  friend class ParagraphComment;

  unsigned : NumCommentBits;

  /// True if \c IsWhitespace field contains a valid value.
  mutable unsigned IsWhitespaceValid : 1;

  /// True if this comment AST node contains only whitespace.
  mutable unsigned IsWhitespace : 1;
};
enum { NumParagraphCommentBits = NumCommentBits + 2 };

class BlockCommandCommentBitfields {
  friend class BlockCommandComment;

  unsigned : NumCommentBits;

  unsigned CommandID : CommandInfo::NumCommandIDBits;

  /// Describes the syntax that was used in a documentation command.
  /// Contains values from CommandMarkerKind enum.
  unsigned CommandMarker : 1;
};
enum { NumBlockCommandCommentBits = NumCommentBits +
                                    CommandInfo::NumCommandIDBits + 1 };

class ParamCommandCommentBitfields {
  friend class ParamCommandComment;

  unsigned : NumBlockCommandCommentBits;

  /// Parameter passing direction, see ParamCommandComment::PassDirection.
  unsigned Direction : 2;

  /// True if direction was specified explicitly in the comment.
  unsigned IsDirectionExplicit : 1;
};
enum { NumParamCommandCommentBits = NumBlockCommandCommentBits + 3 };

union {
  CommentBitfields CommentBits;
  InlineContentCommentBitfields InlineContentCommentBits;
  TextCommentBitfields TextCommentBits;
  InlineCommandCommentBitfields InlineCommandCommentBits;
  HTMLTagCommentBitfields HTMLTagCommentBits;
  HTMLStartTagCommentBitfields HTMLStartTagCommentBits;
  ParagraphCommentBitfields ParagraphCommentBits;
  BlockCommandCommentBitfields BlockCommandCommentBits;
  ParamCommandCommentBitfields ParamCommandCommentBits;
};

void setSourceRange(SourceRange SR) {
  Range = SR;
}

void setLocation(SourceLocation L) {
  Loc = L;
}

185public:
enum CommentKind {
  NoCommentKind = 0,
188#define COMMENT(CLASS, PARENT) CLASS##Kind,
189#define COMMENT_RANGE(BASE, FIRST, LAST) \
  First##BASE##Constant=FIRST##Kind, Last##BASE##Constant=LAST##Kind,
191#define LAST_COMMENT_RANGE(BASE, FIRST, LAST) \
  First##BASE##Constant=FIRST##Kind, Last##BASE##Constant=LAST##Kind
193#define ABSTRACT_COMMENT(COMMENT)
194#include "clang/AST/CommentNodes.inc"
};

Comment(CommentKind K,
        SourceLocation LocBegin,
        SourceLocation LocEnd) :
    Loc(LocBegin), Range(SourceRange(LocBegin, LocEnd)) {
  CommentBits.Kind = K;
}

CommentKind getCommentKind() const {
  return static_cast<CommentKind>(CommentBits.Kind);
}

const char *getCommentKindName() const;

void dump() const;
void dumpColor() const;
void dump(raw_ostream &OS, const ASTContext &Context) const;

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }

SourceLocation getLocation() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

typedef Comment * const *child_iterator;

child_iterator child_begin() const;
child_iterator child_end() const;

// TODO: const child iterator

unsigned child_count() const {
  return child_end() - child_begin();
}
232};

234/// Inline content (contained within a block).
235/// Abstract class.
236class InlineContentComment : public Comment {
237protected:
InlineContentComment(CommentKind K,
                     SourceLocation LocBegin,
                     SourceLocation LocEnd) :
    Comment(K, LocBegin, LocEnd) {
  InlineContentCommentBits.HasTrailingNewline = 0;
}

245public:
static bool classof(const Comment *C) {
  return C->getCommentKind() >= FirstInlineContentCommentConstant &&
         C->getCommentKind() <= LastInlineContentCommentConstant;
}

void addTrailingNewline() {
  InlineContentCommentBits.HasTrailingNewline = 1;
}

bool hasTrailingNewline() const {
  return InlineContentCommentBits.HasTrailingNewline;
}
258};

260/// Plain text.
261class TextComment : public InlineContentComment {
StringRef Text;

264public:
TextComment(SourceLocation LocBegin,
            SourceLocation LocEnd,
            StringRef Text) :
    InlineContentComment(TextCommentKind, LocBegin, LocEnd),
    Text(Text) {
  TextCommentBits.IsWhitespaceValid = false;
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == TextCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }

StringRef getText() const LLVM_READONLY__attribute__((__pure__)) { return Text; }

bool isWhitespace() const {
  if (TextCommentBits.IsWhitespaceValid)
    return TextCommentBits.IsWhitespace;

  TextCommentBits.IsWhitespace = isWhitespaceNoCache();
  TextCommentBits.IsWhitespaceValid = true;
  return TextCommentBits.IsWhitespace;
}

292private:
bool isWhitespaceNoCache() const;
294};

296/// A command with word-like arguments that is considered inline content.
297class InlineCommandComment : public InlineContentComment {
298public:
struct Argument {
  SourceRange Range;
  StringRef Text;

  Argument(SourceRange Range, StringRef Text) : Range(Range), Text(Text) { }
};

/// The most appropriate rendering mode for this command, chosen on command
/// semantics in Doxygen.
enum RenderKind {
  RenderNormal,
  RenderBold,
  RenderMonospaced,
  RenderEmphasized,
  RenderAnchor
};

316protected:
/// Command arguments.
ArrayRef<Argument> Args;

320public:
InlineCommandComment(SourceLocation LocBegin,
                     SourceLocation LocEnd,
                     unsigned CommandID,
                     RenderKind RK,
                     ArrayRef<Argument> Args) :
    InlineContentComment(InlineCommandCommentKind, LocBegin, LocEnd),
    Args(Args) {
  InlineCommandCommentBits.RenderKind = RK;
  InlineCommandCommentBits.CommandID = CommandID;
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == InlineCommandCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }

unsigned getCommandID() const {
  return InlineCommandCommentBits.CommandID;
}

StringRef getCommandName(const CommandTraits &Traits) const {
  return Traits.getCommandInfo(getCommandID())->Name;
}

SourceRange getCommandNameRange() const {
  return SourceRange(getBeginLoc().getLocWithOffset(-1), getEndLoc());
}

RenderKind getRenderKind() const {
  return static_cast<RenderKind>(InlineCommandCommentBits.RenderKind);
}

unsigned getNumArgs() const {
  return Args.size();
}

StringRef getArgText(unsigned Idx) const {
  return Args[Idx].Text;
}

SourceRange getArgRange(unsigned Idx) const {
  return Args[Idx].Range;
}
367};

369/// Abstract class for opening and closing HTML tags.  HTML tags are always
370/// treated as inline content (regardless HTML semantics).
371class HTMLTagComment : public InlineContentComment {
372protected:
StringRef TagName;
SourceRange TagNameRange;

HTMLTagComment(CommentKind K,
               SourceLocation LocBegin,
               SourceLocation LocEnd,
               StringRef TagName,
               SourceLocation TagNameBegin,
               SourceLocation TagNameEnd) :
    InlineContentComment(K, LocBegin, LocEnd),
    TagName(TagName),
    TagNameRange(TagNameBegin, TagNameEnd) {
  setLocation(TagNameBegin);
  HTMLTagCommentBits.IsMalformed = 0;
}

389public:
static bool classof(const Comment *C) {
  return C->getCommentKind() >= FirstHTMLTagCommentConstant &&
         C->getCommentKind() <= LastHTMLTagCommentConstant;
}

StringRef getTagName() const LLVM_READONLY__attribute__((__pure__)) { return TagName; }

SourceRange getTagNameSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  SourceLocation L = getLocation();
  return SourceRange(L.getLocWithOffset(1),
                     L.getLocWithOffset(1 + TagName.size()));
}

bool isMalformed() const {
  return HTMLTagCommentBits.IsMalformed;
}

void setIsMalformed() {
  HTMLTagCommentBits.IsMalformed = 1;
}
410};

412/// An opening HTML tag with attributes.
413class HTMLStartTagComment : public HTMLTagComment {
414public:
class Attribute {
public:
  SourceLocation NameLocBegin;
  StringRef Name;

  SourceLocation EqualsLoc;

  SourceRange ValueRange;
  StringRef Value;

  Attribute() { }

  Attribute(SourceLocation NameLocBegin, StringRef Name) :
      NameLocBegin(NameLocBegin), Name(Name),
      EqualsLoc(SourceLocation()),
      ValueRange(SourceRange()), Value(StringRef())
  { }

  Attribute(SourceLocation NameLocBegin, StringRef Name,
            SourceLocation EqualsLoc,
            SourceRange ValueRange, StringRef Value) :
      NameLocBegin(NameLocBegin), Name(Name),
      EqualsLoc(EqualsLoc),
      ValueRange(ValueRange), Value(Value)
  { }

  SourceLocation getNameLocEnd() const {
    return NameLocBegin.getLocWithOffset(Name.size());
  }

  SourceRange getNameRange() const {
    return SourceRange(NameLocBegin, getNameLocEnd());
  }
};

450private:
ArrayRef<Attribute> Attributes;

453public:
HTMLStartTagComment(SourceLocation LocBegin,
                    StringRef TagName) :
    HTMLTagComment(HTMLStartTagCommentKind,
                   LocBegin, LocBegin.getLocWithOffset(1 + TagName.size()),
                   TagName,
                   LocBegin.getLocWithOffset(1),
                   LocBegin.getLocWithOffset(1 + TagName.size())) {
  HTMLStartTagCommentBits.IsSelfClosing = false;
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == HTMLStartTagCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }

unsigned getNumAttrs() const {
  return Attributes.size();
}

const Attribute &getAttr(unsigned Idx) const {
  return Attributes[Idx];
}

void setAttrs(ArrayRef<Attribute> Attrs) {
  Attributes = Attrs;
  if (!Attrs.empty()) {
    const Attribute &Attr = Attrs.back();
    SourceLocation L = Attr.ValueRange.getEnd();
    if (L.isValid())
      Range.setEnd(L);
    else {
      Range.setEnd(Attr.getNameLocEnd());
    }
  }
}

void setGreaterLoc(SourceLocation GreaterLoc) {
  Range.setEnd(GreaterLoc);
}

bool isSelfClosing() const {
  return HTMLStartTagCommentBits.IsSelfClosing;
}

void setSelfClosing() {
  HTMLStartTagCommentBits.IsSelfClosing = true;
}
504};

506/// A closing HTML tag.
507class HTMLEndTagComment : public HTMLTagComment {
508public:
HTMLEndTagComment(SourceLocation LocBegin,
                  SourceLocation LocEnd,
                  StringRef TagName) :
    HTMLTagComment(HTMLEndTagCommentKind,
                   LocBegin, LocEnd,
                   TagName,
                   LocBegin.getLocWithOffset(2),
                   LocBegin.getLocWithOffset(2 + TagName.size()))
{ }

static bool classof(const Comment *C) {
  return C->getCommentKind() == HTMLEndTagCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }
526};

528/// Block content (contains inline content).
529/// Abstract class.
530class BlockContentComment : public Comment {
531protected:
BlockContentComment(CommentKind K,
                    SourceLocation LocBegin,
                    SourceLocation LocEnd) :
    Comment(K, LocBegin, LocEnd)
{ }

538public:
static bool classof(const Comment *C) {
  return C->getCommentKind() >= FirstBlockContentCommentConstant &&
         C->getCommentKind() <= LastBlockContentCommentConstant;
}
543};

545/// A single paragraph that contains inline content.
546class ParagraphComment : public BlockContentComment {
ArrayRef<InlineContentComment *> Content;

549public:
ParagraphComment(ArrayRef<InlineContentComment *> Content) :
    BlockContentComment(ParagraphCommentKind,
                        SourceLocation(),
                        SourceLocation()),
    Content(Content) {
  if (Content.empty()) {
    ParagraphCommentBits.IsWhitespace = true;
    ParagraphCommentBits.IsWhitespaceValid = true;
    return;
  }

  ParagraphCommentBits.IsWhitespaceValid = false;

  setSourceRange(SourceRange(Content.front()->getBeginLoc(),
                             Content.back()->getEndLoc()));
  setLocation(Content.front()->getBeginLoc());
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == ParagraphCommentKind;
}

child_iterator child_begin() const {
  return reinterpret_cast<child_iterator>(Content.begin());
}

child_iterator child_end() const {
  return reinterpret_cast<child_iterator>(Content.end());
}

bool isWhitespace() const {
  if (ParagraphCommentBits.IsWhitespaceValid)
    return ParagraphCommentBits.IsWhitespace;

  ParagraphCommentBits.IsWhitespace = isWhitespaceNoCache();
  ParagraphCommentBits.IsWhitespaceValid = true;
  return ParagraphCommentBits.IsWhitespace;
}

589private:
bool isWhitespaceNoCache() const;
591};

593/// A command that has zero or more word-like arguments (number of word-like
594/// arguments depends on command name) and a paragraph as an argument
595/// (e. g., \\brief).
596class BlockCommandComment : public BlockContentComment {
597public:
struct Argument {
  SourceRange Range;
  StringRef Text;

  Argument() { }
  Argument(SourceRange Range, StringRef Text) : Range(Range), Text(Text) { }
};

606protected:
/// Word-like arguments.
ArrayRef<Argument> Args;

/// Paragraph argument.
ParagraphComment *Paragraph;

BlockCommandComment(CommentKind K,
                    SourceLocation LocBegin,
                    SourceLocation LocEnd,
                    unsigned CommandID,
                    CommandMarkerKind CommandMarker) :
    BlockContentComment(K, LocBegin, LocEnd),
    Paragraph(nullptr) {
  setLocation(getCommandNameBeginLoc());
  BlockCommandCommentBits.CommandID = CommandID;
  BlockCommandCommentBits.CommandMarker = CommandMarker;
}

625public:
BlockCommandComment(SourceLocation LocBegin,
                    SourceLocation LocEnd,
                    unsigned CommandID,
                    CommandMarkerKind CommandMarker) :
    BlockContentComment(BlockCommandCommentKind, LocBegin, LocEnd),
    Paragraph(nullptr) {
  setLocation(getCommandNameBeginLoc());
  BlockCommandCommentBits.CommandID = CommandID;
  BlockCommandCommentBits.CommandMarker = CommandMarker;
}

static bool classof(const Comment *C) {
  return C->getCommentKind() >= FirstBlockCommandCommentConstant &&
         C->getCommentKind() <= LastBlockCommandCommentConstant;
}

child_iterator child_begin() const {
  return reinterpret_cast<child_iterator>(&Paragraph);
}

child_iterator child_end() const {
  return reinterpret_cast<child_iterator>(&Paragraph + 1);
}

unsigned getCommandID() const {
  return BlockCommandCommentBits.CommandID;
}

StringRef getCommandName(const CommandTraits &Traits) const {
  return Traits.getCommandInfo(getCommandID())->Name;
}

SourceLocation getCommandNameBeginLoc() const {
  return getBeginLoc().getLocWithOffset(1);
}

SourceRange getCommandNameRange(const CommandTraits &Traits) const {
  StringRef Name = getCommandName(Traits);
  return SourceRange(getCommandNameBeginLoc(),
                     getBeginLoc().getLocWithOffset(1 + Name.size()));
}

unsigned getNumArgs() const {
  return Args.size();
}

StringRef getArgText(unsigned Idx) const {
  return Args[Idx].Text;
}

SourceRange getArgRange(unsigned Idx) const {
  return Args[Idx].Range;
}

void setArgs(ArrayRef<Argument> A) {
  Args = A;
  if (Args.size() > 0) {
    SourceLocation NewLocEnd = Args.back().Range.getEnd();
    if (NewLocEnd.isValid())
      setSourceRange(SourceRange(getBeginLoc(), NewLocEnd));
  }
}

ParagraphComment *getParagraph() const LLVM_READONLY__attribute__((__pure__)) {
  return Paragraph;
}

bool hasNonWhitespaceParagraph() const {
  return Paragraph && !Paragraph->isWhitespace();
}

void setParagraph(ParagraphComment *PC) {
  Paragraph = PC;
  SourceLocation NewLocEnd = PC->getEndLoc();
  if (NewLocEnd.isValid())
    setSourceRange(SourceRange(getBeginLoc(), NewLocEnd));
}

CommandMarkerKind getCommandMarker() const LLVM_READONLY__attribute__((__pure__)) {
  return static_cast<CommandMarkerKind>(
      BlockCommandCommentBits.CommandMarker);
}
708};

710/// Doxygen \\param command.
711class ParamCommandComment : public BlockCommandComment {
712private:
/// Parameter index in the function declaration.
unsigned ParamIndex;

716public:
enum : unsigned {
  InvalidParamIndex = ~0U,
  VarArgParamIndex = ~0U/*InvalidParamIndex*/ - 1U
};

ParamCommandComment(SourceLocation LocBegin,
                    SourceLocation LocEnd,
                    unsigned CommandID,
                    CommandMarkerKind CommandMarker) :
    BlockCommandComment(ParamCommandCommentKind, LocBegin, LocEnd,
                        CommandID, CommandMarker),
    ParamIndex(InvalidParamIndex) {
  ParamCommandCommentBits.Direction = In;
  ParamCommandCommentBits.IsDirectionExplicit = false;
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == ParamCommandCommentKind;
}

enum PassDirection {
  In,
  Out,
  InOut
};

static const char *getDirectionAsString(PassDirection D);

PassDirection getDirection() const LLVM_READONLY__attribute__((__pure__)) {
  return static_cast<PassDirection>(ParamCommandCommentBits.Direction);
}

bool isDirectionExplicit() const LLVM_READONLY__attribute__((__pure__)) {
  return ParamCommandCommentBits.IsDirectionExplicit;
}

void setDirection(PassDirection Direction, bool Explicit) {
  ParamCommandCommentBits.Direction = Direction;
  ParamCommandCommentBits.IsDirectionExplicit = Explicit;
}

bool hasParamName() const {
  return getNumArgs() > 0;
}

StringRef getParamName(const FullComment *FC) const;

StringRef getParamNameAsWritten() const {
  return Args[0].Text;
}

SourceRange getParamNameRange() const {
  return Args[0].Range;
}

bool isParamIndexValid() const LLVM_READONLY__attribute__((__pure__)) {
  return ParamIndex != InvalidParamIndex;
}

bool isVarArgParam() const LLVM_READONLY__attribute__((__pure__)) {
  return ParamIndex == VarArgParamIndex;
}

void setIsVarArgParam() {
  ParamIndex = VarArgParamIndex;
  assert(isParamIndexValid())((void)0);
}

unsigned getParamIndex() const LLVM_READONLY__attribute__((__pure__)) {
  assert(isParamIndexValid())((void)0);
  assert(!isVarArgParam())((void)0);
  return ParamIndex;
}

void setParamIndex(unsigned Index) {
  ParamIndex = Index;
  assert(isParamIndexValid())((void)0);
  assert(!isVarArgParam())((void)0);
}
796};

798/// Doxygen \\tparam command, describes a template parameter.
799class TParamCommandComment : public BlockCommandComment {
800private:
/// If this template parameter name was resolved (found in template parameter
/// list), then this stores a list of position indexes in all template
/// parameter lists.
///
/// For example:
/// \verbatim
///     template<typename C, template<typename T> class TT>
///     void test(TT<int> aaa);
/// \endverbatim
/// For C:  Position = { 0 }
/// For TT: Position = { 1 }
/// For T:  Position = { 1, 0 }
ArrayRef<unsigned> Position;

815public:
TParamCommandComment(SourceLocation LocBegin,
                     SourceLocation LocEnd,
                     unsigned CommandID,
                     CommandMarkerKind CommandMarker) :
    BlockCommandComment(TParamCommandCommentKind, LocBegin, LocEnd, CommandID,
                        CommandMarker)
{ }

static bool classof(const Comment *C) {
  return C->getCommentKind() == TParamCommandCommentKind;
}

bool hasParamName() const {
  return getNumArgs() > 0;
}

StringRef getParamName(const FullComment *FC) const;

StringRef getParamNameAsWritten() const {
  return Args[0].Text;
}

SourceRange getParamNameRange() const {
  return Args[0].Range;
}

bool isPositionValid() const LLVM_READONLY__attribute__((__pure__)) {
  return !Position.empty();
}

unsigned getDepth() const {
  assert(isPositionValid())((void)0);
  return Position.size();
}

unsigned getIndex(unsigned Depth) const {
  assert(isPositionValid())((void)0);
  return Position[Depth];
}

void setPosition(ArrayRef<unsigned> NewPosition) {
  Position = NewPosition;
  assert(isPositionValid())((void)0);
}
860};

862/// A line of text contained in a verbatim block.
863class VerbatimBlockLineComment : public Comment {
StringRef Text;

866public:
VerbatimBlockLineComment(SourceLocation LocBegin,
                         StringRef Text) :
    Comment(VerbatimBlockLineCommentKind,
            LocBegin,
            LocBegin.getLocWithOffset(Text.size())),
    Text(Text)
{ }

static bool classof(const Comment *C) {
  return C->getCommentKind() == VerbatimBlockLineCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }

StringRef getText() const LLVM_READONLY__attribute__((__pure__)) {
  return Text;
}
886};

888/// A verbatim block command (e. g., preformatted code).  Verbatim block has an
889/// opening and a closing command and contains multiple lines of text
890/// (VerbatimBlockLineComment nodes).
891class VerbatimBlockComment : public BlockCommandComment {
892protected:
StringRef CloseName;
SourceLocation CloseNameLocBegin;
ArrayRef<VerbatimBlockLineComment *> Lines;

897public:
VerbatimBlockComment(SourceLocation LocBegin,
                     SourceLocation LocEnd,
                     unsigned CommandID) :
    BlockCommandComment(VerbatimBlockCommentKind,
                        LocBegin, LocEnd, CommandID,
                        CMK_At) // FIXME: improve source fidelity.
{ }

static bool classof(const Comment *C) {
  return C->getCommentKind() == VerbatimBlockCommentKind;
}

child_iterator child_begin() const {
  return reinterpret_cast<child_iterator>(Lines.begin());
}

child_iterator child_end() const {
  return reinterpret_cast<child_iterator>(Lines.end());
}

void setCloseName(StringRef Name, SourceLocation LocBegin) {
  CloseName = Name;
  CloseNameLocBegin = LocBegin;
}

void setLines(ArrayRef<VerbatimBlockLineComment *> L) {
  Lines = L;
}

StringRef getCloseName() const {
  return CloseName;
}

unsigned getNumLines() const {
  return Lines.size();
}

StringRef getText(unsigned LineIdx) const {
  return Lines[LineIdx]->getText();
}
938};

940/// A verbatim line command.  Verbatim line has an opening command, a single
941/// line of text (up to the newline after the opening command) and has no
942/// closing command.
943class VerbatimLineComment : public BlockCommandComment {
944protected:
StringRef Text;
SourceLocation TextBegin;

948public:
VerbatimLineComment(SourceLocation LocBegin,
                    SourceLocation LocEnd,
                    unsigned CommandID,
                    SourceLocation TextBegin,
                    StringRef Text) :
    BlockCommandComment(VerbatimLineCommentKind,
                        LocBegin, LocEnd,
                        CommandID,
                        CMK_At), // FIXME: improve source fidelity.
    Text(Text),
    TextBegin(TextBegin)
{ }

static bool classof(const Comment *C) {
  return C->getCommentKind() == VerbatimLineCommentKind;
}

child_iterator child_begin() const { return nullptr; }

child_iterator child_end() const { return nullptr; }

StringRef getText() const {
  return Text;
}

SourceRange getTextRange() const {
  return SourceRange(TextBegin, getEndLoc());
}
977};

979/// Information about the declaration, useful to clients of FullComment.
980struct DeclInfo {
/// Declaration the comment is actually attached to (in the source).
/// Should not be NULL.
const Decl *CommentDecl;

/// CurrentDecl is the declaration with which the FullComment is associated.
///
/// It can be different from \c CommentDecl.  It happens when we decide
/// that the comment originally attached to \c CommentDecl is fine for
/// \c CurrentDecl too (for example, for a redeclaration or an overrider of
/// \c CommentDecl).
///
/// The information in the DeclInfo corresponds to CurrentDecl.
const Decl *CurrentDecl;

/// Parameters that can be referenced by \\param if \c CommentDecl is something
/// that we consider a "function".
ArrayRef<const ParmVarDecl *> ParamVars;

/// Function return type if \c CommentDecl is something that we consider
/// a "function".
QualType ReturnType;

/// Template parameters that can be referenced by \\tparam if \c CommentDecl is
/// a template (\c IsTemplateDecl or \c IsTemplatePartialSpecialization is
/// true).
const TemplateParameterList *TemplateParameters;

/// A simplified description of \c CommentDecl kind that should be good enough
/// for documentation rendering purposes.
enum DeclKind {
  /// Everything else not explicitly mentioned below.
  OtherKind,

  /// Something that we consider a "function":
  /// \li function,
  /// \li function template,
  /// \li function template specialization,
  /// \li member function,
  /// \li member function template,
  /// \li member function template specialization,
  /// \li ObjC method,
  /// \li a typedef for a function pointer, member function pointer,
  ///     ObjC block.
  FunctionKind,

  /// Something that we consider a "class":
  /// \li class/struct,
  /// \li class template,
  /// \li class template (partial) specialization.
  ClassKind,

  /// Something that we consider a "variable":
  /// \li namespace scope variables;
  /// \li static and non-static class data members;
  /// \li enumerators.
  VariableKind,

  /// A C++ namespace.
  NamespaceKind,

  /// A C++ typedef-name (a 'typedef' decl specifier or alias-declaration),
  /// see \c TypedefNameDecl.
  TypedefKind,

  /// An enumeration or scoped enumeration.
  EnumKind
};

/// What kind of template specialization \c CommentDecl is.
enum TemplateDeclKind {
  NotTemplate,
  Template,
  TemplateSpecialization,
  TemplatePartialSpecialization
};

/// If false, only \c CommentDecl is valid.
unsigned IsFilled : 1;

/// Simplified kind of \c CommentDecl, see \c DeclKind enum.
unsigned Kind : 3;

/// Is \c CommentDecl a template declaration.
unsigned TemplateKind : 2;

/// Is \c CommentDecl an ObjCMethodDecl.
unsigned IsObjCMethod : 1;

/// Is \c CommentDecl a non-static member function of C++ class or
/// instance method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsInstanceMethod : 1;

/// Is \c CommentDecl a static member function of C++ class or
/// class method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsClassMethod : 1;

void fill();

DeclKind getKind() const LLVM_READONLY__attribute__((__pure__)) {
  return static_cast<DeclKind>(Kind);
}

TemplateDeclKind getTemplateKind() const LLVM_READONLY__attribute__((__pure__)) {
  return static_cast<TemplateDeclKind>(TemplateKind);
}
1088};

1090/// A full comment attached to a declaration, contains block content.
1091class FullComment : public Comment {
ArrayRef<BlockContentComment *> Blocks;
DeclInfo *ThisDeclInfo;

1095public:
FullComment(ArrayRef<BlockContentComment *> Blocks, DeclInfo *D) :
    Comment(FullCommentKind, SourceLocation(), SourceLocation()),
    Blocks(Blocks), ThisDeclInfo(D) {
  if (Blocks.empty())
    return;

  setSourceRange(
      SourceRange(Blocks.front()->getBeginLoc(), Blocks.back()->getEndLoc()));
  setLocation(Blocks.front()->getBeginLoc());
}

static bool classof(const Comment *C) {
  return C->getCommentKind() == FullCommentKind;
}

child_iterator child_begin() const {
  return reinterpret_cast<child_iterator>(Blocks.begin());
}

child_iterator child_end() const {
  return reinterpret_cast<child_iterator>(Blocks.end());
}

const Decl *getDecl() const LLVM_READONLY__attribute__((__pure__)) {
  return ThisDeclInfo->CommentDecl;
}

const DeclInfo *getDeclInfo() const LLVM_READONLY__attribute__((__pure__)) {
  if (!ThisDeclInfo->IsFilled)
2
←
Assuming field 'IsFilled' is 0→
3
←
Taking true branch→
    ThisDeclInfo->fill();
4
←
Calling 'DeclInfo::fill'→
8
←
Returning from 'DeclInfo::fill'→
  return ThisDeclInfo;
}

ArrayRef<BlockContentComment *> getBlocks() const { return Blocks; }

1131};
1132} // end namespace comments
1133} // end namespace clang

1135#endif
