Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ASTDiagnostic_8cpp_source.html below:

clang: lib/AST/ASTDiagnostic.cpp Source File

;

(

*UT = dyn_cast<UsingType>(Ty)) {

(

*PT = dyn_cast<ParenType>(Ty)) {

dyn_cast<SubstTemplateTypeParmType>(Ty)) {

(

*AT = dyn_cast<AdjustedType>(Ty)) {

(

*AT = dyn_cast<AutoType>(Ty)) {

(

*FT = dyn_cast<FunctionType>(Ty)) {

DesugarReturn =

;

SugarRT = FT->getReturnType();

DesugarArgument =

;

(

nullability =

(DesugarReturn || DesugarArgument) {

dyn_cast<TemplateSpecializationType>(Ty)) {

(!TST->isTypeAlias()) {

DesugarArgument =

;

(DesugarArgument) {

TST->getTemplateName(), Args, QT);

(

*AT = dyn_cast<ArrayType>(Ty)) {

(

*CAT = dyn_cast<ConstantArrayType>(AT))

ElementTy, CAT->getSize(), CAT->getSizeExpr(),

CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());

(

*VAT = dyn_cast<VariableArrayType>(AT))

ElementTy, VAT->getSizeExpr(), VAT->getSizeModifier(),

VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());

(

*DSAT = dyn_cast<DependentSizedArrayType>(AT))

ElementTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),

DSAT->getIndexTypeCVRQualifiers(), DSAT->getBracketsRange());

(

*IAT = dyn_cast<IncompleteArrayType>(AT))

IAT->getIndexTypeCVRQualifiers());

llvm_unreachable(

);

IsSugar =

;

(isa<VectorType>(Underlying))

(

*QTT = dyn_cast<TypedefType>(QT))

(UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())

(Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {

BaseType, Ty->getTypeArgsAsWritten(),

Ty->isKindOfTypeAsWritten());

QC.

(Context, QT);

ForceAKA =

;

(

&QualTypeVal : QualTypeVals) {

(CompareCanTy == CanTy)

ShouldAKA =

;

std::string CompareDesugarStr =

(CompareS != S && CompareDesugarStr != S)

std::string CompareCanS =

(CompareCanS == CanS)

Repeated =

;

(

&PrevArg : PrevArgs) {

ShouldAKA =

;

(ShouldAKA || ForceAKA) {

(DesugaredTy == Ty) {

S =

+ S +

+ akaStr +

;

std::string DecoratedString;

llvm::raw_string_ostream OS(DecoratedString);

*Values = VTy->getNumElements() > 1 ?

:

;

OS <<

<< S <<

<< VTy->getNumElements() <<

<<

<< Values <<

;

DecoratedString;

PrintFromType,

ElideType,

OldEnd = Output.size();

llvm::raw_svector_ostream OS(Output);

NeedQuotes =

;

: llvm_unreachable(

);

assert(Modifier.empty() && Argument.empty() &&

);

OS << (Context.

().OpenCL ?

:

);

OS <<

;

OS <<

;

OS <<

<< S <<

;

assert(Modifier.empty() && Argument.empty() &&

);

OS <<

;

Modifier = StringRef();

Argument = StringRef();

assert(Modifier.empty() && Argument.empty() &&

);

(Modifier ==

&& Argument.empty())

(Modifier ==

&& Argument.empty())

assert(Modifier.empty() && Argument.empty() &&

);

(Modifier ==

&& Argument.empty())

assert(Modifier.empty() && Argument.empty() &&

);

assert(DC &&

);

OS <<

;

OS <<

;

OS <<

;

OS <<

;

PrevArgs, QualTypeVals);

assert(isa<NamedDecl>(DC) &&

);

(isa<NamespaceDecl>(ND))

(isa<ObjCMethodDecl>(ND))

(isa<FunctionDecl>(ND))

*At =

*

(Val);

assert(At &&

);

Output.insert(Output.begin()+OldEnd,

);

Output.push_back(

);

FromIntegerAndToDeclaration,

FromDeclarationAndToInteger

TemplateArgumentInfo {

IsValidInt =

;

*ArgExpr =

;

NeedAddressOf =

;

IsNullPtr =

;

IsDefault =

;

NextNode = 0;

ChildNode = 0;

ParentNode = 0;

TemplateArgumentInfo FromArgInfo, ToArgInfo;

DiffNode(

ParentNode = 0) : ParentNode(ParentNode) {}

CurrentNode;

NextFreeNode;

DiffTree() : CurrentNode(0), NextFreeNode(1), ReadNode(0) {

FlatTree.push_back(DiffNode());

FromDefault,

ToDefault) {

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind = Template;

FlatTree[CurrentNode].FromArgInfo.TD = FromTD;

FlatTree[CurrentNode].ToArgInfo.TD = ToTD;

FlatTree[CurrentNode].FromArgInfo.Qual = FromQual;

FlatTree[CurrentNode].ToArgInfo.Qual = ToQual;

SetDefault(FromDefault, ToDefault);

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind =

;

FlatTree[CurrentNode].FromArgInfo.ArgType = FromType;

FlatTree[CurrentNode].ToArgInfo.ArgType = ToType;

SetDefault(FromDefault, ToDefault);

SetExpressionDiff(

*FromExpr,

*ToExpr,

FromDefault,

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;

FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;

SetDefault(FromDefault, ToDefault);

FromDefault,

ToDefault) {

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind = TemplateTemplate;

FlatTree[CurrentNode].FromArgInfo.TD = FromTD;

FlatTree[CurrentNode].ToArgInfo.TD = ToTD;

SetDefault(FromDefault, ToDefault);

SetIntegerDiff(

llvm::APSInt &FromInt,

llvm::APSInt &ToInt,

IsValidFromInt,

IsValidToInt,

*FromExpr,

*ToExpr,

FromDefault,

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind =

;

FlatTree[CurrentNode].FromArgInfo.Val = FromInt;

FlatTree[CurrentNode].ToArgInfo.Val = ToInt;

FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;

FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;

FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;

FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;

FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;

FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;

SetDefault(FromDefault, ToDefault);

FromAddressOf,

ToAddressOf,

FromNullPtr,

ToNullPtr,

*FromExpr,

*ToExpr,

FromDefault,

ToDefault) {

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;

FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;

FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;

FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;

FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;

FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;

FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;

FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;

SetDefault(FromDefault, ToDefault);

SetFromDeclarationAndToIntegerDiff(

*FromValueDecl,

FromAddressOf,

FromNullPtr,

*FromExpr,

llvm::APSInt &ToInt,

IsValidToInt,

ToIntType,

*ToExpr,

FromDefault,

ToDefault) {

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;

FlatTree[CurrentNode].FromArgInfo.VD = FromValueDecl;

FlatTree[CurrentNode].FromArgInfo.NeedAddressOf = FromAddressOf;

FlatTree[CurrentNode].FromArgInfo.IsNullPtr = FromNullPtr;

FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;

FlatTree[CurrentNode].ToArgInfo.Val = ToInt;

FlatTree[CurrentNode].ToArgInfo.IsValidInt = IsValidToInt;

FlatTree[CurrentNode].ToArgInfo.ArgType = ToIntType;

FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;

SetDefault(FromDefault, ToDefault);

SetFromIntegerAndToDeclarationDiff(

llvm::APSInt &FromInt,

IsValidFromInt,

FromIntType,

ToNullPtr,

*ToExpr,

FromDefault,

ToDefault) {

assert(FlatTree[CurrentNode].Kind == Invalid &&

);

FlatTree[CurrentNode].Kind = FromIntegerAndToDeclaration;

FlatTree[CurrentNode].FromArgInfo.Val = FromInt;

FlatTree[CurrentNode].FromArgInfo.IsValidInt = IsValidFromInt;

FlatTree[CurrentNode].FromArgInfo.ArgType = FromIntType;

FlatTree[CurrentNode].FromArgInfo.ArgExpr = FromExpr;

FlatTree[CurrentNode].ToArgInfo.VD = ToValueDecl;

FlatTree[CurrentNode].ToArgInfo.NeedAddressOf = ToAddressOf;

FlatTree[CurrentNode].ToArgInfo.IsNullPtr = ToNullPtr;

FlatTree[CurrentNode].ToArgInfo.ArgExpr = ToExpr;

SetDefault(FromDefault, ToDefault);

SetDefault(

FromDefault,

ToDefault) {

assert((!FromDefault || !ToDefault) &&

);

FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;

FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;

SetSame(

Same) {

FlatTree[CurrentNode].Same =

;

SetKind(DiffKind Kind) {

FlatTree[CurrentNode].Kind =

;

assert(FlatTree[CurrentNode].Kind != Invalid &&

);

CurrentNode = FlatTree[CurrentNode].ParentNode;

assert(FlatTree[CurrentNode].Kind == Template &&

);

FlatTree.push_back(DiffNode(CurrentNode));

DiffNode &

= FlatTree[CurrentNode];

(

.ChildNode == 0) {

.ChildNode = NextFreeNode;

(i =

.ChildNode; FlatTree[i].NextNode != 0;

i = FlatTree[i].NextNode) {

FlatTree[i].NextNode = NextFreeNode;

CurrentNode = NextFreeNode;

StartTraverse() {

CurrentNode = NextFreeNode;

ReadNode = FlatTree[ReadNode].ParentNode;

assert(FlatTree[ReadNode].Kind == Template &&

);

FromTD = FlatTree[ReadNode].FromArgInfo.TD;

ToTD = FlatTree[ReadNode].ToArgInfo.TD;

FromQual = FlatTree[ReadNode].FromArgInfo.Qual;

ToQual = FlatTree[ReadNode].ToArgInfo.Qual;

assert(FlatTree[ReadNode].Kind ==

&&

);

FromType = FlatTree[ReadNode].FromArgInfo.ArgType;

ToType = FlatTree[ReadNode].ToArgInfo.ArgType;

GetExpressionDiff(

*&FromExpr,

*&ToExpr) {

assert(FlatTree[ReadNode].Kind ==

&&

);

FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;

ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;

assert(FlatTree[ReadNode].Kind == TemplateTemplate &&

);

FromTD = FlatTree[ReadNode].FromArgInfo.TD;

ToTD = FlatTree[ReadNode].ToArgInfo.TD;

GetIntegerDiff(llvm::APSInt &FromInt, llvm::APSInt &ToInt,

&IsValidFromInt,

&IsValidToInt,

assert(FlatTree[ReadNode].Kind == Integer &&

);

FromInt = FlatTree[ReadNode].FromArgInfo.Val;

ToInt = FlatTree[ReadNode].ToArgInfo.Val;

IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;

IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;

FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;

ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;

FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;

ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;

&FromAddressOf,

&ToAddressOf,

&FromNullPtr,

&ToNullPtr,

*&FromExpr,

assert(FlatTree[ReadNode].Kind == Declaration &&

);

FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;

ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;

FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;

ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;

FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;

ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;

FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;

ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;

GetFromDeclarationAndToIntegerDiff(

*&FromValueDecl,

&FromAddressOf,

&FromNullPtr,

*&FromExpr, llvm::APSInt &ToInt,

&IsValidToInt,

assert(FlatTree[ReadNode].Kind == FromDeclarationAndToInteger &&

);

FromValueDecl = FlatTree[ReadNode].FromArgInfo.VD;

FromAddressOf = FlatTree[ReadNode].FromArgInfo.NeedAddressOf;

FromNullPtr = FlatTree[ReadNode].FromArgInfo.IsNullPtr;

FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;

ToInt = FlatTree[ReadNode].ToArgInfo.Val;

IsValidToInt = FlatTree[ReadNode].ToArgInfo.IsValidInt;

ToIntType = FlatTree[ReadNode].ToArgInfo.ArgType;

ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;

GetFromIntegerAndToDeclarationDiff(

llvm::APSInt &FromInt,

&IsValidFromInt,

&FromIntType,

&ToNullPtr,

*&ToExpr) {

assert(FlatTree[ReadNode].Kind == FromIntegerAndToDeclaration &&

);

FromInt = FlatTree[ReadNode].FromArgInfo.Val;

IsValidFromInt = FlatTree[ReadNode].FromArgInfo.IsValidInt;

FromIntType = FlatTree[ReadNode].FromArgInfo.ArgType;

FromExpr = FlatTree[ReadNode].FromArgInfo.ArgExpr;

ToValueDecl = FlatTree[ReadNode].ToArgInfo.VD;

ToAddressOf = FlatTree[ReadNode].ToArgInfo.NeedAddressOf;

ToNullPtr = FlatTree[ReadNode].ToArgInfo.IsNullPtr;

ToExpr = FlatTree[ReadNode].ToArgInfo.ArgExpr;

FlatTree[ReadNode].FromArgInfo.IsDefault;

FlatTree[ReadNode].ToArgInfo.IsDefault;

FlatTree[ReadNode].Same;

FlatTree[ReadNode].ChildNode != 0;

ReadNode = FlatTree[ReadNode].ChildNode;

AdvanceSibling() {

(FlatTree[ReadNode].NextNode == 0)

ReadNode = FlatTree[ReadNode].NextNode;

HasNextSibling() {

FlatTree[ReadNode].NextNode != 0;

FlatTree[ReadNode].Kind;

InternalIterator {

: TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {

(isEnd())

;

(CurrentTA != EndTA)

;

isValid()

{

TST; }

isEnd()

{

assert(TST &&

);

InternalIterator &operator++() {

assert(TST &&

);

(CurrentTA != EndTA) {

(CurrentTA != EndTA)

(CurrentTA != EndTA)

assert(TST &&

);

assert(!isEnd() &&

);

(CurrentTA == EndTA)

pointer operator->()

{

assert(TST &&

);

InternalIterator SugaredIterator;

InternalIterator DesugaredIterator;

: SugaredIterator(TST),

(TST->isSugared() && !TST->isTypeAlias())

? GetTemplateSpecializationType(Context, TST->desugar())

TSTiterator &operator++() {

(DesugaredIterator.isValid())

++DesugaredIterator;

*SugaredIterator;

pointer operator->()

{

isEnd()

{

SugaredIterator.isEnd();

hasDesugaredTA()

{

DesugaredIterator.isValid() && !DesugaredIterator.isEnd();

reference getDesugaredTA()

{

assert(DesugaredIterator.isValid() &&

);

*DesugaredIterator;

Ty = SubstType->getReplacementType();

dyn_cast<ClassTemplateSpecializationDecl>(RT->

());

FromArgTST = GetTemplateSpecializationType(Context, FromType);

ToArgTST = GetTemplateSpecializationType(Context, ToType);

(!FromArgTST || !ToArgTST)

(!hasSameTemplate(Context, FromArgTST, ToArgTST))

DiffTypes(

TSTiterator &FromIter,

TSTiterator &ToIter) {

FromType = GetType(FromIter);

FromDefault = FromIter.isEnd() && !FromType.

();

ToDefault = ToIter.isEnd() && !ToType.

();

(OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {

.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);

assert(FromArgTST && ToArgTST &&

);

FromQual, ToQual, FromDefault, ToDefault);

DiffTemplate(FromArgTST, ToArgTST);

DiffTemplateTemplates(

TSTiterator &FromIter,

TSTiterator &ToIter) {

ToIter.isEnd() && ToDecl);

InitializeNonTypeDiffVariables(

&Context,

TSTiterator &

,

llvm::APSInt &

,

&HasInt,

&IntType,

&IsNullPtr,

&NeedAddressOf) {

(!

.isEnd()) {

(

->getKind()) {

IntType =

->getIntegralType();

VD =

->getAsDecl();

NeedAddressOf =

;

=

->getAsExpr();

llvm_unreachable(

);

llvm_unreachable(

);

}

(!

->isParameterPack()) {

=

->getDefaultArgument().getArgument().getAsExpr();

(!

.hasDesugaredTA())

NeedAddressOf =

;

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

DiffNonTypes(

TSTiterator &FromIter,

TSTiterator &ToIter,

*FromExpr =

, *ToExpr =

;

llvm::APSInt FromInt, ToInt;

*FromValueDecl =

, *ToValueDecl =

;

HasFromInt =

, HasToInt =

, FromNullPtr =

,

ToNullPtr =

, NeedFromAddressOf =

, NeedToAddressOf =

;

InitializeNonTypeDiffVariables(

Context, FromIter, FromDefaultNonTypeDecl, FromInt, HasFromInt,

FromIntType, FromNullPtr, FromExpr, FromValueDecl, NeedFromAddressOf);

InitializeNonTypeDiffVariables(Context, ToIter, ToDefaultNonTypeDecl, ToInt,

HasToInt, ToIntType, ToNullPtr, ToExpr,

ToValueDecl, NeedToAddressOf);

FromDefault = FromIter.isEnd() &&

(FromExpr || FromValueDecl || HasFromInt || FromNullPtr);

ToDefault = ToIter.isEnd() &&

(ToExpr || ToValueDecl || HasToInt || ToNullPtr);

FromDeclaration = FromValueDecl || FromNullPtr;

ToDeclaration = ToValueDecl || ToNullPtr;

(FromDeclaration && HasToInt) {

.SetFromDeclarationAndToIntegerDiff(

FromValueDecl, NeedFromAddressOf, FromNullPtr, FromExpr, ToInt,

HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);

.SetSame(

);

(HasFromInt && ToDeclaration) {

.SetFromIntegerAndToDeclarationDiff(

FromInt, HasFromInt, FromIntType, FromExpr, ToValueDecl,

NeedToAddressOf, ToNullPtr, ToExpr, FromDefault, ToDefault);

.SetSame(

);

(HasFromInt || HasToInt) {

.SetIntegerDiff(FromInt, ToInt, HasFromInt, HasToInt, FromIntType,

ToIntType, FromExpr, ToExpr, FromDefault, ToDefault);

(HasFromInt && HasToInt) {

(FromDeclaration || ToDeclaration) {

.SetDeclarationDiff(FromValueDecl, ToValueDecl, NeedFromAddressOf,

NeedToAddressOf, FromNullPtr, ToNullPtr, FromExpr,

ToExpr, FromDefault, ToDefault);

BothNull = FromNullPtr && ToNullPtr;

SameValueDecl =

FromValueDecl && ToValueDecl &&

NeedFromAddressOf == NeedToAddressOf &&

.SetSame(BothNull || SameValueDecl);

assert((FromExpr || ToExpr) &&

);

.SetExpressionDiff(FromExpr, ToExpr, FromDefault, ToDefault);

.SetSame(IsEqualExpr(Context, FromExpr, ToExpr));

TotalArgs = 0;

(TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);

!FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {

FromParamIndex = std::min(TotalArgs, ParamsFrom->

() - 1);

ToParamIndex = std::min(TotalArgs, ParamsTo->

() - 1);

);

(isa<TemplateTypeParmDecl>(FromParamND)) {

DiffTypes(FromIter, ToIter);

}

(isa<TemplateTemplateParmDecl>(FromParamND)) {

DiffTemplateTemplates(FromIter, ToIter);

}

(isa<NonTypeTemplateParmDecl>(FromParamND)) {

cast<NonTypeTemplateParmDecl>(FromParamND);

cast<NonTypeTemplateParmDecl>(ToParamND);

DiffNonTypes(FromIter, ToIter, FromDefaultNonTypeDecl,

ToDefaultNonTypeDecl);

llvm_unreachable(

);

makeTemplateList(

TemplateList.push_back(TST);

hasSameBaseTemplate(

&Context,

hasSameTemplate(

&Context,

(hasSameBaseTemplate(Context, FromTST, ToTST))

makeTemplateList(FromTemplateList, FromTST);

makeTemplateList(ToTemplateList, ToTST);

FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),

ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();

(!hasSameBaseTemplate(Context, *FromIter, *ToIter))

(; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {

(!hasSameBaseTemplate(Context, *FromIter, *ToIter))

FromTST = FromIter[-1];

(!

.isEnd())

->getAsType();

(

.hasDesugaredTA())

.getDesugaredTA().getAsType();

(!

.isEnd())

->getAsTemplate().getAsTemplateDecl();

(

.hasDesugaredTA())

.getDesugaredTA().getAsTemplate().getAsTemplateDecl();

(FromExpr == ToExpr)

(!FromExpr || !ToExpr)

llvm::FoldingSetNodeID FromID, ToID;

FromExpr->

(FromID, Context,

);

ToExpr->

(ToID, Context,

);

FromID == ToID;

TreeToString(

Indent = 1) {

OS.indent(2 * Indent);

(

.GetKind()) {

DiffTree::Invalid:

llvm_unreachable(

);

DiffTree::Type: {

.GetTypeDiff(FromType, ToType);

PrintTypeNames(FromType, ToType,

.FromDefault(),

.ToDefault(),

.NodeIsSame());

DiffTree::Expression: {

*FromExpr, *ToExpr;

.GetExpressionDiff(FromExpr, ToExpr);

PrintExpr(FromExpr, ToExpr,

.FromDefault(),

.ToDefault(),

.NodeIsSame());

DiffTree::TemplateTemplate: {

.GetTemplateTemplateDiff(FromTD, ToTD);

PrintTemplateTemplate(FromTD, ToTD,

.FromDefault(),

.ToDefault(),

.NodeIsSame());

DiffTree::Integer: {

llvm::APSInt FromInt, ToInt;

*FromExpr, *ToExpr;

IsValidFromInt, IsValidToInt;

.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,

FromIntType, ToIntType, FromExpr, ToExpr);

PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,

ToIntType, FromExpr, ToExpr,

.FromDefault(),

.ToDefault(),

.NodeIsSame());

DiffTree::Declaration: {

FromAddressOf, ToAddressOf;

FromNullPtr, ToNullPtr;

*FromExpr, *ToExpr;

.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,

ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,

PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,

FromNullPtr, ToNullPtr, FromExpr, ToExpr,

.FromDefault(),

.ToDefault(),

.NodeIsSame());

DiffTree::FromDeclarationAndToInteger: {

.GetFromDeclarationAndToIntegerDiff(

FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,

IsValidToInt, ToIntType, ToExpr);

assert((FromValueDecl || FromNullPtr) && IsValidToInt);

PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,

FromExpr,

.FromDefault(), ToInt, ToIntType,

ToExpr,

.ToDefault());

DiffTree::FromIntegerAndToDeclaration: {

llvm::APSInt FromInt;

IsValidFromInt;

.GetFromIntegerAndToDeclarationDiff(

FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,

ToAddressOf, ToNullPtr, ToExpr);

assert(IsValidFromInt && (ToValueDecl || ToNullPtr));

PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,

.FromDefault(), ToValueDecl, ToAddressOf,

ToNullPtr, ToExpr,

.ToDefault());

DiffTree::Template: {

.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);

PrintQualifiers(FromQual, ToQual);

(!

.HasChildren()) {

.MoveToChild();

NumElideArgs = 0;

AllArgsElided =

;

(

.NodeIsSame()) {

AllArgsElided =

;

(NumElideArgs > 0) {

PrintElideArgs(NumElideArgs, Indent);

TreeToString(Indent);

(

.HasNextSibling())

}

(

.AdvanceSibling());

(NumElideArgs > 0) {

PrintElideArgs(NumElideArgs, Indent);

assert(!IsBold &&

);

assert(IsBold &&

);

FromDefault,

ToDefault,

Same) {

);

PrintQualifiers(FromQual, ToQual);

std::string FromTypeStr = FromType.

() ?

std::string ToTypeStr = ToType.

() ?

(FromTypeStr == ToTypeStr) {

*FromElTy = dyn_cast<ElaboratedType>(FromType),

*ToElTy = dyn_cast<ElaboratedType>(ToType);

(FromElTy || ToElTy) {

std::string FromNamedTypeStr =

FromElTy ? FromElTy->getNamedType().getAsString(Policy)

std::string ToNamedTypeStr =

ToElTy ? ToElTy->getNamedType().getAsString(Policy) : ToTypeStr;

(FromNamedTypeStr != ToNamedTypeStr) {

FromTypeStr = FromNamedTypeStr;

ToTypeStr = ToNamedTypeStr;

std::string FromCanTypeStr =

(FromCanTypeStr != ToCanTypeStr) {

FromTypeStr = FromCanTypeStr;

ToTypeStr = ToCanTypeStr;

(PrintTree) OS <<

;

OS << (FromDefault ?

:

);

OS <<

<< (ToDefault ?

:

);

PrintExpr(

*FromExpr,

*ToExpr,

FromDefault,

ToDefault,

Same) {

assert((FromExpr || ToExpr) &&

);

PrintExpr(FromExpr);

}

(!PrintTree) {

OS << (FromDefault ?

:

);

PrintExpr(FromExpr);

OS << (FromDefault ?

:

);

PrintExpr(FromExpr);

OS <<

<< (ToDefault ?

:

);

PrintExpr(

*

) {

OS <<

;

FromDefault,

ToDefault,

Same) {

assert((FromTD || ToTD) &&

);

std::string FromName =

std::string(FromTD ? FromTD->

() :

);

std::string ToName = std::string(ToTD ? ToTD->

() :

);

(FromTD && ToTD && FromName == ToName) {

}

(!PrintTree) {

OS << (FromDefault ?

:

);

OS << (FromDefault ?

:

);

OS <<

<< (ToDefault ?

:

);

PrintAPSInt(

llvm::APSInt &FromInt,

llvm::APSInt &ToInt,

IsValidFromInt,

IsValidToInt,

FromIntType,

FromDefault,

ToDefault,

Same) {

assert((IsValidFromInt || IsValidToInt) &&

);

OS << ((FromInt == 0) ?

:

);

PrintType = IsValidFromInt && IsValidToInt &&

OS << (FromDefault ?

:

);

PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);

OS << (FromDefault ?

:

);

PrintAPSInt(FromInt, FromExpr, IsValidFromInt, FromIntType, PrintType);

OS <<

<< (ToDefault ?

:

);

PrintAPSInt(ToInt, ToExpr, IsValidToInt, ToIntType, PrintType);

PrintAPSInt(

llvm::APSInt &Val,

*

,

Valid,

IntType,

PrintType) {

(HasExtraInfo(

)) {

OS << ((Val == 0) ?

:

);

OS <<

;

HasExtraInfo(

*

) {

(!

)

;

CheckIntegerLiteral = [](

*

) {

(

*TemplateExpr = dyn_cast<SubstNonTypeTemplateParmExpr>(

))

= TemplateExpr->getReplacement();

isa<IntegerLiteral>(

);

(CheckIntegerLiteral(

))

;

(UO->getOpcode() == UO_Minus)

(CheckIntegerLiteral(UO->getSubExpr()))

(isa<CXXBoolLiteralExpr>(

))

PrintValueDecl(

*VD,

AddressOf,

*

,

NullPtr) {

(

*TPO = dyn_cast<TemplateParamObjectDecl>(VD)) {

TPO->getType().getUnqualifiedType().print(OS, Policy);

TPO->printAsInit(OS, Policy);

(

&& !isa<CXXNullPtrLiteralExpr>(

)) {

OS <<

;

FromAddressOf,

ToAddressOf,

FromNullPtr,

ToNullPtr,

*FromExpr,

*ToExpr,

FromDefault,

ToDefault,

Same) {

assert((FromValueDecl || FromNullPtr || ToValueDecl || ToNullPtr) &&

);

PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);

}

(!PrintTree) {

OS << (FromDefault ?

:

);

PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);

OS << (FromDefault ?

:

);

PrintValueDecl(FromValueDecl, FromAddressOf, FromExpr, FromNullPtr);

OS <<

<< (ToDefault ?

:

);

PrintValueDecl(ToValueDecl, ToAddressOf, ToExpr, ToNullPtr);

PrintValueDeclAndInteger(

*VD,

NeedAddressOf,

IsNullPtr,

*VDExpr,

DefaultDecl,

llvm::APSInt &Val,

IntType,

*IntExpr,

DefaultInt) {

OS << (DefaultDecl ?

:

);

PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);

OS << (DefaultDecl ?

:

);

PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);

OS <<

<< (DefaultInt ?

:

);

PrintAPSInt(Val, IntExpr,

, IntType,

);

PrintIntegerAndValueDecl(

llvm::APSInt &Val,

IntType,

NeedAddressOf,

IsNullPtr,

*VDExpr,

DefaultDecl) {

OS << (DefaultInt ?

:

);

PrintAPSInt(Val, IntExpr,

, IntType,

);

OS << (DefaultInt ?

:

);

PrintAPSInt(Val, IntExpr,

, IntType,

);

OS <<

<< (DefaultDecl ?

:

);

PrintValueDecl(VD, NeedAddressOf, VDExpr, IsNullPtr);

PrintElideArgs(

NumElideArgs,

Indent) {

(

i = 0; i < Indent; ++i)

(NumElideArgs == 0)

;

(NumElideArgs == 1)

OS <<

<< NumElideArgs <<

;

(FromQual == ToQual) {

PrintQualifier(FromQual,

);

(CommonQual.

() && FromQual.

()) {

OS <<

;

PrintQualifier(CommonQual,

);

PrintQualifier(FromQual,

);

(CommonQual.

() && ToQual.

()) {

OS <<

;

PrintQualifier(CommonQual,

,

PrintQualifier(ToQual,

,

PrintQualifier(CommonQual,

);

PrintQualifier(FromQual,

);

PrintQualifier(

Q,

ApplyBold,

AppendSpaceIfNonEmpty =

) {

(Q.

())

;

(ApplyBold)

();

Q.

(OS, Policy, AppendSpaceIfNonEmpty);

(ApplyBold) Unbold();

ToType,

PrintTree,

PrintFromType,

ElideType,

ShowColor)

Policy(Context.getLangOpts()),

ElideType(ElideType),

PrintTree(PrintTree),

ShowColor(ShowColor),

FromTemplateType(PrintFromType ? FromType : ToType),

ToTemplateType(PrintFromType ? ToType : FromType),

DiffTemplate() {

GetTemplateSpecializationType(Context, FromTemplateType);

GetTemplateSpecializationType(Context, ToTemplateType);

(!FromOrigTST || !ToOrigTST)

(!hasSameTemplate(Context, FromOrigTST, ToOrigTST)) {

.SetTemplateDiff(

FromQual, ToQual,

,

);

DiffTemplate(FromOrigTST, ToOrigTST);

.StartTraverse();

assert(!IsBold &&

);

PrintFromType,

ElideType,

PrintFromType =

;

TemplateDiff TD(OS, Context, FromType, ToType, PrintTree, PrintFromType,

Defines the clang::ASTContext interface.

static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType, QualType ToType, bool PrintTree, bool PrintFromType, bool ElideType, bool ShowColors, raw_ostream &OS)

FormatTemplateTypeDiff - A helper static function to start the template diff and return the properly ...

static std::string ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, ArrayRef< intptr_t > QualTypeVals)

Convert the given type to a string suitable for printing as part of a diagnostic.

This file provides some common utility functions for processing Lambda related AST Constructs.

clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

C Language Family Type Representation.

const NamedDecl * FromDecl

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

QualType getRValueReferenceType(QualType T) const

Return the uniqued reference to the type for an rvalue reference to the specified type.

QualType getBuiltinVaListType() const

Retrieve the type of the __builtin_va_list type.

QualType getObjCClassType() const

Represents the Objective-C Class type.

QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const

QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const

QualType getBuiltinMSVaListType() const

Retrieve the type of the __builtin_ms_va_list type.

QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const

Return a non-unique reference to the type for a variable array of the specified element type.

QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const

Return a K&R style C function type like 'int()'.

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

TemplateName getCanonicalTemplateName(TemplateName Name, bool IgnoreDeduced=false) const

Retrieves the "canonical" template name that refers to a given template.

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference to the specified type.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const

Return the unique reference to the type for a constant array of the specified element type.

const LangOptions & getLangOpts() const

QualType getObjCProtoType() const

Retrieve the type of the Objective-C Protocol class.

QualType getObjCSelType() const

Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.

QualType getObjCObjectPointerType(QualType OIT) const

Return a ObjCObjectPointerType type for the given ObjCObjectType.

QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const

Legacy interface: cannot provide type arguments or __kindof.

const clang::PrintingPolicy & getPrintingPolicy() const

QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const

Return a non-unique reference to the type for a dependently-sized array of the specified element type...

QualType getObjCIdType() const

Represents the Objective-CC id type.

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const

Return a unique reference to the type for an incomplete array of the specified element type.

Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.

Attr - This represents one attribute.

const char * getSpelling() const

An attributed type is a type to which a type attribute has been applied.

static std::optional< NullabilityKind > stripOuterNullability(QualType &T)

Strip off the top-level nullability annotation on the given type, if it's there.

Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.

Represents a class template specialization, which refers to a class template with a given set of temp...

ClassTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

const TemplateArgumentList & getTemplateArgs() const

Retrieve the template arguments of the class template specialization.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

bool isTranslationUnit() const

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

static DeclarationName getFromOpaqueInteger(uintptr_t P)

Get a declaration name from an opaque integer returned by getAsOpaqueInteger.

@ ak_nameddecl

NamedDecl *.

@ ak_declcontext

DeclContext *.

@ ak_addrspace

address space

@ ak_qualtype_pair

pair<QualType, QualType>

@ ak_declarationname

DeclarationName.

@ ak_nestednamespec

NestedNameSpecifier *.

Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...

This represents one expression.

Expr * IgnoreImpCasts() LLVM_READONLY

Skip past any implicit casts which might surround this expression until reaching a fixed point.

Represents a prototype with parameter type info, e.g.

ExtProtoInfo getExtProtoInfo() const

ArrayRef< QualType > param_types() const

FunctionType - C99 6.7.5.3 - Function Declarators.

An lvalue reference type, per C++11 [dcl.ref].

Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.

This represents a decl that may have a name.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

std::string getQualifiedNameAsString() const

virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const

Appends a human-readable name for this declaration into the given stream.

virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const

Pretty-print the unqualified name of this declaration.

Represents a C++ nested name specifier, such as "\::std::vector<int>::".

void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const

Print this nested name specifier to the given output stream.

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

Represents a pointer to an Objective C object.

Represents a class type in Objective C.

Sugar for parentheses used when specifying types.

PointerType - C99 6.7.5.1 - Pointer Declarators.

A (possibly-)qualified type.

QualType getLocalUnqualifiedType() const

Return this type with all of the instance-specific qualifiers removed, but without removing any quali...

bool isNull() const

Return true if this QualType doesn't point to a type yet.

static QualType getFromOpaquePtr(const void *Ptr)

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const

QualType getCanonicalType() const

static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)

Qualifiers getLocalQualifiers() const

Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...

A qualifier set is used to build a set of qualifiers.

const Type * strip(QualType type)

Collect any qualifiers on the given type and return an unqualified type.

QualType apply(const ASTContext &Context, QualType QT) const

Apply the collected qualifiers to the given type.

The collection of all-type qualifiers we support.

static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)

Returns the common set of qualifiers while removing them from the given sets.

void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const

std::string getAsString() const

static Qualifiers fromOpaqueValue(uint64_t opaque)

static std::string getAddrSpaceAsString(LangAS AS)

An rvalue reference type, per C++11 [dcl.ref].

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const

Produce a unique representation of the given statement.

Represents the result of substituting a type for a template type parameter.

ArrayRef< TemplateArgument > asArray() const

Produce this as an array ref.

Represents a template argument.

QualType getParamTypeForDecl() const

Expr * getAsExpr() const

Retrieve the template argument as an expression.

pack_iterator pack_end() const

Iterator referencing one past the last argument of a template argument pack.

pack_iterator pack_begin() const

Iterator referencing the first argument of a template argument pack.

llvm::APSInt getAsIntegral() const

Retrieve the template argument as an integral value.

QualType getIntegralType() const

Retrieve the type of the integral value.

ValueDecl * getAsDecl() const

Retrieve the declaration for a declaration non-type template argument.

@ Declaration

The template argument is a declaration that was provided for a pointer, reference,...

@ Template

The template argument is a template name that was provided for a template template parameter.

@ StructuralValue

The template argument is a non-type template argument that can't be represented by the special-case D...

@ Pack

The template argument is actually a parameter pack.

@ TemplateExpansion

The template argument is a pack expansion of a template name that was provided for a template templat...

@ NullPtr

The template argument is a null pointer or null pointer to member that was provided for a non-type te...

@ Type

The template argument is a type.

@ Null

Represents an empty template argument, e.g., one that has not been deduced.

@ Integral

The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...

@ Expression

The template argument is an expression, and we've not resolved it to one of the other forms yet,...

ArgKind getKind() const

Return the kind of stored template argument.

The base class of all kinds of template declarations (e.g., class, function, etc.).

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Represents a C++ template name within the type system.

TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const

Retrieve the underlying template declaration that this template name refers to, if known.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

Represents a type template specialization; the template must be a class template, a type alias templa...

QualType getAliasedType() const

Get the aliased type, if this is a specialization of a type alias template.

ArrayRef< TemplateArgument > template_arguments() const

TemplateName getTemplateName() const

Retrieve the name of the template that we are specializing.

bool isTypeAlias() const

Determine if this template specialization type is for a type alias template that has been substituted...

Represents a declaration of a type.

The base class of the type hierarchy.

bool isBooleanType() const

bool isPointerType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

TypeClass getTypeClass() const

const T * getAs() const

Member-template getAs<specific type>'.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a GCC generic vector type.

The JSON file list parser is used to communicate input to InstallAPI.

QualType desugarForDiagnostic(ASTContext &Context, QualType QT, bool &ShouldAKA)

Returns a desugared version of the QualType, and marks ShouldAKA as true whenever we remove significa...

bool isLambdaCallOperator(const CXXMethodDecl *MD)

LangAS

Defines the address space values used by the address space qualifier of QualType.

const char ToggleHighlight

Special character that the diagnostic printer will use to toggle the bold attribute.

void FormatASTNodeDiagnosticArgument(DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)

DiagnosticsEngine argument formatting function for diagnostics that involve AST nodes.

__INTPTR_TYPE__ intptr_t

A signed integer type with the property that any valid pointer to void can be converted to this type,...

Describes how types, statements, expressions, and declarations should be printed.

unsigned TemplateDiffUsed

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4